struct test
{
char name[10];
float
socre;
test *next;
};//這樣是正確的!
struct
test
{
char name[10];
float socre;
test
next;
};//這樣是錯誤的!
被過濾廣告 利用結構體的這點特殊特性，我們就可以自己產生一個環環相套的一種射線結構，一個指向另一個。
鏈表的學習不像想象的那麼那麼容易，很多人學習到這裡的時候都會碰到困難，很多人也因此而放棄了學習，在這裡我說,一定不能放棄，對應它的學習我們要進行分解式學習，方法很重要，理解需要時間，不必要把自己逼迫的那麼緊，學習前你也得做一些最基本的準備工作，你必須具備對堆記憶體的基本知識的瞭解，還有就是對結構體的基本認識，有了這兩個重要的條件，再進行分解式學習就可以比較輕鬆的掌握這一節內容的痛點。
下面我們給出一個完整的建立鏈表的程式，不管看的懂看不懂希望讀者先認真看一下，想一想，看不懂沒有關係，因為我下面會有分解式的教程，但之前的基本思考一定要做，要不即使我分解了你也是無從理解的。
代碼如下，我在重要部分做了註解：
#include <iostream>
using
namespace std;
struct test
{
char name[10];
float
socre;
test *next;
};
test *head;//建立一個全域的引導進入鏈表的指標
test *create()
{
test *ls;//節點指標
test *le;//鏈尾指標
ls = new
test;//把ls指向動態開闢的堆記憶體位址
cin>>ls->name>>ls->socre;
head=NULL;//進入的時候先不設定head指標指向任何地址,因為不知道是否一上來就輸入null跳出程式
le=ls;//把鏈尾指標設定成剛剛動態開闢的堆記憶體位址,用於等下設定le->next,也就是下一個節點的位置
while(strcmp(ls->name,"null")!=0)//建立迴圈條件為ls->name的值不是null,用於迴圈添加節點
{
if(head==NULL)//判斷是否是第一次進入迴圈
{
head=ls;//如果是第一次進入迴圈,那麼把引導進入鏈表的指標指向第一次動態開闢的堆記憶體位址
}
else
{
le->next=ls;//如果不是第一次進入那麼就把上一次的鏈尾指標的le->next指向上一次迴圈結束前動態建立的堆記憶體位址
}
le=ls;//設定鏈尾指標為當前迴圈中的節點指標,用於下一次進入迴圈的時候把上一次的節點的next指向上一次迴圈結束前動態建立的堆記憶體位址
ls=new
test;//為下一個節點在堆記憶體中動態開闢空間
cin>>ls->name>>ls->socre;
}
le->next=NULL;//把鏈尾指標的next設定為空白,因為不管如何迴圈總是要結束的,設定為空白才能夠在迴圈顯鏈表的時候不至於死迴圈
delete ls;//當結束的時候最後一個動態開闢的記憶體是無效的,所以必須清除掉
return head;//返回鏈首指標
}
void showl(test *head)
{
cout<<"鏈首指標:"<<head<<endl;
while(head)//以記憶體指向為null為條件迴圈顯示先前輸入的內容
{
cout<<head->name<<"|"<<head->socre<<endl;
head=head->next;
}
}
void main()
{
showl(create());
cin.get();
cin.get();
}
上面的代碼我們是要達到一個目的：就是要儲存你輸入的人名和他們的得分，並且以鏈狀結構把它們組合成一個鏈狀結構。
程式種有兩個組成部分
test *create()
和 void showl(test *head)
這兩個函數，create是用來建立鏈表的 ，showl是用來顯示鏈表的。
create函數的傳回型別是一個結構體指標，在程式調用的時候我們用了showl(create());，而不用引用的目的原因是引導指標是一個全域指標變數，我們不能在showl()內改變它，因為showl()函數內有一個移動操作head=head->next;，如果是引用的話我們就破壞了head指標的位置，以至於我們再也無法找會首地址的位置了。
下面我們來分解整個程式，以一個初學者的思想來思考整個程式，由淺入深的逐步解釋。
首先，我們寫這個程式，要考慮到由於是一個鏈表結構，我們不可能知道它的大小到底是多大，這個問題我們可以用動態開闢堆記憶體來解決，因為堆記憶體在程式結束前始終是有效，不受函數棧空間生命期的限制，但要注意的是我們必須有一個指標變數來儲存這一鏈狀結構的進入地址，而在函數內部來建立這一指標變數顯然是不合適的，因為函數一旦退出，這個指標變數也隨之失效，所以我們在程式的開始聲明了一個全域指標變數。
test
*head;//建立一個全域的引導進入鏈表的指標
好解決了這兩個問題，我們接下去思考
有輸入就必然有輸出，由於輸出函數和輸入函數是相對獨立的，為了不斷測試程式的正確性好調試我們先寫好輸出函數和main函數捏的調用，建立函數我們先約定好名為create。
我們先寫出如下的代碼：
#include <iostream>
using
namespace std;
struct test
{
char name[10];
float
socre;
test *next;
};
test *head;//建立一個全域的引導進入鏈表的指標
test *create()
{
return head;//返回鏈首指標
}
void showl(test *head)
{
cout<<"鏈首指標:"<<head<<endl;
while(head)//以記憶體指向為null為條件迴圈顯示先前輸入的內容
{
cout<<head->name<<"|"<<head->socre<<endl;
head=head->next;
}
}
void main()
{
showl(create());
cin.get();
cin.get();
}
程式寫到這裡，基本形態已經出來，輸入和調用我們已經有了。
下面我們來解決輸入問題，鏈表的實現我們是通過迴圈輸入來實現的，既然是迴圈我們就一定得考慮終止迴圈的條件，避免死迴圈和無效迴圈的發生。
在create()函數內部我們先寫成這樣：
test *create()
{
test *ls;//節點指標
test
*le;//鏈尾指標
ls = new test;//把ls指向動態開闢的堆記憶體位址
cin>>ls->name>>ls->socre;
head=NULL;//進入的時候先不設定head指標指向任何地址,因為不知道是否一上來就輸入null跳出程式
le=ls;//把鏈尾指標設定成剛剛動態開闢的堆記憶體位址,用於等下設定le->next,也就是下一個節點的位置
le->next=NULL;//把鏈尾指標的next設定為空白,因為不管如何迴圈總是要結束的,設定為空白才能夠在迴圈顯鏈表的時候不至於死迴圈
delete ls;//當結束的時候最後一個動態開闢的記憶體是無效的,所以必須清除掉
return head;//返回鏈首指標
}
在迴圈建立之前我們必須考慮一個都不輸入的情況。
程式一單進入create函數我們首先必然要建立一個節點，我們先建立一個節點指標，後把者個節點指標指向到動態開闢的test類型的動態記憶體地址位置上。
所以我們有了
test *ls;
ls = new test;
程式既然是迴圈輸入，而結構成員test
*next又是用來儲存下一個接點的記憶體位址的，每次迴圈我們又要動態建立一個新的記憶體空間，所以我們必須要有一個指標來儲存上一次迴圈動態開闢的記憶體位址，於是就有了
test
*le;
接下來在進入迴圈前我們要建立鏈表的第一個節點，第一個節點必然是在迴圈外建立，於是就有了
cin>>ls->name>>ls->socre;
程式執行者的情況是位置的，所以我們必然要考慮，一上來就不想繼續運行程式的情況，所以我們一開始先把head引導指標設定為不指向任何地址也就是
head=NULL;
為了符合le也就是鏈尾指標的設計思路，我們在迴圈前一定要儲存剛剛動態開闢的記憶體位址，好在下一次迴圈的時候設定上一個節點中的next成員指向，於是我們便有了：
le=ls;
為了實現迴圈輸入我們又了下面的代碼：
while(strcmp(ls->name,"null")!=0)
{
if(head==NULL)
{
head=ls;
}
else
{
le->next=ls;
}
le=ls;
ls=new test;
cin>>ls->name>>ls->socre;
}
程式是迴圈必然要有終止迴圈的條件，所以我們的迴圈條件是：
while(strcmp(ls->name,"null")!=0)
輸入的名字是null的時候就停止迴圈。
為了保證第一次進入迴圈，也就是在迴圈內準備建立第二個節點前，設定引導指標的指向我們有了如下的判斷代碼：
if(head==NULL)
{
head=ls;
}
else
{
le->next=ls;
}
代碼中的else條件是為了設定前一個節點next指向而寫的,這點我們記住先看下面的代碼,稍後大家回過頭想就明白了
le=ls;
ls=new test;
cin>>ls->name>>ls->socre;
le=ls;這麼寫就是為了儲存上一次迴圈指標的位置而設的,正是為了上面的else代碼而做的預先保留
ls=new test;
cin>>ls->name>>ls->socre;
這兩行代碼的意思就是繼續開闢下一個節點空間,和輸入節點內容!
迴圈一旦結束也就結束了程式,為了保持程式不出錯,也就是最後一個節點的next成員指向為空白我們有了下面的代碼
le->next=NULL;
程式的思路始終是以先開闢後判斷為思路的,所以到最後一個不成立的時候總會有一個多開闢的記憶體空間,為了刪除掉它,我們有了下面的代碼
delete ls;
程式到最後由於返回head指標
return head;
顯示鏈表的函數沒有什麼太多特別的也只需要注意下面這樣就可以了！
head=head->next;
我們之所以不用head+=1;來寫就是因為鏈表是我們動態開闢的，而每一個節點的位置並不是相連的，next成員指標的意義也就是下一個節點的記憶體位址。
到這裡整個建立函數的設計思路也都說完了，筆者不一定說的很好，但基本思路是這樣的，希望讀者多思考，多對比，相信此教程還是對大家有協助的，程式設計就是利用逐步思考的方式進行的，寫好的代碼往往直接看看不懂就是因為中間的細節並不是一次都能夠想到的。
下面我們來說一下鏈表節點的刪除!
我們以上面的程式為基礎，但為了我們方便學習刪除我們休整結構體為
struct test
{
int number;
float
socre;
test *next;
};
number為唯一的編號每一個節點的。
刪除的我就不多說了，裡面重要部分有註解。
特別注意deletel函數的參數意義，指標的引用在這裡很重要，如果只是指標，或者只是應用都是不行的，為什麼仔細思考，很多知名的教材在這一問題上都很模糊，而且很多書還有錯誤，程式不錯，但思路是錯的，我這裡特別不說，請大家仔細閱讀程式，如果還是有問題，可以回此帖，我會回答的。
完整代碼如下：
#include <iostream>
using
namespace std;
struct test
{
int number;
float socre;
test *next;
};
test
*head;//建立一個全域的引導進入鏈表的指標
test *create()
{
test *ls;//節點指標
test
*le;//鏈尾指標
ls = new test;//把ls指向動態開闢的堆記憶體位址
cin>>ls->number>>ls->socre;
head=NULL;//進入的時候先不設定head指標指向任何地址,因為不知道是否一上來就輸入null跳出程式
le=ls;//把鏈尾指標設定成剛剛動態開闢的堆記憶體位址,用於等下設定le->next,也就是下一個節點的位置
while(ls->number!=0)//建立迴圈條件為ls->number的值不是null,用於迴圈添加節點
{
if(head==NULL)//判斷是否是第一次進入迴圈
{
head=ls;//如果是第一次進入迴圈,那麼把引導進入鏈表的指標指向第一次動態開闢的堆記憶體位址
}
else
{
le->next=ls;//如果不是第一次進入那麼就把上一次的鏈尾指標的le->next指向上一次迴圈結束前動態建立的堆記憶體位址
}
le=ls;//設定鏈尾指標為當前迴圈中的節點指標,用於下一次進入迴圈的時候把上一次的節點的next指向上一次迴圈結束前動態建立的堆記憶體位址
ls=new
test;//為下一個節點在堆記憶體中動態開闢空間
cin>>ls->number>>ls->socre;
}
le->next=NULL;//把鏈尾指標的next設定為空白,因為不管如何迴圈總是要結束的,設定為空白才能夠在迴圈顯鏈表的時候不至於死迴圈
delete ls;//當結束的時候最後一個動態開闢的記憶體是無效的,所以必須清除掉
return head;//返回鏈首指標
}
void
showl(test *head)
{
cout<<"鏈首指標:"<<head<<endl;
while(head)//以記憶體指向為null為條件迴圈顯示先前輸入的內容
{
cout<<head->number<<"|"<<head->socre<<endl;
head=head->next;
}
}
void deletel(test *&head,int
number)//這裡如果參數換成test *head,意義就完全不同了,head變成了複製而不是原有鏈上操作了,特別注意,很多書上都不對這裡
{
test *point;//判斷鏈表是否為空白
if(head==NULL)
{
cout<<"鏈表為空白,不能進行刪除工作!";
return;
}
if(head->number==number)//判刪除的節點是否為首節點
{
point=head;
cout<<"刪除點是鏈表第一個節點位置!";
head=head->next;//重新設定引導指標
delete point;
return;
}
test
*fp=head;//儲存連首指標
for(test
*&mp=head;mp->next;mp=mp->next)
{
if(mp->next->number==number)
{
point=mp->next;
mp->next=point->next;
delete
point;
head=fp;//由於head的不斷移動丟失了head,把進入迴圈前的head指標恢複!
return;
}
}
}
void main()
{
head=create();//調用建立
showl(head);
int dp;
cin>>dp;
deletel(head,dp);//調用刪除
showl(head);
cin.get();
cin.get();
}
最後我學習一下如何在已有的鏈表上插入節點
我們要考慮四中情況,
1.鏈表為空白!
2.插入點在首節點前
3.插入點找不到的情況我們設定放在最後!
4.插入點在中間的情況!
今天的程式在昨天的基礎上做了進一步的修改,可以避免刪除點找不到的情況,如果找不到刪除點就退出函數!
#include <iostream>
using
namespace std;
struct test
{
int number;
float socre;
test *next;
};
test
*head;//建立一個全域的引導進入鏈表的指標
test *create()
{
test *ls;//節點指標
test
*le;//鏈尾指標
ls = new test;//把ls指向動態開闢的堆記憶體位址
cout<<"請輸入第一個節點number和節點score,輸入0.0跳出函數"<<endl;
cin>>ls->number>>ls->socre;
head=NULL;//進入的時候先不設定head指標指向任何地址,因為不知道是否一上來就輸入null跳出程式
le=ls;//把鏈尾指標設定成剛剛動態開闢的堆記憶體位址,用於等下設定le->next,也就是下一個節點的位置
while(ls->number!=0)//建立迴圈條件為ls->number的值不是null,用於迴圈添加節點
{
if(head==NULL)//判斷是否是第一次進入迴圈
{
head=ls;//如果是第一次進入迴圈,那麼把引導進入鏈表的指標指向第一次動態開闢的堆記憶體位址
}
else
{
le->next=ls;//如果不是第一次進入那麼就把上一次的鏈尾指標的le->next指向上一次迴圈結束前動態建立的堆記憶體位址
}
le=ls;//設定鏈尾指標為當前迴圈中的節點指標,用於下一次進入迴圈的時候把上一次的節點的next指向上一次迴圈結束前動態建立的堆記憶體位址
ls=new
test;//為下一個節點在堆記憶體中動態開闢空間
cout<<"請下一個節點number和節點score,輸入0.0跳出函數"<<endl;
cin>>ls->number>>ls->socre;
}
le->next=NULL;//把鏈尾指標的next設定為空白,因為不管如何迴圈總是要結束的,設定為空白才能夠在迴圈顯鏈表的時候不至於死迴圈
delete ls;//當結束的時候最後一個動態開闢的記憶體是無效的,所以必須清除掉
return head;//返回鏈首指標
}
void
showl(test *head)
{
cout<<"鏈首指標:"<<head<<endl;
while(head)//以記憶體指向為null為條件迴圈顯示先前輸入的內容
{
cout<<head->number<<"|"<<head->socre<<endl;
head=head->next;
}
}
void deletel(test *&head,int
number)//這裡如果參數換成test *head,意義就完全不同了,head變成了複製而不是原有鏈上操作了,特別注意,很多書上都不對這裡
{
test *point;//判斷鏈表是否為空白
if(head==NULL)
{
cout<<"鏈表為空白,不能進行刪除工作!";
return;
}
int
derror=1;//設定找不到的情況的條件,預先設定為真
test
*check=head;
while(check)//利用迴圈進行尋找
{
if
(check->number==number)
{
derror=0;//條件轉為假
}
check=check->next;
}
if(derror)//如果為假就跳出函數
{
return;
}
if(head->number==number)//判刪除的節點是否為首節點
{
point=head;
cout<<"刪除點是鏈表第一個節點位置!";
head=head->next;//重新設定引導指標
delete point;
return;
}
test
*fp=head;//儲存連首指標
for(test
*&mp=head;mp->next;mp=mp->next)
{
if(mp->next->number==number)
{
point=mp->next;
mp->next=point->next;
delete
point;
head=fp;//由於head的不斷移動丟失了head,把進入迴圈前的head指標恢複!
return;
}
}
}
void insterl(int
number)
{
test *point=new test;
cout<<"請輸入節點number和節點score"<<endl;
cin>>point->number>>point->socre;
if(head==NULL)//鏈表為空白的情況下插入
{
head=point;
point->next=NULL;
return;
}
int ierror=1;//設定找不到的情況的條件,預先設定為真
test *le;
test *check=head;
while(check)//利用迴圈進行尋找
{
if
(check->number==number)
{
ierror=0;//條件轉為假
}
le=check;
check=check->next;
}
if(ierror)
{
cout<<le->number;
le->next=point;
point->next=NULL;
return;
}
if(head->number==number)//檢測是否是在第一個節點處插入
{
point->next=head;
head=point;
return;
}
for(test
*&mp=head;mp->next;mp=mp->next)//在鏈表中間插入
{
if(mp->next->number==number)
{
point->next=mp->next;
mp->next=point;
return;
}
}
}
void main()
{
head=create();//調用建立
showl(head);
int dp;
cout<<"請輸入刪除點如果找不到就跳出函數"<<endl;
cin>>dp;
deletel(head,dp);//調用刪除
showl(head);
int ip;
cout<<"請輸入插入點如果找不到就在鏈尾添加"<<endl;
cin>>ip;
insterl(ip);
showl(head);
cin.get();
cin.get();
}
到此關於結構體的內容已經全部討論結束，鏈表的建立刪除插入操作可以很好的對前面所學知識進行一個總結，它既考察了程式員對記憶體大理解(堆記憶體操作、指標操作)也考察了對結構化編程掌握的熟悉程式。
以後的教程我們將著重訓練物件導向的編程的相關知識點。
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
