C++數據結構之傳統單鏈表

時間 2019-12-08

標籤 c++ 數據結構傳統鏈表欄目 C&C++ 简体版

原文原文鏈接

　　這幾天有空重寫一下數據結構，從單鏈表開始吧，這個是C++版本的，後面會根據狀況是否補充上C版本的。ios

這個文章寫了以後，也查看了網絡上其餘的數據結構寫法，發現你們的寫法多多少少都有一些不同的地方，而網絡

個人寫法也和你們多多少少有一些不同的地方，歡迎你們參閱，若是有問題請幫忙指正，我會盡力修改，但願數據結構

你們可以一塊兒進步！謝謝！ide

LinkList.h頭文件函數

 1 #pragma once
 2 #include<iostream>
 3 using namespace std;
 4 
 5 class LinkNode
 6 {
 7 public:
 8     int data;
 9     LinkNode* next;
10 };
11 
12 class LinkList
13 {
14 public:
15     LinkList();
16 
17     //插入操做
18     void InsertLinkNodeByPox(int pox, int val);
19 
20     //根據值刪除元素
21     void RemoveLinkNodeByVal(int val);
22 
23     //根據位置刪除元素
24     void RemoveLinkNodeByPox(int pox);
25 
26     //反轉鏈表  方法1 這個是我第一時候寫的，方法比表原始，原本準備刪除的，不過畢竟是心血，仍是放上面把。。。。。。  較笨拙，不推薦。。
27     void reverse();
28 
29     //反轉鏈表  方法1  這個簡單  非遞歸方法
30     void reverseSimply();  //方法簡單！
31 
32     //遞歸實現鏈表反轉
33     LinkNode* reserveByRecursion(LinkNode* hd);
34 
35     //遍歷鏈表
36     void ForEachLinkList();
37 
38     //根據值查找節點的位置
39     LinkNode* FindVal(int val);
40 
41     //返回長度
42     int LinkListLength();
43 
44 
45     //清空鏈表
46     void clearList();
47 
48     //析構函數
49     ~LinkList();
50     
51 public:
52     LinkNode* head;
53 
54     int length;
55 };

LinkList.cpp實現文件this

  1 #include "LinkList.h"
  2 
  3 LinkList::LinkList()
  4 {
  5     this->length = 0;
  6     this->head = new LinkNode;
  7     head->data = -1;
  8     head->next = NULL;
  9 }
 10 
 11 void LinkList::InsertLinkNodeByPox(int pox, int val)
 12 {
 13     if (pox < 0 || pox > this->length)
 14     {
 15         pox = this->length;
 16     }
 17     
 18     LinkNode* pcurNode = this->head;
 19 
 20     //找到插入位置的前一個節點
 21     for (int i = 0; i < pox; ++i)
 22     {
 23         pcurNode = pcurNode->next;
 24     }
 25     LinkNode* newNode = new LinkNode;
 26     newNode->data = val;
 27     newNode->next = pcurNode->next;
 28     pcurNode->next = newNode;
 29 
 30     this->length++;
 31 }
 32 
 33 void LinkList::RemoveLinkNodeByVal(int val)
 34 {
 35     if (this->length <= 0)
 36     {
 37         return;
 38     }
 39     LinkNode* pcurNode = this->head;
 40     LinkNode* preNode = this->head;
 41     
 42     for (int i = 0; i < this->length; ++i)
 43     {
 44         pcurNode = pcurNode->next;
 45         if (pcurNode->data == val)
 46         {
 47             preNode->next = pcurNode->next;
 48             delete pcurNode;
 49             pcurNode = NULL;
 50             this->length--;
 51             return;
 52         }
 53         preNode = pcurNode;
 54     }
 55 
 56 }
 57 
 58 void LinkList::RemoveLinkNodeByPox(int pox)
 59 {
 60     if (pox < 0 || pox >= this->length)
 61     {
 62         return;
 63     }
 64     LinkNode* pcurNode = this->head;
 65 
 66     //找到前去節點
 67     for (int i = 0; i < pox; ++i)
 68     {
 69         pcurNode = pcurNode->next;
 70     }
 71 
 72     LinkNode* delNode = pcurNode->next;
 73     pcurNode->next = delNode->next;
 74     delete delNode;
 75     delNode = NULL;
 76 
 77     this->length--;
 78 }
 79 
 80 void LinkList::reverse()
 81 {
 82     if (NULL == this->head->next)
 83     {
 84         return;
 85     }
 86     LinkNode* pFirst = this->head->next;  //指向頭結點
 87 
 88     if (NULL == pFirst->next)
 89     {
 90         return;
 91     }
 92     LinkNode* pMid = this->head->next;    //指向頭結點的下一個節點
 93 
 94     if (NULL == pMid->next)
 95     {
 96         pFirst->next = NULL;
 97         pMid->next = pFirst;
 98         this->head->next = pMid;
 99         return;
100     }
101 
102     LinkNode* pLast = pMid->next;
103     pFirst->next = NULL;
104     while (true)
105     {
106         pMid->next = pFirst;  //讓第二個節點指向第一個節點
107         pFirst = pLast->next;  //讓第一個節點挪動到最後一個節點的下一個
108         
109         if (NULL == pFirst)
110         {
111             pLast->next = pMid;
112             head->next = pLast;
113             return;
114         }
115 
116         pLast->next = pMid;
117         pMid = pFirst->next;
118 
119         if (NULL == pMid)
120         {
121             pFirst->next = pLast;
122             head->next = pFirst;
123             return;
124         }
125 
126         pFirst->next = pLast;
127         pLast = pMid->next;
128         if (NULL == pLast)
129         {
130             pMid->next = pFirst;
131             head->next = pMid;
132             return;
133         }
134     }
135 }
136 
137 void LinkList::reverseSimply()
138 {
139     LinkNode* pnext = this->head->next;  //記載下一個節點，也是反轉後的第一個節點
140 
141     LinkNode* pcur = NULL;  //記載當前的
142     LinkNode* ppre = NULL;    //記載前一個節點
143 
144     while (true)
145     {
146         if (NULL == pnext || NULL == pnext->next)  //若是隻有頭節點或者只有一個節點，或者pnext到了最後一個節點
147         {
148             this->head->next = pnext;
149             if (pnext != NULL)             //防止只有頭結點狀況
150             {
151                 pnext->next = pcur;             //防止最後一個節點沒有連接上倒數第二個
152             }
153             return;
154         }
155         pcur = pnext;  
156         pnext = pnext->next;  //上一步已經完成佔位操做，以後讓本身下移，記載下一個節點指針
157         pcur->next = ppre;  //通過上面兩步，當前節點已經下移了一位，讓本身的下一個指向以前的一個節點
158         ppre = pcur;    //上一步已經完成反向連接過程，讓ppre後移一個節點
159     }
160 
161 }
162 
163 
164 LinkNode * LinkList::reserveByRecursion(LinkNode* hd)
165 {
166     if (NULL == hd->next)  //遞歸先找到最後一個節點
167     {
168         this->head->next = hd;
169         return hd;
170     }
171     LinkNode* pcurNode = reserveByRecursion(hd->next);  //是反轉前的最後一個節點，反轉後的第一個節點
172 
173     pcurNode->next = hd;  //此時hd表明反轉前的前一個節點，進行逆向連接
174 
175     return hd;
176 }
177 
178 
179 void LinkList::ForEachLinkList()
180 {
181     LinkNode* pcurNode = this->head;
182 
183     for (int i = 0; i < this->length; ++i)
184     {
185         pcurNode = pcurNode->next;
186         cout << pcurNode->data << "   ";
187     }
188     cout << endl;
189 }
190 
191 LinkNode* LinkList::FindVal(int val)
192 {
193     if (this->length <= 0)
194     {
195         return NULL;
196     }
197 
198     LinkNode* pcurNode = head;
199     for (int i = 0; i < this->length; ++i)
200     {
201         pcurNode = pcurNode->next;
202         if (pcurNode->data == val)
203         {
204             cout << "找到了！" << endl;
205             return pcurNode;
206         }
207     }
208     return NULL;
209 }
210 
211 int LinkList::LinkListLength()
212 {
213     return this->length;
214 }
215 
216 
217 
218 void LinkList::clearList()
219 {
220     if (this->length <= 0)
221     {
222         return;
223     }
224     
225     LinkNode* pcurNode = head;
226     LinkNode* pnextNode = head->next;
227 
228     for (int i = 0; i < length; ++i)
229     {
230         pcurNode = pnextNode;
231         pnextNode = pcurNode->next;
232         if (pcurNode != NULL)
233         {
234             delete pcurNode;
235             pcurNode = NULL;
236         }
237     }
238 
239     this->length = NULL;
240 }
241 
242 LinkList::~LinkList()
243 {
244     if (this->length <= 0)
245     {
246         if (NULL != head)
247         {
248             delete head;
249             head = NULL;
250         }
251         return;
252     }
253 
254     LinkNode* pcurNode = head;
255     LinkNode* pnextNode = head->next;
256 
257     for (int i = 0; i < length; ++i)
258     {
259         pcurNode = pnextNode;
260         pnextNode = pcurNode->next;
261         if (pcurNode != NULL)
262         {
263             delete pcurNode;
264             pcurNode = NULL;
265         }
266     }
267     this->length = 0;
268     if (NULL != head)
269     {
270         delete head;
271         head = NULL;
272     }
273     return;
274 }