一个简单的链表类

1. #include <iostream>
2. #include <stack>
3. using namespace std;
4. class Linklist
5. {
6. private:
7.     typedef struct NODE
8.     {
9.         int data;
10.         NODE* next;
11.         NODE(int data, NODE* next)
12.         {
13.             this->data = data;
14.             this->next = next;
15.         }
16.     };
17.     
18. private:
19.     NODE* head;
20.     
21. public:
22.     //默认构造函数
23.     Linklist(int n=10)
24.     {
25.         NODE* p = new NODE(-1,0);
26.         head = p;
27.         
28.         int i = 0;
29.         while (i<n)
30.         {
31.             int k = 0;
32.             cout << "input the NODE of " << i+1 << ":";
33.             cin >> k;
34.             
35.             NODE* t_ptr = new NODE(k,0);
36.             p->next = t_ptr;
37.             p = p->next;
39.             i++;
40.         }   
41.     }
42.     
43.     //析构函数
44.     ~Linklist()
45.     {
46.         stack<NODE*> ptr_stack;
47.         NODE* ptr = head;
48.         while (0 != ptr)
49.         {
50.             ptr_stack.push(ptr);
51.             ptr = ptr->next;
52.         }
54.         while (!ptr_stack.empty())
55.         {
56.             delete ptr_stack.top();
57.             ptr_stack.pop();
58.         }
59.     }
61.     //打印链表
62.     void display()
63.     {
64.         NODE* p = head->next;
65.         while (0 != p)
66.         {
67.             cout << (p->data) << endl;
68.             p = p->next;
69.         }
70.     }
71.     
72.     //链表反转
73.     void antitone()
74.     {
75.         stack<NODE*> ptr_stack;
76.         NODE* ptr = head->next;
77.         while (ptr)
78.         {
79.             ptr_stack.push(ptr);
80.             ptr = ptr->next;
81.         }
82.         head->next = ptr_stack.top();
83.         ptr_stack.pop();
84.         ptr = head->next;
85.         ptr->next = 0;
86.         
87.         while (!ptr_stack.empty())
88.         {
89.             ptr->next = ptr_stack.top();
90.             ptr_stack.pop();
91.             ptr = ptr->next;
92.             ptr->next = 0;
93.         }
94.     }
95.     
96.     //数据data第一次出现的后面插入一个节点 
97.     bool insertNODE(int data)
98.     {
99.         NODE* ptr = get_ptr(data);
100.         if (ptr)
101.         {
102.             cout << "input the data of you wanna insert:";
103.             int k = 0;
104.             cin >> k;
105.             NODE* node = new NODE(k,0);
106.             node->next = ptr->next;
107.             ptr->next = node;
108.             return true;
109.         }
110.         return false;
111.     }
112.     
113.     //获得节点的个数
114.     int getDataNum()
115.     {
116.         NODE* ptr = head->next;
117.         int num=0;
118.         while(ptr)
119.         {
120.             num++;
121.             ptr = ptr->next;
122.         }
123.         return num;
124.     }
125.     
126.     //链表排序
127.     void sort()
128.     {
129.         int num = getDataNum();
130.         int* arr = new int[num];
131.         NODE* ptr = head->next;
132.         
133.         for (int i = 0; i<num; i++)
134.         {
135.             arr[i] = ptr->data;
136.             ptr = ptr->next;
137.         }
138.         
139.         //冒泡
140.         for (int i=0; i<num; i++)
141.             for (int j=i+1; j<num; j++)
142.                 if(arr[i]>arr[j])
143.                 {
144.                     int tmp = arr[j];
145.                     arr[j] = arr[i];
146.                     arr[i] = tmp;
147.                 }
148.         
149.         ptr = head->next;
150.         for (int i=0; i< num; i++)
151.         {
152.             ptr->data = arr[i];
153.             ptr = ptr->next;
154.         }
155.         delete []arr;
156.     }
157.     
158.     //删除data第一次出现的节点
159.     bool deleteNODE(int data)
160.     {
161.         NODE* ptr_1 = head;
162.         NODE* ptr_2 = head->next;
163.         
164.         while (ptr_2 && (ptr_2->data != data))
165.         {
166.             ptr_1 = ptr_1->next;
167.             ptr_2 = ptr_2->next;
168.         }
169.         
170.         if (ptr_2)
171.         {
172.             ptr_1->next = ptr_1->next->next;
173.             delete ptr_2;
174.             return true;
175.         }
176.         return false;
177.     }
178.     
179. private:
180.     //获得数据为data第一次出现的节点的指针值
181.     NODE* get_ptr(int data)
182.     {
183.         NODE* ptr = head->next;
184.         while (ptr&&((ptr->data) != data))
185.             ptr = ptr->next;
186.         if (!ptr)
187.             return 0;
188.         return ptr;
189.     }
190. };
192. int main()
193. {
194.     Linklist linklist = Linklist(20);
195.     linklist.display();
196.     linklist.sort();
197.     cout << "---------/n";
198.     linklist.display();
199.     return 0;
200. }