1
int head;     //头节点下标
2

3
int e[N];     //节点i的值，相当于结构体指针中的val
4

5
int ne[N];    //表示节点i的next指针是多少
6

7
int idx;      //当前用到哪个节点

1
void init()
2
{
3
    head = -1;
4
    idx = 0;
5
}

1
void add_at_head(int x)
2
{
3
    e[idx] = x;
4
    ne[idx] = head;
5
    head = idx;
6
    idx++;
7
}
8

9

10
void add_at_k(int x , int k)
11
{
12
    e[k] = x;
13
    ne[idx] = ne[k];
14
    ne[k] = idx;
15
    idx++;
16
}
17

18
void remove(int k) //删除第k个点后面的点
19
{
20
    ne[k] = ne[ne[k]];
21
}
22
### 结构体指针
23

24

25
```cpp
26
typedef struct ListNode {
27
    int data;
28
    ListNode* next;
29
} Node;
30

31
//创建新节点
32

33
Node* createNode(int data)
34
{
35
    Node* newNode = (Node*) malloc(sizeof(Node));
36
    newNode->data = data;
37
    newNode->next = NULL;
38
    return newNode;
39
}
40

41
//头插
42

43
void insertAtHead(Node** head , int x)
44
{
45
    Node* newNode = createNode(x);
46
    newNode ->next = *head;
47
    *head = newNode;
48
}
49
#### 有同学可能会问：什么是*head ，什么是**head ？
50

51

52
在Node*head中，head是一个只想Node结构体的指针，他储存着链表头节点的地址，*head 代表作着Node结构，也就是头节点本身。
53

54

55
如果head指向某个节点，那么head存的是地址，*head存的是节点的内容（data和next）。
56

57

58
而**head，是一个指向head指针的指针。因为如果要在函数内部修改head值，必须传递指针的指针。
59

60

61
因此在程序中，head是头指针的地址。  *head是头指针本身，储存着链表第一个头节点地址。
62

63

64
**newNode-.next = *head;  让新节点的next指向当前head所指向头节点**
65

66

67
***head= newNode； 让head指向newNode，使新节点成为链表新的头节点**
68

69

70
-----------------------------------------------------------------------------------------------
71

72

73
```cpp
74
//删除指定值节点
75

76
void deleteNode(Node** head, int x)
77
{
78
    Node* temp = *head, *prev = NULL;
79
    if(temp != NULL && temp -> data == x){ //如果头节点是要删除的节点
80
        *head = temp -> next;
81
        free(temp);
82
        return;
83
    }
84
    while(temp != NULL && temp -> data != x){
85
        prev = temp;
86
        temp = temp -> next;
87
    }
88
    if(temp == NULL) return;
89
    prev -> next = temp -> next;
90
    free(temp);
91
}

1
void deleteNode(Node** head, int x) {
2
    Node* temp = *head;
3
    Node* prev = NULL;
4

5
    while (temp != NULL && temp->val != x) {
6
        prev = temp;
7
        temp = temp->next;
8
    }
9

10
    if (temp == NULL) return;  // 没找到
11

12
    prev->next = temp->next;  // 试图删除
13
    free(temp);
14
}

1
//更新指定值的节点
2

3
void updateNode(Node* head, int x, int newData)
4
{
5
    Node* temp = head;
6
    while(temp != NULL && temp -> data != x){
7
        temp = temp -> next;
8
    }
9
    if(temp == NULL) return;
10
    temp -> data = newData;
11
}

1
//查找指定值的节点
2

3
Node* searchNode(Node* head,int x)
4
{
5
    Node* temp = head;
6
    while(temp != NULL)
7
    {
8
        if(temp -> data == x)   return temp;
9
        temp = temp -> next;
10
    }
11
    return NULL;
12
}

1
void reverseList(Node** head)
2
{
3
    Node* prev = NULL;
4
    Node* next = NULL;
5
    Node* current = *head;
6
    while(current != NULL){
7
        next = current -> next;  //记录下一个节点
8
        current -> next = prev;    //反转指针
9
        prev = current;            //更新prev
10
        current = next;            //移动current
11
    }
12
    *head = prev;                    //更新头节点
13
}

1
head -> [1] -> [2] -> [3] -> [4] -> NULL

1
head -> [4] -> [3] -> [2] -> [1] -> NULL
2
//成功反转

1
//递归反转链表
2

3
Node* reverse(Node* head) {
4
    if (head == NULL || head->next == NULL) {
5
        return head;
6
    }
7
    Node* newHead = reverse(head->next);  // 递归反转后续链表
8
    head->next->next = head;               // 将当前节点反向指向前一个节点
9
    head->next = NULL;                     // 当前节点变为新链表的尾节点
10
    return newHead;                        // 返回反转后的新头节点
11
}