数据结构之单链表(C实现)

最新推荐文章于 2022-04-21 23:32:49 发布
最新推荐文章于 2022-04-21 23:32:49 发布
阅读量61 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/linuxAndMcu/p/7535675.html
版权

list.h

#ifndef LIST_H
#define LIST_H

#include <iostream>
#include <stdio.h>
#include <malloc.h>

//定义单链表结点
typedef struct _node
{
    int data;   //数据
    struct _node *next; //指向下一结点
}node,*pNode;

//创建链表
node *create_list();

//从链表头后插入数据
int insert_listHead(pNode head,int data);

//从链表尾后插入数据
int insert_listTail(pNode head, int data);

//遍历链表，并显示每个结点的数据
int show_listData(pNode head);

//求链表中的结点个数 (不包括链表头,指真正存放数据的结点数目)
int getNodeNum(pNode head);

//根据索引查找结点，找到返回所找结点 index=0,对应头结点(不存放数据) index=1,对应第一个数据结点
pNode find_nodeByIndex(pNode head,int index);

//根据数据查找第一个符合结点(后面也可能有结点的数据为所找数据)，找到返回所找结点
pNode find_nodeByData(pNode head,int data);

//指定位置插入结点数据
int insert_dataInPos(pNode head,int data,int index);

//从链表中删除第index个结点  index范围为1-nodeNum
int delete_listIndex(pNode head,int index);

//删除整个链表
int delete_listAll(node **head);

//根据索引查找结点，找到修改其值
int modify_nodeByIndex(pNode head,int index,int data);

//将链表排序 ==0,升序  ==1,降序
int sort_list(pNode head,int sortType);

#endif // LIST_H

 

list.c

#include "list.h"

/*************单链表测试程序************/

//创建链表
node *create_list()
{
    pNode head = (pNode)malloc(sizeof(node));
    if(!head)
    {
        printf("malloc error!\n");
//        exit(-1);   //在iostream中定义
        return NULL;
    }

    head->data = 0;
    head->next = NULL;  //不用指向head,由于不是循环链表且是单链表的尾结点的next腰指向NULL

    return head;
}

//从链表头后插入结点数据
int insert_listHead(pNode head,int data)
{
    //检测链表是否存在
    if(!head)
    {
        printf("list isnot exist!\n");
        return -1;
    }

    pNode tmpNode = (pNode)malloc(sizeof(node));    //存放插入数据的结点
    if(!tmpNode)
    {
        printf("malloc error!\n");
        return -1;
    }

    //将插入数据存入要插入链表的结点
    tmpNode->data = data;
    //将tmpNode插入链表头后
    tmpNode->next = head->next;
    head->next = tmpNode;

    return 0;
}

//从链表尾后插入结点数据
int insert_listTail(pNode head, int data)
{
    //检测链表是否存在
    if(!head)
    {
        printf("list isnot exist!\n");
        return -1;
    }

    pNode tmpNode = (pNode)malloc(sizeof(node));    //存放插入数据的结点
    if(!tmpNode)
    {
        printf("malloc error!\n");
        return -1;
    }

    //将插入数据存入要插入链表的结点
    tmpNode->data = data;
    //将tmpNode插入链表尾后
    tmpNode->next = NULL;   //插入链表插入链表尾后，成为新的尾结点，next要指向NULL

    pNode cur = head;
    //找到链表尾结点
    while(cur->next)    //尾结点的next指向NULL，跳出时的cur即为尾结点
    {
        cur = cur->next;
    }

    cur->next = tmpNode;    //原先尾结点的next指向插入结点

    return 0;
}

//遍历链表，并显示每个结点的数据
int show_listData(pNode head)
{
    //检测链表是否存在
    if(!head)
    {
        printf("list isnot exist!\n");
        return -1;
    }

    //检测链表是否为空  (“为空”与“不存在”不同，为空说明只有一个结点，刚创建还未插入任何结点)
    if(!head->next)
    {
        printf("list isnot exist!\n");
        return -1;
    }

    pNode cur = head->next; //头结点数据域不保存插入数据，第二个结点才是第一个插入结点
    while(cur)
    {
        printf("%d ",cur->data);
        cur = cur->next;
    }
    printf("\n");

    return 0;
}

//求链表中的结点个数 (不包括链表头,指真正存放数据的结点数目)
int getNodeNum(pNode head)
{
    int nodeNum = 0;    //结点数目

    //判断链表是否存在
    if(!head)
    {
        printf("list isnot exist!\n");
        return -1;
    }
    //------
    //判断链表是否为空
    if(!head->next)
    {
        printf("list is NULL!\n");
        return -1;
    }

    pNode cur = head->next;
    while(cur)
    {
        nodeNum++;
        cur = cur->next;
    }

    return nodeNum;
}

//根据索引查找结点，找到返回所找结点 index=0,对应头结点(不存放数据) index=1,对应第一个数据结点
pNode find_nodeByIndex(pNode head,int index)
{
    //判断链表是否存在
    if(!head)
    {
        printf("list isnot exist!\n");
        return NULL;
    }
    //------
    //判断链表是否为空
    if(!head->next)
    {
        printf("list is NULL!\n");
        return NULL;
    }
    //------
    int nodeNum = getNodeNum(head);
    if(index<=0 || index > nodeNum)   //索引必须在允许范围 (1-nodeNum)
    {
        printf("pos out of range!\n");
        return NULL;
    }

    int i = 0;
    pNode cur =  head;
    while(cur)
    {
        i++;
        cur = cur->next;
        if(i==index)
            return cur;
    }

    return NULL;    //不返回，有警告
}

//根据数据查找第一个符合结点(后面也可能有结点的数据为所找数据)，找到返回所找结点
pNode find_nodeByData(pNode head,int data)
{
    //判断链表是否存在
    if(!head)
    {
        printf("list isnot exist!\n");
        return NULL;
    }
    //------
    //判断链表是否为空
    if(!head->next)
    {
        printf("list is NULL!\n");
        return NULL;
    }

    pNode cur =  head->next;
    while(cur)
    {
        if(cur->data == data)
            return cur;
        cur = cur->next;
    }

    return NULL;
}

//指定位置插入结点数据
int insert_dataInPos(pNode head,int data,int index)
{
    //判断链表是否存在
    if(!head)
    {
        printf("list isnot exist!\n");
        return -1;
    }
    //------
    //判断链表是否为空
    if(!head->next)
    {
        printf("list is NULL!\n");
        return -1;
    }
    //------
    int nodeNum = getNodeNum(head);
    if(index<=0 || index > nodeNum)   //指定插入位置必须在允许范围
    {
        printf("pos out of range!\n");
        return -1;
    }

    //由于find_nodeByIndex的参数2范围限制为1-nodeNum,所以index在那里不能为1,要>=2
    if(index==1)    //插入到位置1，相当于插入头结点后面
    {
        insert_listHead(head,data);
    }
    else    //index范围为2-nodeNum
    {
        pNode tmpNode = (pNode)malloc(sizeof(node));
        if(!tmpNode)
        {
            printf("malloc error!\n");
            return -1;
        }
        tmpNode->data = data;

        //获得插入位置的前一个结点-insertFrontNode(新数据结点插入到该结点后面)
        pNode insertFrontNode = find_nodeByIndex(head,index-1);
        if(!insertFrontNode)   //未找到要被插入的结点
        {
            printf("no find insertFrontNode!\n");
            return -1;
        }

        //若index=2,相当于新数据结点插入到原数据结点1后面，所以需要找到原数据结点1
        tmpNode->next = insertFrontNode->next;
        insertFrontNode->next = tmpNode;
    }

    return 0;
}

//从链表中删除第index个结点  index范围为2-nodeNum
int delete_listIndex(pNode head,int index)
{
    //判断链表是否存在
    if(!head)
    {
        printf("list isnot exist!\n");
        return -1;
    }
    //------
    //判断链表是否为空
    if(!head->next)
    {
        printf("list is NULL!\n");
        return -1;
    }
    //------
    int nodeNum = getNodeNum(head);
    if(index<=1 || index > nodeNum)   //index必须在允许范围
    {
        printf("pos out of range!\n");
        return -1;
    }

    pNode front =  find_nodeByIndex(head,index-1);    //找到要删除结点的前一个结点
    if(!front)
    {
        printf("no find!\n");
        return -1;
    }
    //---------
    pNode cur =  find_nodeByIndex(head,index);    //找到要删除结点
    if(!cur)
    {
        printf("no find!\n");
        return -1;
    }

    //删除该结点
    front->next = cur->next;
    free(cur);
    cur = NULL;

    return 0;
}

//删除整个链表
int delete_listAll(node **head)
{
    if(*head == NULL)
    {
        printf("list isnot exist!\n");
        return -1;
    }

    node *cur = (*head)->next;

    while(cur)
    {
        node *tmp = cur;

        //在free(tmp);后面,那时cur==tmp已经被释放,cur = cur->next不能正常执行了
        cur = cur->next;

        free(tmp);
        tmp = NULL;
    }

    free(*head);
    (*head) = NULL;

    return 0;
}

//根据索引查找结点，找到修改其值
int modify_nodeByIndex(pNode head,int index,int data)
{
    pNode modifyNode =  find_nodeByIndex(head,index); //找到要修改的结点
    modifyNode->data = data;

    return 0;    //不返回，有警告
}

//将链表排序 ==0,升序  ==1,降序
int sort_list(pNode head,int sortType)
{
    //判断链表是否存在
    if(!head)
    {
        printf("list isnot exist!\n");
        return -1;
    }
    //------
    //判断链表是否为空
    if(!head->next)
    {
        printf("list is NULL!\n");
        return -1;
    }

    int nodeNum = getNodeNum(head);

    int i,j;
    for(i = 0; i < nodeNum - 1; i++) //冒泡排序法
    {
        for(j = 0; j < nodeNum - 1 - i; j++)
        {
            //第一次获取0,1结点 第二次获取1,0结点
            node *t_first = find_nodeByIndex(head,j+1);
            node *t_second = find_nodeByIndex(head,j+2);

            if(sortType == 0)   //升序
            {
                if(t_first->data > t_second->data)
                {
                    //交换2个结点的值
                    int tmp = t_first->data;
                    t_first->data = t_second->data;
                    t_second->data = tmp;
                }
            }
            else if(sortType == 1)  //降序
            {
                if(t_first->data < t_second->data)
                {
                    int tmp = t_first->data;
                    t_first->data = t_second->data;
                    t_second->data = tmp;
                }
            }
            else
            {
                printf("parame error!\n");
                return -1;
            }

        }
    }

    return 0;
}

main.c

#include <iostream>
#include <stdio.h>
#include <malloc.h>
#include "list.h"

using namespace std;

pNode tmpNode;
int main(void)
{
    //创建链表
    tmpNode = create_list();
    if(!tmpNode)
    {
        printf("malloc error!\n");
        return -1;
    }

    //插入1,3,5,7,9到链表中
    for(int i=0;i<10;i++)
    {
        insert_listHead(tmpNode,++i);
    }

    //插入结点数据
    insert_dataInPos(tmpNode,12,2);

    //获取结点数目
    printf("nodeNum=%d\n",getNodeNum(tmpNode));

    //遍历显示结点数据
    printf("showList: ");
    show_listData(tmpNode);

    //根据索引,返回第3个数据结点 index范围为1-nodeNum
    pNode t_node = find_nodeByIndex(tmpNode,3);
    if(!t_node)    //有可能未找到，则返回NULL,那执行t_node->data会造成程序崩溃
        printf("no find!\n");
    else
        printf("t_data:data=%d\n",t_node->data);
    //返回数据为1的结点
    pNode t_node1 = find_nodeByData(tmpNode,1);
    if(!t_node1)
        printf("no find!\n");
    else
        printf("t_data:data=%d\n",t_node1->data);

    //从链表中删除第1个结点  index范围为2-nodeNum
    delete_listIndex(tmpNode,2);
    printf("showList: ");
    show_listData(tmpNode);

    //升序后显示结点数据
    sort_list(tmpNode,0);
    printf("sortUp showList: ");
    show_listData(tmpNode);

    //降序后显示结点数据
    sort_list(tmpNode,1);
    printf("sortUp showList: ");
    show_listData(tmpNode);

    //删除所有结点
    delete_listAll(&tmpNode);
    printf("showList: ");
    show_listData(tmpNode);


}

 

结果运行图:

 

转载于:https://www.cnblogs.com/linuxAndMcu/p/7535675.html

weixin_30755393
关注
数据结构 单链表 C语言实现
Baron_wu的博客
03-05 967
单链表 单链表 顺序存储线性表 分配方式 分散存储 集中存储 时间性能 查找O(n) 插入删除O(1) 查找O(1) 插入删除O(n) 空间性能 无需分配空间，元素可以无限扩充 分配空间，元素个数有限 c语言代码实现（单链表） // // main.c // 线性表链式存储结构 // // Created by Kinble Wu on 2020/3/2. /...
数据结构-C语言实现单链表-数据结构学习
最新发布
05-26
C语言实现的数据结构中的单链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对链表边界的判定 实现了以下功能： 创建单链表 向顺序表中插入元素(头插法，尾插...
c++指针构建链表实现单链表的建立
03-21
C语言实现单链表的建立、输入、插入、删除、查找元素并返回位置.这些都是通过c语言的数据结构编程的。
数据结构基础（3）---C语言实现单链表
weixin_34281477的博客
01-23 98
#include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #include&lt;stdbool.h&gt; /** **链表节点的定义 */ typedef struct Node{ int data;//数据域 struct Node * PNext;//指针域，存放下一个节点的地址 } Node ,* PNode ; /** **创建链表 *...
数据结构与算法分析-用C语言实现单链表
weixin_30613343的博客
05-19 285
掌握单链表很容易，把下面的代码弄懂，敲几遍，全部记住，而且记清每一个细节。 首先，在List.h中声明单链表的ADT.我们把我们所需要的自定义类型啊，函数啊，都声明出来，但这里我们只是声明他们，而具体实现则是在List.c中进行。 /** * @file List.h * @brief 单链表的声明 * @details * @author mr...
单链表的实现与应用
weixin_45275526的博客
12-06 422
#include<stdio.h> #include<stdlib.h> #include<malloc.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -1 typedef int ElemType; typedef int Status; typ...
单链表及其实现
Shallowmm的博客
09-16 416
单链表和快慢指针 链表是一种重要的数据结构，为了防止忘记单链表，写一篇博客用来复习。 单链表采用结构指针来实现，首先定义一个结构体，里面存放数据和指向下一个结点的指针。 typedef struct LNode { int data; struct LNode* next; } LNode; typedef struct LNode *LinkList; 实现代码 #include <stdio.h> #include <stdlib.h> #include <time
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
数据结构C语言单链表上实现插入和删除的算法实验报告.docx
05-30
"数据结构C语言单链表上实现插入和删除的算法实验报告" 本文档是关于数据结构中的单链表实现插入和删除操作的算法实验报告，使用C语言编写，并提供了详细的实验步骤和实验结果。 单链表的基本操作 单链表是一种...
数据结构 C语言实现循环单链表的实例
08-30
数据结构 C语言实现循环单链表的实例 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、表示和操作的方法。在计算机科学中，数据结构是指数据的组织、存储和操作的方法。循环单链表是一种常见的数据...
数据结构课程设计单链表的操作实现
12-23
点链表的操作与实现 自己写的 蛮好 用
数据结构-单链表的实现方式
weixin_43296982的博客
02-15 901
线性表（链表） 定义：n个数据元素的有限序列，n是表长度 （自己写带表头节点的链表，区别带表头结点和不带表头节点的链表） 特点： 1、除第一个元素外，其他元素有且只有一个直接前驱。 2、除最后一个元素外，其他元素有且只有一个直接后继。 单链表 静态链表 静态链表实现方法，先定义数组后，再让相应的元素指向后一个节点。空间分配以数组形式分配，访问方式按照链表的访问方式来访问。 特点： 1、每个节点由结点构成（结点由数据域和指针域组成，用结构体来定义） 结构体中有指针，只能是结构体自己的指针 2、线性结构 判
c语言实现单链表&二级指针在单链表的应用
echo
06-26 2337
c语言实现单链表 二级指针在单链表的使用
单链表（结构体与类实现）
Nick
12-12 2359
1.单链表数据结构，自带sort函数按照从小到大排列，插入数据时，从链表头往后扫，将插入数据放在遇到的第一个比插入data小的数的前一位。2.代码#include<iostream> using namespace std;struct LinkNode { public: LinkNode(int value = 0) { nValue = value; p
数据结构中单链表的基本操作
tyeerth的博客
04-06 2557
单链表的基本操作 文章目录单链表的基本操作一、定义数据结构定义：二、基本操作。1、初始化线性表2、判断线性表是否为空表3、销毁线性表4、求线性表的长度5、链表中插入数据6、删除指定位置上的元素7、按元素值进行查找8、找元素第一次出现的位置9、求指定位置上的元素值10、打印单链表11、头插法创建单链表(输出与数组顺序相反)12、尾插法创建单链表(输出与数组顺序相同)三、常用算法。1、单链表的排序（采...
【数据结构】单链表的操作
qq_45972928的博客
04-21 6231
内容： 1）实现单链表的以下基本操作：建立单链表，查找单链表，插入单链表，删除单链表。 2）采用单链表结构编程实现：两个有序单链表的归并运算。 实现思路： ① 定义数据域类型； ② 定义单链表，分为数据域和指针域； ③ 分别编写实现前插法创建单链表、后插法创建单链表、初始化单链表、单链表的查找、向单链表插入元素、删除单链表中某元素、遍历单链表并显示、求单链表最大节点、判断单链表是否为空、求单链表长度、逆转单链表、两个有序单链表的归并等函数功能； ④ 在主函数中定义单链表； ⑤ 使用while实现循环操.
数据结构C语言 单链表基本操作
徐大大的博客
04-07 1889
1．建立单链表，并在单链表上实现插入、删除和查找操作（验证性内容） 2．具有良好的操作、交互功能。 编程实现如下功能： （1）根据输入单链表的长度n和各个数据元素值（整数），用头插法（或尾插法）建立单链表，并输出单链表中各元素值，观察输入的内容与输出的内容是否一致。 （2）在单链表的第i个元素之前插入一个值为x的元素，并输出插入后的单链表中各元素值。 （3）删除单链表中第i个元素，并输出删除后的单链表中各元素值。 （4）在单链表中查找第i个元素，如果查找成功，则显示该元素的值，否则显示该元素不存在。 编译环
数据结构单链表及基本操作实现(C语言实现)
qq_42169456的博客
09-14 718
单链表的基本操作的实现 定义(个人看法)：单向链表是通过指针的方式将个各个节点串联起来形成链式结构； 特点：具有插入和删除操作方便，但其访问链表中的元素没有顺序表快； #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <error.h> typedef int ElementType; typedef struct LNode *LinkList; struct LNod
数据结构与算法设计-----单链表操作
apple_50916469的博客
03-26 1590
实验目的： 1、掌握线性表的链式存储结构的表示与实现。 2、掌握和验证单链表上各类操作的实现方法。 3、掌握C++编程中的一些基本编程规范。 实验要求： 实现单链表的基本操作 1）构造空的单链表； 2）建立含有若干数据元素的单链表并输出； 3）求表长； 4）获取第三个元素的值； 5）在第四个位置后，插入一个值为“38”的新的元素后输出单链表； 6）删除第五个位置上的元素后输出单链表； 测试数据：23 33 21 45 67 98 下面就以本次实验来讲解单链表操作的实现： 一、首先需要自定义一个结点类型的结构
C语言实现单链表数据结构详解及实例
本教程主要关注使用C语言实现单链表数据结构。 首先，链表之所以被广泛使用，是因为它弥补了数组的不足。数组在定义时需要预先指定大小，这可能导致存储空间的浪费，而链表则允许在运行时动态地添加或删除元素，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值