資料結構學習之單鏈表

來自：happcock論壇

節點類

#ifndef Node_H #define Node_H template class Node //單鏈節點類 { 　public: 　　Type data; 　　Node *link; 　　Node() : data(Type()), link(NULL) {} 　　Node(const Type &item) : data(item), link(NULL) {} 　　Node(const Type &item, Node *p) : data(item), link(p) {} 　}; #endif

　　【說明】因為資料結構裡用到這個結構的地方太多了，如果用《資料結構》那種聲明友元的做法，那聲明不知道要比這個類的本身長多少。不如開放成員，事實上，這種結構只是C中的struct，除了為了方便初始化一下，不需要任何的方法，原書那是畫蛇添足。下面可以看到，鏈表的public部分沒有返回Node或者Node*的函數，所以，別的類不可能用這個開放的介面對鏈表中的節點操作。

　　【重要修改】原書的預設建構函式是這樣的Node() : data(NULL), link(NULL) {} 。我原來也是照著寫的，結果當我做擴充時發現這樣是不對的。當Type為結構而不是簡單類型（int、……），不能簡單賦NULL值。這樣做使得定義的模板只能用於很少的簡單類型。顯然，這裡應該調用Type的預設建構函式。 這也要求，用在這裡的類一定要有預設建構函式。在下面可以看到構造鏈表時，使用了這個預設建構函式。當然，這裡是約定帶表前端節點的鏈表，不帶前端節點的情況請大家自己思考。

　　【閑話】請不要對int *p = new int(1);這種文法有什麼懷疑，實際上int也可以看成一種class。

　　單鏈表類定義與實現

#ifndef List_H #define List_H #ifndef TURE 　#define TURE 1 #endif #ifndef FALSE 　#define FALSE 0 #endif typedef int BOOL; #include "Node.h" template class List //單鏈表定義 { 　//基本上無參數的成員函數操作的都是當前節點，即current指的節點 　//認為表中“第1個節點”是第0個節點，請注意，即表長為1時，最後一個節點是第0個節點 　public: 　　List() { first = current = last = new Node; prior = NULL; } 　　~List() { MakeEmpty(); delete first; } 　　 void MakeEmpty() //置空表 　　{ 　　　Node *q; 　　　while (first->link != NULL) 　　　{ 　　　　q = first->link; 　　　　first->link = q->link; 　　　　delete q; 　　　} 　　　Initialize(); 　　} 　　BOOL IsEmpty() 　　{ 　　　if (first->link == NULL) 　　　{ 　　　　Initialize(); 　　　　return TURE; 　　　} 　　　else return FALSE; 　　} 　　int Length() const //計算帶表前端節點的單鏈表長度 　　{ 　　　Node *p = first->link; 　　　int count = 0; 　　　while (p != NULL) 　　　{ 　　　　p = p->link; 　　　　count++; 　　　} 　　　return count; 　　} 　　Type *Get()//返回當前節點的資料域的地址 　　{ 　　　if (current != NULL) return ¤t->data; 　　　else return NULL; 　　} 　　BOOL Put(Type const &value)//改變當前節點的data，使其為value 　　{ 　　　if (current != NULL) 　　　{ 　　　　current->data = value; 　　　　return TURE; 　　　} 　　　else return FALSE; 　　} 　　Type *GetNext()//返回當前節點的下一個節點的資料域的地址，不改變current 　　{ 　　　if (current->link != NULL) return ¤t->link->data; 　　　else return NULL; 　　} 　　Type *Next()//移動current到下一個節點，返回節點資料域的地址 　　{ 　　　if (current != NULL && current->link != NULL) 　　　{ 　　　　prior = current; 　　　　current = current->link; 　　　　return ¤t->data; 　　　} 　　　else 　　　{ 　　　　return NULL; 　　　} 　　} 　　void Insert(const Type &value)//在當前節點的後面插入節點，不改變current 　　{ 　　　Node *p = new Node(value, current->link); 　　　current->link = p; 　　} 　　BOOL InsertBefore(const Type &value)//在當前節點的前面插入一節點，不改變current，改變prior 　　{ 　　　Node *p = new Node(value); 　　　if (prior != NULL) 　　　{ 　　　　p->link = current; 　　　　prior->link = p; 　　　　prior = p; 　　　　return TURE; 　　　} 　　　else return FALSE; 　　} 　　BOOL Locate(int i)//移動current到第i個節點 　　{ 　　　if (i <= -1) return FALSE; 　　　　current = first->link; 　　　　for (int j = 0; current != NULL && j < i; j++, current = current->link) 　　　　　prior = current; 　　　　　if (current != NULL) return TURE; 　　　　　else return FALSE; 　　} 　　void First()//移動current到表頭 　　{ 　　　current = first; 　　　prior = NULL; 　　} 　　void End()//移動current到表尾 　　{ 　　　if (last->link != NULL) 　　　{ 　　　　for ( ;current->link != NULL; current = current->link) 　　　　　prior = current; 　　　　　last = current; 　　　} 　　　current = last; 　　} 　　BOOL Find(const Type &value)//移動current到資料等於value的節點 　　{ 　　　if (IsEmpty()) return FALSE; 　　　for (current = first->link, prior = first; current != NULL && current->data != value; 　　　current = current->link) 　　　　prior = current; 　　　　if (current != NULL) return TURE; 　　　　else return FALSE; 　　} 　　BOOL Remove()//刪除當前節點，current指向下一個節點，如果current在表尾，執行後current = NULL 　　{ 　　　if (current != NULL && prior != NULL) 　　　{ 　　　　Node *p = current; 　　　　prior->link = p->link; 　　　　current = p->link; 　　　　delete p; 　　　　return TURE; 　　　} 　　　else return FALSE; 　　} 　　BOOL RemoveAfter()//刪除當前節點的下一個節點，不改變current 　　{ 　　　if (current->link != NULL && current != NULL) 　　　{ 　　　　Node *p = current->link; 　　　　current->link = p->link; 　　　　delete p; 　　　　return TURE; 　　　} 　　　else return FALSE; 　　} 　　friend ostream & operator << (ostream & strm, List &l) 　　{ 　　　l.First(); 　　　while (l.current->link != NULL) strm << *l.Next() << " " ; 　　　　strm << endl; 　　　　l.First(); 　　　　return strm; 　　} 　　protected: 　　/*主要是為了高效的入隊演算法所添加的。因為Insert()，Remove()，RemoveAfter()有可能改變last但沒有改變last所以這個演算法如果在public裡除非不使用這些，否則不正確。但是last除了在隊列中非常有用外，其他的時候很少用到，沒有必要為了這個用途而降低Insert()，Remove()的效率所以把這部分放到protected，實際上主要是為了給隊列繼承*/ void LastInsert(const Type &value) 　{ 　　Node *p = new Node(value, last->link); 　　last->link = p; 　　last = p; 　} 　void Initialize()//當表為空白表時使指標複位 　{ 　　current = last = first; 　　prior = NULL; 　} 　//這部分函數傳回型別為Node指標,是擴充List功能的介面 　 　Node *pGet() 　{ 　　return current; 　} 　Node *pNext() 　{ 　　prior = current; 　　current = current->link; 　　return current; 　} 　Node *pGetNext() 　{ 　　return current->link; 　} 　Node *pGetFirst() 　{ 　　return first; 　} 　Node *pGetLast() 　{ 　　return last; 　} 　Node *pGetPrior() 　{ 　　return prior; 　} 　void PutLast(Node *p) 　{ 　　last = p; 　} //這部分插入刪除函數不建立或刪除節點，是原位操作的介面 　void Insert(Node *p) 　{ 　　p->link = current->link; 　　current->link = p; 　} 　void InsertBefore(Node *p) 　{ 　　p->link = current; 　　prior->link = p; 　　prior = p; 　} 　void LastInsert(Node *p) 　{ 　　p->link = NULL; 　　last->link = p; 　　last = p; 　} 　Node *pRemove() 　{ 　　if (current != NULL && prior != NULL) 　　{ 　　　Node *p = current; 　　　prior->link = current->link; 　　　current = current->link; 　　　return p; 　　} 　　else return NULL; 　} 　Node *pRemoveAfter() 　{ 　　if (current->link != NULL && current != NULL) 　　{ 　　　Node *p = current->link; 　　　current->link = current->link->link; 　　　return p; 　　} 　　else return NULL; 　} 　private: 　　List(const List &l); 　　Node *first, *current, *prior, *last; 　　//盡量不要使用last，如果非要使用先用End()使指標last正確 }; #endif

　　【說明】我將原書的遊標類Iterator的功能放在了鏈表類中，屏蔽掉了傳回值為Node以及Node*類型的介面，這樣的鏈表簡單、實用，擴充效能也很好。

　　在完成書後作業的時候，我發現了原書做法的好處，也就是我的做法的不足。如果使用原書的定義，在完成一個功能時，只需要寫出對應的函數實現。而在我的定義中，必須先派生一個類，然後把這個功能作為成員或者友元。但是這種比較並不說明書上的定義比我的要合理。首先，使用到原位操作的情況並不多，書後作業只是一種特殊情況；換句話說，書上的定義只是對完成書後作業更實用些。其次，在使用到鏈表的時候，通常只會用到插入、刪除、取資料、搜尋等很少的幾個功能，我的定義足夠用了。而在完成一個軟體時，對鏈表的擴充功能在設計階段就很清晰了，這時可以派生一個新類在整個軟體中使用，對整體的規劃更為有利。而對於單個鏈表的操作，把它作為成員函數更好理解一些。也就是說我的定義靈活性不差。

單鏈表應用

　　有人曾經建議最好把鏈表和鏈表位置這兩個分開，C++標準庫是這麼做的；但對於初學者來說，一個類總比兩個類好操作。我不清楚在書中這部分的程式究竟調沒調試，但這種語句我是絕對看不懂的：

ListNode *pa, *pb, *pc, *p; ListIterator Aiter(ah.poly); ListIterator Biter(ah.poly); pa = pc = Aiter.First(); pb = p = Biter.First(); ……………………….. pa->coef = pa->coef + pb->coef; p = pb; pb = Biter.Next(); delete p;

　　pa, pb, p 究竟指向什嗎？你說這很清楚，ListNode這樣的節點唄。但按照原書的定義，ListIterator::First()等等函數返回是指向data域的指標，他們怎麼能直接賦值？到了下面更亂了，pb指向的地區直接分解出了Term的資料成員，也就是說是指向Term結構的；然後讓ListNode類型的指標p指向這個Term結構，最後，居然把這個結構delete了，天啊，ListNode這樣的節點的data域被delete了！

　　如果從基本的節點操作入手，誰也不會弄的這麼亂。但正因為又多了一個類，很多事就疏忽了。所以，我並不懷疑標準庫的做法，只是對於初學者，同一時間最好只對一個類操作。我以我的定義為基礎，重新完成了這段程式。我並不欣賞原位操作的多項式加法（＋），PolyA+PolyB，然後B就嗖的一下沒了，A就多了一堆（也可能少了一堆）；你作intJ+intK的時候怎麼沒見J和K有什麼變化。與其這樣，重載“+”還不如寫成PolyA.Add(PolyB)或者PolyAdd(PolyA,PolyB)。

　　一元多項式類定義與實現

#ifndef Polynomial_H #define Polynomial_H #include "List.h" class Term { 　public: 　　int coef; 　　int exp; 　　Term() : coef(0), exp(0) {} 　　Term(int c, int e) : coef(c), exp(e) {} 　　Term(int c) : coef(c), exp(0) {} }; class Polynomial : List { 　public: 　　void Input() 　　{ 　　　cout << endl << "輸入多項式的各項係數和指數"; 　　　cout << endl << "注意：請按降序輸入各項,輸入係數0表示結束" << endl; 　　　int coef, exp; 　　　for(int i = 1; ; i++) 　　　{ 　　　　cout << "第" << i << "項的係數："; 　　　　cin >> coef; 　　　　if (coef) 　　　　{ 　　　　　cout << "指數："; 　　　　　cin >> exp; 　　　　　Term term(coef, exp); 　　　　　Insert(term); 　　　　} 　　　　else break; 　　　} 　　} 　void Print() 　{ 　　cout << endl; 　　First(); 　　if (!IsEmpty()) 　　{ 　　　Term *p = Next(); 　　　cout << p->coef; 　　　if (p->exp) 　　　{ 　　　　cout << "x"; 　　　　if (p->exp != 1) cout << "^" << p->exp; 　　　} 　　while (Next() != NULL) 　　{ 　　　p = Get(); 　　　if (p->coef > 0) cout << "+"; 　　　cout << p->coef; 　　　if (p->exp) 　　　{ 　　　　cout << "x"; 　　　　if (p->exp != 1) cout << "^" << p->exp; 　　　} 　　} 　} 　cout << endl; } friend void PolyAdd (Polynomial &polyA, Polynomial &polyB) { 　Node *pA, *pB; 　polyA.First();polyB.First(); 　pA = polyA.pNext();pB = polyB.pNext(); 　while (pA != NULL && pB !=NULL) 　{ 　　if (pA->data.exp == pB->data.exp) 　　{ 　　　pA->data.coef = pA->data.coef + pB->data.coef; 　　　polyB.Remove(); 　　　if (!pA->data.coef) polyA.Remove(); 　　　else polyA.pNext(); 　　} 　　else 　　{ 　　　if (pA->data.exp > pB->data.exp) 　　　{ 　　　　polyB.pRemove(); 　　　　polyA.InsertBefore(pB); 　　　} 　　　else if (pA->data.exp < pB->data.exp) polyA.pNext(); 　　} 　　pA = polyA.pGet();pB = polyB.pGet(); 　} 　if (pA == NULL) 　{ 　　polyA.pGetPrior()->link = pB; 　　polyB.pGetPrior()->link = NULL; 　} } }; #endif

　　【說明】對於多項式，通常我們都是降序書寫的，於是我就要求降序輸入。但是對於做加法來說，確實升序的要方便一些，於是，實際上到了內部，就變成升序的了。對於輸出格式（從C的時候我就不喜歡做這個），盡量照顧習慣，但是當非常數項係數為1的時候還是會輸出係數的，我實在不想把一個實際應用中根本拿不出台的輸出函數搞的很複雜。為我編起來方便，輸出變成了升序的，請多包含。測試程式就不給了，很簡單。在續篇中，我將完成一元多項式“＋”“－”“×”“＝”的重載——為什麼沒有“÷”，這種運算我拿筆算都不麻利，編起來就更鬧心了，我還清楚的記得拿彙編寫多位元組除法程式時的痛苦。到了下一篇，你就可以這樣寫了a=b+c*d;a.Print()。

　　在下面將會有些重載運算子的例子，我們的工作將是使多項式的運算看起來更符合書寫習慣。完成這些是我覺得我擅自將原書的“＋”改成了PolyAdd()，總要給個交待吧。

下面將完成單鏈表的賦值運算的重載，請把這部分加到List類的public部分。的確，這部分也可以放在多項式類裡實現；但是，複製一個多項式實際上就是複製一個單鏈表，與其單單做一個多項式賦值，還不如完成單鏈表的賦值，讓衍生類別都能共用。

operator = (const List &l) { 　MakeEmpty(); 　for (Node *p = l.first->link; p != NULL; p = p->link) LastInsert(p->data); }

　　還記得List類的private裡面的這個List(const List &l)嗎？當初怕它惹禍，直接將它禁用了，既然現在=都能用了，為了這種文法List b = a;順便也把它完成了吧。現在可以把它從private放到public了。

List(const List &l) { 　first = current = last = new Node; prior = NULL; 　for (Node *p = l.first->link; p != NULL; p = p->link) LastInsert(p->data); }

　　終於可以這樣寫了a = b + c * d

friend Polynomial operator + (Polynomial &polyA, Polynomial &polyB) { 　Polynomial tempA = polyA;Polynomial tempB = polyB; 　PolyAdd(tempA, tempB); 　return tempA; } friend Polynomial operator * (Polynomial &polyA, Polynomial &polyB) { 　Node *pA = polyA.pGetFirst()->link; 　Node *pB = polyB.pGetFirst()->link; 　Polynomial polyTempA, polyTempB; 　int coef, exp; 　if (pA == NULL || pB == NULL) return polyTempA; 　for (pA = polyA.pGetFirst()->link; pA != NULL; pA = pA->link) 　{ 　　for(pB = polyB.pGetFirst()->link; pB != NULL; pB = pB->link) 　　{ 　　　coef = pA->data.coef * pB->data.coef; 　　　exp = pA->data.exp + pB->data.exp; 　　　Term term(coef, exp); 　　　polyTempB.LastInsert(term); 　　} 　　PolyAdd(polyTempA, polyTempB); 　　polyTempB.Initialize(); 　} 　return polyTempA; }

　　【後記】很顯然，在“＋”的處理上我偷懶了，但這是最方便的。乘法部分只要參照手工運算，還是很簡單的，我就不解釋了。對於“－”，可以先完成（－a）這樣的演算法，然後就可以用加法完成了，而你要是象我一樣懶很可能就會做這種事－a＝－1×a，真的不提倡，超低的效率。對於除法，如果你會用彙編寫多位元組除法（跟手工計算很像），依樣畫葫蘆也能弄出來，但首先要完成“－”。如果要寫又得好長，留給你完成吧。到這裡你明白原位加法的重要了吧，這些運算實際上都是靠它實現的。