数据结构——动态链表（C++）

定义一个节点：

[cpp] view plain copy

 

print?

1. #include <iostream>
2. using namespace std;
3. typedef int T;
4. struct Node{
5. T data;
6. Node* next;
7. Node(const T& d):data(d), next(NULL){}
8. operator T(){
9. return data;
10. }
11. };
12. int main(){
13. Node a(10), b(20);
14. cout << "a=" << a << ", b=" << b << endl;
15. return 0;
16. }

上面的运算符重载，先将a类型强转为T类型（也就是int),Java中的toString实际上就是类似的强转成string类型的。

输出一段简单的链表

[cpp] view plain copy

 

print?

1. #include <iostream>
2. using namespace std;
3. typedef int T;
4. struct Node{
5. T data;
6. Node* next;
7. Node(const T& d):data(d), next(NULL){}
8. operator T(){
9. return data;
10. }
11. };
12. int main(){
13. Node a(10), b(20), c(30), d(40), e(50);
14. a.next = &b;
15. b.next = &c;
16. c.next = &d;
17. Node *p = &a;
18. while(p != NULL){
19. cout << *p << ' ';
20. p = p->next;
21. }
22. cout << endl;
23. return 0;
24. }

给链表添加一个元素

[cpp] view plain copy

 

print?

1. #include <iostream>
2. using namespace std;
3. typedef int T;
4. struct Node{
5. T data;
6. Node* next;
7. Node(const T& d):data(d), next(NULL){}
8. operator T(){
9. return data;
10. }
11. };
12. //输出链表
13. void showlist(Node* p){
14. while(p != NULL){
15. cout << *p << ' ';
16. p = p->next;
17. }
18. cout << endl;
19. }
20. int main(){
21. Node a(10), b(20), c(30), d(40), e(50);
22. a.next = &b;
23. b.next = &c;
24. c.next = &d;
25. showlist(&a);
26. //添加一个节点
27. Node* & p = b.next;//取b.next指针的别名
28. e.next = p;
29. p = &e;
30. showlist(&a);
31. //再添加一个节点
32. Node* k = new Node(70);
33. Node*& r = c.next;
34. k->next = r;
35. r = k;
36. return 0;
37. }

一个C++实现的链表如下：

[cpp] view plain copy

 

print?

1. #include <iostream>
2. using namespace std;
3. typedef int T;
4. class List{
5. struct Node{
6. T data;
7. Node * next;
8. //T()零初始化
9. Node(const T& d=T()):data(d), next(0){}
10. };
11. Node * head; //头指针
12. int len;
13. public:
14. List():head(NULL),len(0){ }
15. //插入到任何位置
16. //1、在链表里找到指向那个位置的指针pn
17. //2、让新节点的next成员和pn指向同一个地方
18. //3、再让pn指向新节点
19. void insert(const T&d, int pos){
20. Node*& pn = getptr(pos);
21. Node* p = new Node(d);
22. p->next = pn;
23. pn = p;
24. len++;
25. }
26. //返回链表长度
27. int size()const{
28. return len;
29. }
30. //尾插
31. void push_back(const T& d){
32. insert(d, size());
33. }
34. //找链表中指向指定位置的指针
35. Node*& getptr(int pos){
36. if(pos<0 || pos>size()) pos = 0;
37. if(pos==0) return head;
38. Node* p = head;
39. for(int i=1; i<pos; i++)
40. p = p->next;
41. return p->next;
42. }
43. //前插
44. void push_front(const T& d){
45. insert(d, 0);
46. }
47. //遍历
48. void travel()const{
49. Node* p = head;
50. while(p!=NULL){
51. cout << p->data << ' ';
52. p = p->next;
53. }
54. cout << endl;
55. }
56. //清空
57. void clear(){
58. while(head!=NULL){
59. Node * p = head->next;
60. delete head;
61. head = p;
62. }
63. len = 0;
64. }
65. ~List(){
66. clear();
67. }
68. //按照位置删除
69. //1、找到链表中指向那个位置的指针
70. //2、把那个指针另存一份
71. //3、让那个指针指向下一个节点
72. //4、释放那个指针的动态内存
73. void erase(int pos){
74. if(pos<0 || pos>=size()) return;
75. Node *& pn = getptr(pos);
76. Node * p = pn;
77. pn = pn->next;
78. delete p;
79. --len;
80. }
81. //根据元素查找位置
82. int find(const T& d)const{
83. int pos = 0;
84. Node* p = head;
85. while(p){
86. if(p->data==d) return pos;
87. p = p->next;
88. ++pos;
89. }
90. return -1;
91. }
92. //根据元素删除
93. void remove(const T& d){
94. int pos;
95. while((pos = find(d)) != -1)
96. erase(pos);
97. }
98. };
99. int main(){
100. List l;
101. l.push_front(5);
102. l.push_front(8);
103. l.push_front(20);
104. //在第2个位置插入9
105. l.insert(9, 2);
106. l.travel();
107. return 0;
108. }

通过上图可以看出来，如果我们要插入一个节点，就需要找到指向该位置的指针（或者前一个结点），比如上图的p->next指针就是我们需要找到的。删除一个节点也一样，需要找到指向该节点的指针。

原文转自：http://www.tuicool.com/articles/nA7VjmU

原作者为 dawanganban. 请尊重原作者版权