单链表的基本操作大全之C语言实现

单链表的基本操作大全之C语言实现

1. 单链表的定义

链表是通过一组任意的存储单元来存储线性表中的数据元素，这些存储单元可以是连续的也可以是不连续的。为了建立起数据元素之间的关系，对于每个数据元素除了存放数据元素自身的信息外，还必须有包含的指示该元素直接后继元素存储位置的信息，这两部分信息组成一个结点，即每个结点都有至少包括两个域，一个域存储数据元素信息，称为数据域，另一个域存储直接后继的地址,称为指针域。

    typedef struct node{
        int data;    //数据域
        struct node *next;    //指针域
    }NODE;

当n个元素的线性表通过每个结点的指针域连接成了一条“链子”，我们形象的称之为链表。

2. 建立单链表

建立单链表有两种方法，一种是头插法，一种是尾插法。
在主函数中调用函数时，使用一个NODE *类型的指针接收函数的返回值。

2.1初始化一个链表结点

每次malloc的结点都要初始化，因此写成一个函数。

    //初始化一个节点
    NODE *initnode(NODE *pnode, int data)
    {
            pnode = (NODE *)malloc(sizeof(NODE));
            pnode->data = data;//初始化数据域
            pnode->next = NULL;//初始化指针域为NULL

            return pnode;
    }

2.2头插法建立链表

在链表的头部插入结点建立单链表，称为“头插法”。

    //创建一个新节点(头插法)
    NODE *createlink_byhead(NODE *phead, int data)
    {
            NODE *pnode = initnode(pnode, data);//初始化一个结点
            NODE *ptmp = phead;

        if(NULL == phead){    //链表为空，直接返回初始化的结点
                return pnode;
        }else{
                phead = pnode;    //将新申请的结点插在phead后面，也就是整个链表的最前面
                pnode->next = ptmp;
        }

        return phead;
}

因为每次新结点都会插在链表的头部，则数据读入的顺序和线性表中的逻辑顺序正好相反。

2.3尾插法建立链表

在链表的尾部插入结点建立单链表，简称”尾插法“。

    //创建一个链表节点(尾插法)
    NODE *createlink_bytail(NODE *phead, int data)
    {
            NODE *pnode = initnode(pnode, data);//初始化结点
            NODE *ptmp = phead;

        if(NULL == phead){//当链表为空，直接返回初始化的结点
                return pnode;
        }else{
                while(ptmp->next != NULL){//找到最后一个结点，插在尾部
                        ptmp = ptmp->next;
                }
                ptmp->next = pnode;
        }

        return phead;
    }

尾插法读入的数据与线性表中的逻辑顺序相同

3. 链表的长度

    //求链表长度
    int linklen(NODE *phead)
    {
            int len = 0;//计数器
            NODE *ptmp = phead;

            while(ptmp != NULL){//遍历链表，计数器加1
                    len++;
                    ptmp = ptmp->next;
            }

            return len;
    }

这个算法的时间复杂度为O(n)

4. 按值查找操作

   //按值查找
    NODE *searchnode(NODE *phead, int key)
    {
        NODE *ptmp = phead;

        if(NULL == phead){    //链表为空，直接返回
                return NULL;
        }
        while(ptmp->data != key && ptmp->next != NULL){//没找到key && 链表没找完
                ptmp = ptmp->next; //指针移动
        }
        if(ptmp->data == key) //找到key，返回该结点地址
                return ptmp;
        if(ptmp->next == NULL)//没找到，返回空
                return NULL;
    }

这个算法的时间复杂度为O(n)

5.插入操作

插入操作也分为两种，一种是插在目标值得前面，简称“前插法”，另一种是插在目标值的后面，简称“后插法”。

5.1前插法

 //向前插入
    NODE *insertnode_bypre(NODE *phead, int data, int key)
    {
        NODE *pnode = initnode(pnode, data);//初始化插入的结点
        NODE *ptmp = phead;

        if(NULL == phead){//链表为空，直接返回初始化的结点
                return pnode;
        }else if(phead->data == key){//处理第一个结点是否为目标结点
                phead = pnode;
                pnode->next = ptmp;
        }else{
                while(ptmp->next != NULL && ptmp->next->data != key){//循环遍历，没找完 && 没找到
                        ptmp = ptmp->next;
                }
                if(NULL == ptmp->next){//没找到的情况
                        printf("insert key NOT FOUND\n");
                }else{//把新节点插入目标结点的前面
                        ptmp->next->data == key;
                        pnode->next = ptmp->next;
                        ptmp->next = pnode;
                }
        }
        return phead;
    }

前插法单独处理了第一个结点，是因为前插法会改变phead的值，而且前插法查找目标结点必须知道目标节点的前驱结点的next值，所以从第二个结点开始处理。

5.2后插法

   //向后插入
    NODE *insertnode_byback(NODE *phead, int data, int key)
    {
        NODE *pnode = initnode(pnode, data);//初始化插入的结点
        NODE *ptmp = searchnode(phead, key);//查找到目标结点

        if(NULL == ptmp){//处理链表为空，或没找到
                printf("link is empty or not found key\n");
                return phead;
        }
        if(NULL == ptmp->next){//如果key为最后一个结点
                ptmp->next = pnode;
        }else{ //将新节点插入在目标结点的后面
                pnode->next = ptmp->next;
                ptmp->next = pnode;
        }

        return phead;
}

后插法要单独处理尾结点的情况，因为插入操作不相同。
前插法和后插法的时间复杂度都为O(n)

6.删除操作

  //删除节点
    NODE *delnode(NODE *phead, int key)
    {
        NODE *ptmp = phead;
        NODE *tmp = NULL;

        if(NULL == phead){//处理链表为空的情况
                printf("link is empty, del fail\n");
                return NULL;
        }else if(phead->data == key){//单独处理第一个结点
                phead = phead->next;
                free(ptmp);
                ptmp = NULL;
        }else{
                while(ptmp->next != NULL && ptmp->next->data != key){ //没找完 && 没找到
                        ptmp = ptmp->next;
                }
                if(NULL == ptmp->next){ //没找到
                        printf("del key NOT FOUND\n");
                        return phead;
                }
                if(ptmp->next->data == key){ //找到目标结点删除之
                        tmp = ptmp->next;
                        ptmp->next = tmp->next;
                        free(tmp);
                        tmp = NULL;
                }
        }
        return phead;
}

单独处理第一个结点还是因为要知道要删除目标结点的前驱结点
删除操作算法时间复杂度为O(n)

7.链表的倒置

链表的倒置算法思路：一次取出原链表中的每一个结点，将其作为第一个结点插入新链表中。

  //链表的倒置
    NODE *reverselink(NODE *phead)
    {
        NODE *ptmp = NULL;//创建一个新链
        NODE *tmp = NULL;

        if(NULL == phead){//处理链表为空
                printf("link is empty\n");
                return NULL;
        }else{
                while(phead != NULL){//将旧链上的结点链到新链上
                        tmp = phead;
                        phead = phead->next;
                        tmp->next = ptmp;
                        ptmp = tmp;
                }
        }
        return ptmp;
}

8.链表的排序（冒泡排序）

    //链表排序(冒泡)
    NODE *linksort(NODE *phead)
    {
        NODE *p = NULL; //i
        NODE *q = NULL; //j
        NODE *r = NULL; 
        NODE tmp; 

        for(p = phead; p; p = p->next){
                for(q = p->next; q; q = q->next){
                        if(p->data > q->data){
                                tmp = *p;//整个结点交换
                                *p = *q;
                                *q = tmp;
                                r = p->next;//将指针换回去
                                p->next = q->next;
                                q->next = r;
                        }
                }
        }

        return phead;
    }

冒泡排序的时间复杂度为O(n²)

下面是补充：

1. 递归打印链表

void show_linklist(PNODE *phead) 
{
        if(phead == NULL){
                return;
        }else{
                printf("%d\t", phead->data);
                show_linklist(phead->pnext);
                //将此行放在printf的前面则递归打印倒置链表
        }
}

2.链表快速排序

PNODE *divide_two_Qsort(PNODE *phead, PNODE *ptail)
{
        int key = phead->data;
        PNODE *p = phead;
        PNODE *q = phead->pnext;

        while(q != ptail){ 
                if(q->data < key){
                        p = p->pnext;
                        int tmp;
                        tmp = p->data;
                        p->data = q->data;
                        q->data = tmp;
                }       
                q = q->pnext;
        }
        int tmp = p->data;
        p->data = phead->data;
        phead->data = tmp;

        return p;
}

void quicksort_linklist(PNODE *phead, PNODE *ptail)
{
        if(phead != ptail){
                PNODE *pmid = divide_two_Qsort(phead, ptail);
                quicksort_linklist(phead, pmid);
                quicksort_linklist(pmid->pnext, ptail);
        }
}

3. 递归计算链表长度

int getlistlen_recursion(PNODE *phead)
{
        if(phead == NULL)
                return 0;
        else
                return 1+getlistlen_recursion(phead->pnext);
}

4.反转链表（非递归）

PNODE *invert_linklist(PNODE *phead)
{
        if(phead == NULL || phead->pnext == NULL){
                return phead;
        }else{
                PNODE *p = phead;
                PNODE *q = NULL;
                PNODE *r = NULL;
                while(p != NULL){
                        q = p->pnext;//保存下一个节点
                        p->pnext = r;//让该节点指向上一个节点
                        r = p;//上一个节点走到当前节点
                        p = q;//当前节点走到下一个节点
                }
                return r;
        }
}

5.反转链表（递归）

PNODE *invert_linklist_recursion(PNODE *phead)
{
        if(phead == NULL || phead->pnext == NULL){
                return phead;
        }else{
                PNODE *p = phead;//保存头节点
                PNODE *q = p->pnext;//保存下一个节点
                phead = invert_linklist_recursion(q);//递归到最后一个几点,返回转置后链表的地址
                q->pnext = p;//让后面的节点指向前一个节点
                p->pnext = NULL;//每次递归返回都赋值为空，最后一次返回将转置后的节点的pnext赋值为空
                return phead;
        }
}

6.合并两个有序链表（非递归）

PNODE *merge_linklist(PNODE *phead1, PNODE *phead2)
{
        if(phead1 == NULL){
                return phead2;
        }else if(phead2 == NULL){
                return phead1;
        }

        PNODE *phead = NULL;

        if(phead1->data < phead2->data){
                phead = phead1;
                phead1 = phead1->pnext;
        }else{
                phead = phead2;
                phead2 = phead2->pnext;
        }//让phead找到最小的头节点

        PNODE *pcur = phead;//要比较节点(phead1 或 phead2)的上一个节点
        while(phead1 != NULL && phead2 != NULL){
                if(phead1->data < phead2->data){
                        pcur->pnext = phead1;
                        pcur = phead1;
                        phead1 = phead1->pnext;
                }else{
                        pcur->pnext = phead2;
                        pcur = phead2;
                        phead2 = phead2->pnext;
                }
        }

        pcur->pnext = ((phead1 == NULL) ? phead2 : phead1);

        return phead;
}

7.合并两个有序链表（递归）

PNODE *merge_linklist_recursion(PNODE *phead1, PNODE *phead2)
{
        if(phead1 == NULL){
                return phead2;  
        }else if(phead2 == NULL){
                return phead1;
        }       
        PNODE *phead = NULL;
        if(phead1->data < phead2->data){
                phead = phead1;
                phead->pnext = merge_linklist_recursion(phead1->pnext, phead2);
        }else{  
                phead = phead2;
                phead->pnext = merge_linklist_recursion(phead1, phead2->pnext);
        }
        return phead;
}

8.找到链表中间节点

PNODE *find_midnode(PNODE *phead)
{
        if(phead == NULL || phead->pnext == NULL){
                return phead;
        }

        PNODE *p1 = phead;
        PNODE *p2 = phead;
        while(p2->pnext != NULL){
                p1 = p1->pnext;//p1走一步
                p2 = p2->pnext;
                if(p2->pnext != NULL){
                        p2 = p2->pnext;//p2走两步
                }
        }
        return p1;
}

9.判断链表是否有环

int is_circularlinklist(PNODE *phead)
{
        if(phead == NULL || phead->pnext == NULL){
                return 0;       
        }
        PNODE *p1 = phead;
        PNODE *p2 = phead;
        while(p1 != NULL && p2 != NULL){
                p2 = p2->pnext; 
                if(p1 == p2)
                        return 1;
                p2 = p2->pnext;
                p1 = p1->pnext;
        }
        return 0;
}

10.释放链表

void destory_linklist(PNODE *phead) 
{
        PNODE *ptmp;
        while(phead != NULL){
                ptmp = phead;
                phead = phead->pnext;
                free(ptmp);
                ptmp = NULL;
        }
}