数据结构学习：单链表

已于 2024-08-27 17:11:12 修改
阅读量434 收藏 4
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 学习 链表
于 2024-08-26 21:18:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kkbbaaii/article/details/141571242
版权

单链表简介

将线性表L = (a_{0},.....a_{i-1},a_{i},a_{i+1} ..... a_{n-1})中的个元素分布在存储器的不同存储块，每个部分称为节点，通过地址或指针建立元素之间的联系。

节点的示意图如下，

节点的data域存放数据元素 a_{i},而next域是一个指针，指针指向a_{i}的直接后继a_{i+1}所在的节点。

一个链表的图示如下，

头节点和头指针

头节点就是在编程时，在单链表的第一个结点前附设一个结点就称为头结点。

头指针指的就是链表中第一个结点的存储位置。

头节点和头指针的异同如下，

单链表C语言编写

单链表在C语言下编写的结构代码如下，

／＊线性表的单链表存储结构＊／
tγpedef struct node
｛
    data_t data;        /*节点的数据域*/
    struct node *next;  /*节点的后继指针域*/
｝listnode,*linklist;

        下面我们将编写一些顺序表相关的函数，在编写时我们一般会创建三个文件，分别是sqlist.h，sqlist.c，test.c，其中sqlist.h用于编写一些数据结构的定义和函数结构，sqlist.c用于编写函数具体实现，test.c用于测试每个函数是否正确。

在sqlist.h文件中，编写的程序如下，

typedef int data_t;/*此处的类型视情况而定，此处为简单选用整型*/

typedef struct node
{
    data_t data;
    struct node *next;   
}listnode,*linklist;


linklist list_creat();
int list_tail_insert(linklist H,data_t value);
int list_show(linklist H);
linklist list_get(linklist H,int pos);
int list_insert(linklist H,data_t value,int pos);
int list_delete(linklist H,int pos);
linklist list_free(linklist H);
int list_reverse(linklist H);
linklist list_adjmax(linklist H,data_t *value);
int list_merge(linklist A,linklist B);

在sqlist.h文件中，我们编写相关函数的具体实现，以下是每个操作API函数的实现，

创建单链表

/*建立单链表*/
/*依次读入表中的每一个元素，如果ai != 结束符-1，则表示创建一个节点
然后插入表尾，返回链表头节点指针*/
linklist list_creat()
{
    linklist H;
    //为单链表申请内存
    H = (linklist)malloc(sizeof(listnode));

    if(H == NULL)
    {
        printf("malloc fail\n");
        return H;
    }

    /*赋初值*/
    H->data = 0;
    H->next = NULL;

    return NULL;
}

尾部插入元素 

/*尾部插入元素到链表*/
int list_tail_insert(linklist H,data_t value)
{
    linklist p;
    linklist q;

    if(H == NULL)
    {
        printf("H is enpty\n");
        return -1;
    }

    /*1，首先我们得将传入的数据封装成一个新节点，其实就是创建新节点*/
    p = (linklist)malloc(sizeof(listnode));
    if(p == NULL)
    {
        printf("malloc fail\n");
        return H;
    }    

    p->data = value;
    p->next = NULL;/*由于是尾部节点，所以next为空*/

    /*2，然后我们需要找到之前的尾节点的位置，通过判断节点的next是否为空可以找到*/
    q = H;
    while(q->next != NULL)
    {
        q = q->next;
    }

    /*3，最后将新节点插入到尾部*/
    q->next = p;/*将之前链表的最后一个next由NULL变成指向p,也就是新插入尾部的链表*/

    return 0;
}

遍历单链表 

/*遍历单链表*/
int list_show(linklist H)
{
    linklist p;
    if(H == NULL)
    {
        printf("H is enpty\n");
        return -1;
    }

    p = H;
    while (p->next != NULL)
    {
        printf("%d\n",p->next->data);
    }

    puts("");
    return 0;
    

}

元素查找 

/*链表查找*/
/*(1)按序号查找     (2)按值查找*/
/*查找某个位置上的节点*/
/*其中初始头节点对应的值是 -1 依次往后分别是 0 1 2 ...*/
linklist list_get(linklist H,int pos)
{
    linklist p;
    int i;
    if(H == NULL)
    {
        printf("H is enpty\n");
        return NULL;
    }

    

    if(pos < -1)
    {
        printf("pos is invalid\n");
        return NULL;
    }
        

    p = H;
    for(i=-1;i<pos;i++)
    {
        p = p->next; 
        if(p = NULL)
        {
            printf("pos is invalid\n");
            return NULL;
        }
                   
    }

    return p;

}

元素插入

将元素插入到链表中，示意图如下，

/*链表插入，将x插入到节点ai之前*/
int list_insert(linklist H,data_t value,int pos)
{
    linklist p;
    linklist q;

    if(H == NULL)
    {
        printf("H is enpty\n");
        return NULL;
    } 

    /*查找插入位置前一个*/
    q = list_get(H,pos-1);
    if(q == NULL)
        return -1;

    /*创建要插入的新节点*/
    p = (linklist)malloc(sizeof(listnode));
    if(p == NULL)
    {
        printf("malloc fail\n");
        return p;
    }  
    p->data = value;
    p->next = NULL;

    /*调整节点的链接*/
    p->next = q->next;/*由于是尾部节点，所以next为空*/
    q->next = p;


    return 0;
}

元素删除 

元素删除示意图如下，

/*链表删除*/
/*同插入法，按位置删除*/
int list_delete(linklist H,int pos)
{
    linklist p;

    if(H == NULL)
    {
        printf("H is enpty\n");
        return NULL;
    } 
 

    /*找到要删除节点位置的前一个节点*/
    p = list_get(H,pos-1);
    if(p = NULL)
        return -1;
    if (p->next = NULL)
    {
        printf("delete pos is invalid\n");
        return -1;
    }

    /*更新链表，重新进行连接*/
    p->next = p->next->next;

    /*把节点的内存进行释放，因为通过malloc在堆山申请的，不释放会导致内存泄漏*/
    free(p->next);
    p->next =NULL;
    
    return 0;
    
}

释放链表 

/*链表释放*/
/*也就是删除链表所有的元素*/
linklist list_free(linklist H)
{
    linklist p;

    if(H == NULL)
    {
        printf("H is enpty\n");
        return NULL;
    } 

    p = H;
    while (H != NULL)
    {
        p = H;
        H = H->next;
        free(p);
        
    }

    return NULL;
    
}

上面的函数是单链表的一些基本函数，下面编写一些有难度的函数，

链表反转

思路是，依次取出原链表中的各个节点，将其作为新链表首届点插入到H节点之后

/*单链表翻转*/
/*链表的第一个元素在最后，最后一个元素在中间，其他元素依次类推*/
int list_reverse(linklist H)
{
    linklist q;
    linklist p;

    /*判断特殊条件，链表为空或者只有一个元素不需要翻转*/
    if(H == NULL )
    {
        return -1;
    }

    if(H->next || H->next->next == NULL)
    {
        return 0;
    }


    /*进行翻转操作，每一次断成两个链表*/

    q = H->next->next;

    H->next->next = NULL;


    while(p != NULL)
    {
        q = p;
        p = p->next;
        q->next = H->next;
        H->next = q;
                  
    }
    return 0；
}

求和最大 

/*假设节点数据域是整型，求列表中相邻两节点data值之和为最大的第一节点，返回第一节点的指针*/
linklist list_adjmax(linklist H,data_t *value)
{
    linklist p;
    linklist q;
    linklist r;
    int sum;

    /*判断特殊情况*/
    if(H == NULL )
    {
        return NULL;
    }

    if(H->next == NULL ||H->next->next == NULL || H->next->next->next == NULL )
    {
        return H->next;
    }

    /*初始化参数*/
    p = H->next;
    q = p->next;
    r = p;
    sum = p->data + q->data;


    while(q->next != NULL)
    {

        /*指针往后移*/
        p = p->next;
        q = q->next;

        if(p->data + q->data > sum)
        {
            sum = p->data + q->data;
            r = p;
        }


    }

    *value = sum;
    return r;
}

链表排序 

将两个单链表，本身就是按照递增排序，将表A和B合并之后，表A也按照递增排序，示意图如下，

/*链表排序*/
/*将两个单链表，本身就是按照递增排序，将表A和B合并之后，表A也按照递增排序*/
int list_merge(linklist A,linklist B)
{
    linklist p,q,r;

    if(A == NULL && B == NULL)
    {
        return -1;
    }

    p = A->next;
    q = B->next;
    A->next = NULL;
    B->next = NULL;

    /*把链表A作为最后合并的链表*/
    r = A;

    while(q && p)
    {
        if(p->data < q->data)
        {
            r->next = p;
            p = p->next;
            r = r->next;
            r->next = NULL;
        }
        else
        {
            r->next = p;
            q = q->next;
            r = r->next;
            r->next = NULL;            
        }
       
    }

    /*由于剩下的列表本身就有序，所以可以直接插入*/
    if(q == NULL)
    {
        r->next = p;
    }
    else
    {
        r->next = q;
    }

}

上述是编写的关于单链表的相关函数，当然，单链表的操作函数众多，大家可以按照自己的理解进行编写。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值