單鏈表的實現C/C++

單鏈表的實現C/C++

鏈表是線性表的另一種實現方式。與順序表不同，鏈表中邏輯上相鄰的數據元素在物理上未必相鄰，而是通過一個指針指明下一個元素的

物理地址。單鏈表中節點類型的描述如下：

 

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 j = 0;
    LNode* p = L;
    //始終讓p指向第j個節點，當p沒有下一個節點時，j就是表的長度
    while( p->next != NULL ) {
        j++;
        p = p->next;
    }
    return j;
}

//按位序查找，返回指向第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;
}