0%

#01 链表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/***
**************************************************************
* *
* .=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-. *
* | ______ | *
* | .-" "-. | *
* | / \ | *
* | _ | | _ | *
* | ( \ |, .-. .-. ,| / ) | *
* | > "=._ | )(__/ \__)( | _.=" < | *
* | (_/"=._"=._ |/ /\ \| _.="_.="\_) | *
* | "=._"(_ ^^ _)"_.=" | *
* | "=\__|IIIIII|__/=" | *
* | _.="| \IIIIII/ |"=._ | *
* | _ _.="_.="\ /"=._"=._ _ | *
* | ( \_.="_.=" `--------` "=._"=._/ ) | *
* | > _.=" "=._ < | *
* | (_/ \_) | *
* | | *
* '-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=' *
* *
* 单链表 循环链表 双向链表 循环双向链表 *
**************************************************************
*/

单链表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

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

Node *initList() {
Node *L = (Node *)malloc(sizeof(Node));
L->data = 0;
L->next = NULL;

return L;
}

void headInsert(Node *L, int data) {
Node *node = (Node *)malloc(sizeof(Node));
node->data = data;
node->next = L->next;
L->next = node;
}

void printList(Node *L) {
Node *node = L->next;
printf("HEAD(%d) ", L->data);
while (node) {
printf("-> %d ", node->data);
node = node->next;
L->data++;
}
printf("\n");
}

void tailInsert(Node *L, int data) {
Node *head = L;
while (head->next != NULL)
head = head->next;

Node *node = (Node *)malloc(sizeof(Node));
node->data = data;
node->next = NULL;

head->next = node;
L->data++;
}

bool deleteNode(Node *L, int data) {
Node *preNode = L;
Node *node = L->next;

while (node) {
if (node->data == data) {
preNode->next = node->next;
free(node);
L->data--;
return true;
}
preNode = node;
node = node->next;
}
return false;
}

int main(int argc, char **argv) {
Node *L = initList();

headInsert(L, 1);
headInsert(L, 2);
headInsert(L, 3);
headInsert(L, 4);
headInsert(L, 5);
headInsert(L, 6);
headInsert(L, 7);
headInsert(L, 8);

printList(L);

tailInsert(L, 20);
tailInsert(L, 21);
printList(L);

deleteNode(L, 1);
printList(L);

return 0;
}

循环链表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

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

} Node;

Node *initList() {
Node *L = (Node *)malloc(sizeof(Node));
L->data = 0;
L->next = L;

return L;
}

void headInsert(Node *L, int data) {
Node *node = (Node *)malloc(sizeof(Node));

node->data = data;
node->next = L->next;
L->next = node;

L->data++;
}

void printList(Node *L) {
Node *node = L->next;

printf("HEAD(%d) -> ", L->data);
while (node != L) {
printf("%d -> ", node->data);
node = node->next;
}
printf("HEAD\n");
}

void tailInsert(Node *L, int data) {
Node *node = (Node *)malloc(sizeof(Node));
node->data = data;

Node *head = L;

while (head->next != L)
head = head->next;

node->next = head->next;
head->next = node;

L->data++;
}

bool deleteNode(Node *L, int data) {
Node *preNode = L, *node = L->next;

while (node != L) {
if (node->data == data) {
preNode->next = node->next;
free(node);
L->data--;
return true;
}

preNode = node;
node = node->next;
}

return false;
}

int main(int argc, char **argv) {
Node *L = initList();

headInsert(L, 1);
headInsert(L, 2);
headInsert(L, 3);
printList(L);

tailInsert(L, 7);
tailInsert(L, 8);
tailInsert(L, 9);
printList(L);

deleteNode(L, 1);
printList(L);

return 0;
}

双向链表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

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

Node *initList() {
Node *L = (Node *)malloc(sizeof(Node));

L->data = 0;
L->pre = NULL;
L->next = NULL;

return L;
}

void headInsert(Node *L, int data) {
Node *node = (Node *)malloc(sizeof(Node));
node->data = data;

node->pre = L;
node->next = L->next;

if (L->data == 0) {
L->next = node;
} else {
L->next->pre = node;
L->next = node;
}

L->data++;
}

void printList(Node *L) {
Node *node = L->next;
printf("HEAD(%d) ", L->data);
while (node) {
printf("<-> %d ", node->data);
node = node->next;
}
printf("\n");
}

void tailInsert(Node *L, int data) {
Node *node = (Node *)malloc(sizeof(Node));
node->data = data;

Node *head = L;
while (head->next != NULL) {
head = head->next;
}

head->next = node;
node->pre = head;
node->next = NULL;

L->data++;
}

bool deleteNode(Node *L, int data) {
Node *node = L->next;

while (node) {
if (node->data == data) {
node->pre->next = node->next;
if (node->next != NULL)
node->next->pre = node->pre;
free(node);
L->data--;
return true;
}
node = node->next;
}

return false;
}

int main(int argc, char **argv) {
Node *L = initList();

headInsert(L, 1);
headInsert(L, 2);
headInsert(L, 3);

printList(L);

tailInsert(L, 7);
tailInsert(L, 8);
tailInsert(L, 9);
printList(L);

deleteNode(L, 9);
printList(L);

return 0;
}

循环双向链表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

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

Node *initList() {
Node *L = (Node *)malloc(sizeof(Node));
L->data = 0;
L->next = L;
L->pre = L;

return L;
}

void headInsert(Node *L, int data) {
Node *node = (Node *)malloc(sizeof(Node));
node->data = data;

node->next = L->next;
node->pre = L;
L->next->pre = node;
L->next = node;

L->data++;
}

bool deleteNode(Node *L, int data) {
Node *node = L->next;

while (node != L) {
if (node->data == data) {
node->pre->next = node->next;
node->next->pre = node->pre;
free(node);
L->data--;
return true;
}
node = node->next;
}

return false;
}

void printList(Node *L) {
Node *node = L->next;

printf("HEAD(%d) <-> ", L->data);
while (node != L) {
printf("%d <-> ", node->data);
node = node->next;
}
printf("HEAD\n");
}

void tailInsert(Node *L, int data) {
Node *node = (Node *)malloc(sizeof(Node));
node->data = data;

Node *head = L;
while (head->next != L) {
head = head->next;
}

node->next = head->next;
node->pre = head;
head->next->pre = node;
head->next = node;

L->data++;
}

int main(int argc, char **argv) {
Node *L = initList();

headInsert(L, 1);
headInsert(L, 2);
headInsert(L, 3);
printList(L);

tailInsert(L, 7);
tailInsert(L, 8);
tailInsert(L, 9);
printList(L);

deleteNode(L, 3);
printList(L);

return 0;
}