0
点赞
收藏
分享

微信扫一扫

记一次linux操作系统实验

沈芏 2023-11-24 阅读 13
算法数据结构c语言python链表

文章目录

主要内容

  1. 单链表
  2. 双链表和循环链表

一.单链表

1.头插法建立单链表

代码如下（示例）:

C语言代码：

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* createListByHeadInsert(int arr[], int n) {
    Node* head = (Node*)malloc(sizeof(Node));
    head->next = NULL;

    for (int i = 0; i < n; i++) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = arr[i];
        newNode->next = head->next;
        head->next = newNode;
    }

    return head;
}

Python代码：

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def create_list_by_head_insert(arr):
    head = Node(None)

    for data in arr:
        new_node = Node(data)
        new_node.next = head.next
        head.next = new_node

    return head

2.尾插法建立单链表

代码如下（示例）:

C语言代码：

Node* createListByTailInsert(int arr[], int n) {
    Node* head = (Node*)malloc(sizeof(Node));
    head->next = NULL;
    Node* tail = head;

    for (int i = 0; i < n; i++) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = arr[i];
        newNode->next = NULL;
        tail->next = newNode;
        tail = newNode;
    }

    return head;
}

Python代码：

def create_list_by_tail_insert(arr):
    head = Node(None)
    tail = head

    for data in arr:
        new_node = Node(data)
        tail.next = new_node
        tail = new_node

    return head

3.按序号查找结点值

代码如下（示例）:

C语言代码：

int getElemByIndex(Node* head, int index) {
    Node* p = head->next;
    int i = 1;

    while (p && i < index) {
        p = p->next;
        i++;
    }

    if (!p || i > index) {
        return -1;
    }

    return p->data;
}

Python代码：

def get_elem_by_index(head, index):
    p = head.next
    i = 1

    while p and i < index:
        p = p.next
        i += 1

    if not p or i > index:
        return -1

    return p.data

4.按值查找表结点

代码如下（示例）:

C语言代码：

Node* locateElem(Node* head, int value) {
    Node* p = head->next;

    while (p && p->data != value) {
        p = p->next;
    }

    return p;
}

Python代码：

def locate_elem(head, value):
    p = head.next

    while p and p.data != value:
        p = p.next

    return p

5.插入节点操作

代码如下（示例）:

C语言代码：

void insertElem(Node* head, int index, int value) {
    Node* p = head;
    int i = 0;

    while (p && i < index - 1) {
        p = p->next;
        i++;
    }

    if (!p || i > index - 1) {
        return;
    }

    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = p->next;
    p->next = newNode;
}

Python代码：

def insert_elem(head, index, value):
    p = head
    i = 0

    while p and i < index - 1:
        p = p.next
        i += 1

    if not p or i > index - 1:
        return

    new_node = Node(value)
    new_node.next = p.next
    p.next = new_node

6.删除结点操作

代码如下（示例）:

C语言代码：

void deleteElem(Node* head, int value) {
    Node* p = head;
    while (p->next && p->next->data != value) {
        p = p->next;
    }

    if (p->next) {
        Node* temp = p->next;
        p->next = temp->next;
        free(temp);
    }
}

Python代码：

def delete_elem(head, value):
    p = head
    while p.next and p.next.data != value:
        p = p.next

    if p.next:
        temp = p.next
        p.next = temp.next
        del temp

7.求表长操作

代码如下（示例）:

C语言代码：

int getLength(Node* head) {
    Node* p = head->next;
    int length = 0;
    while (p) {
        length++;
        p = p->next;
    }
    return length;
}

Python代码：

def get_length(head):
    p = head.next
    length = 0
    while p:
        length += 1
        p = p.next
    return length

二.双链表和循环链表

1.双链表的插入操作

代码如下（示例）:

C语言实现：

void insertNode(struct Node* prevNode, int newData) {
    if (prevNode == NULL) {
        printf("The given previous node cannot be NULL");
        return;
    }
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = newData;
    newNode->next = prevNode->next;
    prevNode->next = newNode;
    newNode->prev = prevNode;
    if (newNode->next != NULL) {
        newNode->next->prev = newNode;
    }
}

Python实现：

def insertNode(prev_node, new_data):
    if prev_node is None:
        print("The given previous node cannot be NULL")
        return
    new_node = Node(new_data)
    new_node.next = prev_node.next
    prev_node.next = new_node
    new_node.prev = prev_node
    if new_node.next is not None:
        new_node.next.prev = new_node

2.双链表的删除操作

代码如下（示例）:

C语言实现：

void deleteNode(struct Node** head_ref, struct Node* del) {
    if (*head_ref == NULL || del == NULL) {
        return;
    }
    if (*head_ref == del) {
        *head_ref = del->next;
    }
    if (del->next != NULL) {
        del->next->prev = del->prev;
    }
    if (del->prev != NULL) {
        del->prev->next = del->next;
    }
    free(del);
}

Python实现：

def deleteNode(head_ref, del_node):
    if head_ref is None or del_node is None:
        return
    if head_ref == del_node:
        head_ref = del_node.next
    if del_node.next is not None:
        del_node.next.prev = del_node.prev
    if del_node.prev is not None:
        del_node.prev.next = del_node.next
    del_node = None

3.循环单链表

代码如下（示例）:

C语言实现：

struct Node {
    int data;
    struct Node* next;
};

void insertNode(struct Node** head_ref, int newData) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    struct Node* last = *head_ref;
    newNode->data = newData;
    newNode->next = *head_ref;
    if (*head_ref == NULL) {
        newNode->next = newNode;
    } else {
        while (last->next != *head_ref) {
            last = last->next;
        }
        last->next = newNode;
    }
    *head_ref = newNode;
}

Python实现：

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def insertNode(head_ref, new_data):
    new_node = Node(new_data)
    last = head_ref
    new_node.next = head_ref
    if head_ref is None:
        new_node.next = new_node
    else:
        while last.next != head_ref:
            last = last.next
        last.next = new_node
    head_ref = new_node

4.循环双链表的插入操作

代码如下（示例）:

C语言实现：

typedef struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
} Node;

void insert(Node* head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->prev = head;
    newNode->next = head->next;
    head->next->prev = newNode;
    head->next = newNode;
}

Python实现：

class Node:
    def __init__(self, data):
        self.data = data
        self.prev = None
        self.next = None

def insert(head, data):
    new_node = Node(data)
    new_node.prev = head
    new_node.next = head.next
    head.next.prev = new_node
    head.next = new_node

5.循环双链表的删除操作

代码如下（示例）:

C语言实现：

void delete(Node* node) {
    node->prev->next = node->next;
    node->next->prev = node->prev;
    free(node);
}

Python实现：

def delete(node):
    node.prev.next = node.next
    node.next.prev = node.prev

6.静态链表的基本操作

代码如下（示例）:

C语言实现：

#define MAX_SIZE 100
typedef struct {
    int data;
    int next;
} Node;

int allocate(Node* arr) {
    int i = arr[0].next;
    if (i != -1) {
        arr[0].next = arr[i].next;
    }
    return i;
}

void deallocate(Node* arr, int i) {
    arr[i].next = arr[0].next;
    arr[0].next = i;
}

Python实现：

MAX_SIZE = 100
class Node:
    def __init__(self, data, next):
        self.data = data
        self.next = next

def allocate(arr):
    i = arr[0].next
    if i != -1:
        arr[0].next = arr[i].next
    return i

def deallocate(arr, i):
    arr[i].next = arr[0].next
    arr[0].next = i

总结

以上是今天要讲的内容，学到了链式表中单链表、双链表、循环链表和静态链表的相关操作。
线性表–链式表-1

举报

相关推荐

Linux操作系统系列：记一次非Lvm文件系统空间扩容

文件系统linux非LVM扩容ext4resize2fsLinux系统/运维yyds干货盘点

Linux 操作系统 实验

物联网

【linux kernel】记一次linux内核裁剪总结

linuxlinux 内核文件系统linux内核裁剪c

记一次ubuntu安装WGCLOUD监控系统

日记本wgcloud...

记一次configmap报错

configmap 更新kubernetes云计算

【操作系统】实验楼操作系统实验三——系统调用

linux运维服务器

记一次mysql作业

sql数据库学习作业MySQLyyds干货盘点

记一次分析接口

服务器链路表结构Java编程语言

记一次入侵排查

安全

记一次CPU 100%

死循环java数据编程语言
0 条评论