基本資料結構實現--單連結串列【含測試程式碼】

基本資料結構實現--單連結串列

連結串列是線性表的另一種實現方式。與順序表不同，連結串列中邏輯上相鄰的資料元素在物理上未必相鄰，而是通過一個指標指明下一個元素的

實體地址。單連結串列中節點型別的描述如下：

 

struct LNode {
    ElemType data;  //節點資料域
    LNode* next;    //指向下一個節點的指標
};
typedef LNode* LinkList;

單連結串列的優點：與順序表相比，單連結串列的優點在於插入和刪除操作：雖然單連結串列的插入和刪除操作與順序表一樣時間複雜度都是O(n),但是對於單連結串列來說，

插入和刪除時的基本操作主要是“比較”（對於按位插入刪除，比較是否到了第i位；對於按值操作，比較值是否相等），而順序表插入和刪除時

的基本操作主要是“移動”。從硬體的角度講，做一次比較運算的時間是遠小於賦值運算的。因此，連結串列的插入和刪除操作要高效得多。

 

單連結串列的缺點：由於單連結串列中邏輯上相鄰的元素在物理上未必相鄰，故不能根據第一個元素的地址立即計算出第i個元素的地址。於是單連結串列不支援隨機訪問。

（所謂隨機訪問是指：根據起始地址加上元素序號就可以立即找到任意一個元素。）要在單連結串列中訪問第i個元素，必須一個一個訪問連結串列中每一個元素直到

第i個。

 

以下程式碼實現一個帶頭節點的單連結串列，並嘗試實現一種重要操作：將連結串列反序

/* 帶頭節點的單連結串列

     實現操作：
     *1 判空
     *2 求表長
     *3 按位序查詢
     *4 按值查詢
     *5 前插操作
     *6 後插操作
     *7 按位插入
     *8 刪除指定節點
     *9 按位刪除
     *10 單連結串列的建立-頭插和尾插
                                */
#include <iostream>
#include <cstdio>
using namespace std;

typedef int ElemType;
typedef struct LNode {
    ElemType data;  //節點資料域
    LNode* next;    //指向下一個節點的指標
} * LinkList;

bool Empty(LinkList& L)
{
    if( L->next == NULL )
        return true;
    return false;
}

//求表的長度
int Length(LinkList L)
{
    int len = 0;
    LNode* p = L;
    //始終讓p指向第j個節點，當p沒有下一個節點時，j就是表的長度
    while( p->next != NULL ) {
        len++;
        p = p->next;
    }
    return len;
}

//按位序查詢，返回指向第i個節點的指標
//查詢失敗時返回的是NULL
LNode* GetElem(LinkList L,int i)
{
    if( i < 0 )
        return NULL;
    int j = 0;
    LNode* p = L;
    while( j < i && p != NULL ) {
        j++;
        p = p->next;
    }
    return p;   //i=0時返回的是頭節點,i值大於表長是返回的是空指標
}

//按值查詢，找到資料域為e的節點,返回其指標
LNode* LocateElem(LinkList L,ElemType e)
{
    LNode* p = L->next; //注意不是LNode* p = L :因為指向頭節點，資料域是未知的
    while( p != NULL && p->data != e ) {
        p = p->next;
    }
    return p;   //若e不存在，返回空指標
}

//前插操作：在p節點之前插入元素e
bool InsertPriorNode(LNode* p,ElemType e)
{
    if( p == NULL )
        return false;

    //偷天換日
    LNode* s = new LNode;
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}

//後插操作：在p節點之後插入元素e
bool InsertNextNode(LNode* p,ElemType e)
{
    if( p == NULL )
        return false;
    LNode* s = new LNode;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

//按位插入：在單連結串列L的第i個位置插入元素e
bool ListInsert(LinkList& L,int i,ElemType e)
{
    if( i < 1 )
        return false;   //位序最小是1

    //先拿到指向第i-1個節點的指標，然後在他後面插入元素e
    LNode* p = GetElem(L,i-1);
    return InsertNextNode(p,e);
}

//刪除指定節點p
bool DeleteNode(LNode* p)
{
    if( p == NULL )
        return false;
    //偷天換日
    LNode* s = p->next;
    //有bug：當p是最後一個節點時，無法刪除(無法從p->next獲取data)
    //非要刪除最後一個節點的話，可以傳L頭節點指標進來
    p->data = s->data;
    p->next = s->next;
    delete s;

    return true;
}

//按位刪除：刪除單連結串列L的位序為i的元素，並用e返回
bool ListDelete(LinkList& L, int i,int& e)
{
    if( i < 1 )
        return false;
    LNode* p = GetElem(L,i-1);

    if( p == NULL ) //沒有第i-1個節點，更沒有第i個節點
        return false;
    if( p->next == NULL ) //找到了第i-1個節點，但是沒有第i個節點
        return false;
    LNode* t = p->next;
    e = t->data;
    p->next = t->next;
    delete t;
    return true;
}

//頭插法建立單連結串列(假設所給資料從鍵盤輸入)
LinkList List_HeadInsert(LinkList& L)
{
    //假設元素為int型
    int x;
    L = new LNode;
    L->next = NULL;
    while( cin >> x ) {
        InsertNextNode(L,x);
    }
    return L;
}

//尾插法建立單連結串列(假設所給資料從鍵盤輸入)
LinkList List_TailInsert(LinkList& L)
{
    //假設元素為int型
    int x;
    L = new LNode;
    L->next = NULL;
    LNode* r = L;
    while( cin >> x ) {
        LNode* s = new LNode;
        s->data = x;
        r->next = s;
        r = s;  //建立過程中不必將尾節點的next置空，因為後面還會有節點
    }
    r->next = NULL; //連結串列建立結束，最後一個節點的下一個節點置空
    return L;
}

//按順序輸出單連結串列中所有元素
void Print(LinkList L)
{
    if( L == NULL )
        return ;
    LNode* iterater = L->next;
    while( iterater != NULL ) {
        cout << iterater->data << endl;
        iterater = iterater->next;
    }
}

void test1()
{
    //*測試使用a[i]=2*i的100個元素建立連結串列
    int a[100];
    for( int i=0; i<100; i++ ) {
        a[i] = 2*i;
    }
    LinkList L = new LNode;
    L->next = NULL;
    //使用尾插法將以上陣列插入連結串列L
    LNode* r = L;
    for( int i=0; i<100; i++ ) {

        LNode* s = new LNode;
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;

    //*測試在值為20的元素後插入元素985211
    LNode* t = LocateElem(L,20);    //按值查詢
    InsertNextNode(t,985211);

    //*測試刪除位序為15的元素(值應該是26)
    LNode* tt = GetElem(L,15);      //按位序查詢
    if( tt != NULL ) {
        DeleteNode(tt);
    }

    //*測試按位序刪除位序為100的元素
    int ttt = 0;
    if( ListDelete(L,100,ttt) )
        cout << "按位序刪除成功，刪除的元素是：" << ttt << endl;
    Print(L);
    cout << "-------------------------------" << endl;


    //下面嘗試將L反序 *****重要*****
    //抓住連結串列中的第一個資料元素,一個一個往後進行頭插,表頭結點指標還是L
    LNode* it = L->next;
    L->next = NULL; //*****第一個資料已經抓住了;不加這句會導致表尾自己指向自己(而非指向NULL)

    //從連結串列的第一個節點開始，一個一個地在將表中所有節點重新插在表頭
    while( it != NULL ) {
        LNode* nxt = it->next;
        it->next = L->next;
        L->next = it;   //頭插法重構連結串列，即可將連結串列反序
        it = nxt;
    }
    Print(L);

    //*測試查詢不存在的元素返回空指標
    if( LocateElem(L,999) == NULL ) {
        cout << endl << "999不存在" << endl;
    }

}

//測試頭插法
void test2()
{
    LinkList L;
    List_HeadInsert(L);
    Print(L);
}

int main()
{
//    test1();
//    test2();
    return 0;
}