单链表的实现C/C++

单链表的实现C/C++

链表是线性表的另一种实现方式。与顺序表不同，链表中逻辑上相邻的数据元素在物理上未必相邻，而是通过一个指针指明下一个元素的物理地址。单链表中节点类型的描述如下：

struct LNode {
    ElemType data;  //节点数据域
    LNode* next;    //指向下一个节点的指针
};
typedef LNode* LinkList;

单链表的优点：与顺序表相比，单链表的优点在于插入和删除操作：虽然单链表的插入和删除操作与顺序表一样时间复杂度都是O(n),但是对于单链表来说，插入和删除时的基本操作主要是“比较”（对于按位插入删除，比较是否到了第i位；对于按值操作，比较值是否相等），而顺序表插入和删除时的基本操作主要是“移动”。从硬件的角度讲，做一次比较运算的时间是远小于赋值运算的。因此，链表的插入和删除操作要高效得多。

单链表的缺点：由于单链表中逻辑上相邻的元素在物理上未必相邻，故不能根据第一个元素的地址立即计算出第i个元素的地址。于是单链表不支持随机访问。（所谓随机访问是指：根据起始地址加上元素序号就可以立即找到任意一个元素。）要在单链表中访问第i个元素，必须一个一个访问链表中每一个元素直到第i个。

以下代码实现一个带头节点的单链表，存储int元素，并尝试实现一种重要操作：将链表反序

/* 带头节点的单链表

     实现操作：
     *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;
}

 上一篇【顺序表的实现】：https://www.cnblogs.com/pkuqcy/p/14932650.html

 下一篇【双链表的实现C/C++】：https://www.cnblogs.com/pkuqcy/p/14951810.html