C语言链表

最新推荐文章于 2023-08-15 16:50:52 发布
最新推荐文章于 2023-08-15 16:50:52 发布
阅读量947 收藏 5
点赞数 1
分类专栏： c++基础 文章标签： 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coolwriter/article/details/78615806
版权 
#define  _CRT_SECURE_NO_WARNINGS 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

/*
struct Teacher 
{
    char name[64];
    int id;
    char *p;
    char **p2;
};
typedef struct Teacher Teacher ;
*/


typedef struct Student 
{
    char name[64];
    int id;

}Student;

typedef struct Teacher 
{
    char name[64];
    int id;
    char *p;
    char **p2;
    Student s1;
    Student *p3;
}Teacher;

//1 结构体中套一个结构体
//2             结构体的指针
//3 结构中套一个 自己类型的结构体元素。。。err
//4 结构体中 套一个 指向自己类型的指针

//数据类型本质：固定大小内存块的别名 

/*
typedef struct AdvTeacher 
{
    char name[64];
    int id;
    struct AdvTeacher AdvTeacher;
}AdvTeacher;  //在自己类型大小 还没有确定的情况下 引用自己类型的元素 是不正确的
//结构体不能嵌套定义 （确定不了数据类型的内存大小，分配不了内存）
*/

typedef struct AdvTeacher2 
{
    char name[64];
    int id;
    struct AdvTeacher2 *p2;
}AdvTeacher;


//函数的嵌套调用  和 结构数据类型嵌套定义 是两个不同的概念
void main11()
{
    Teacher t1;
    //AdvTeacher  advT1; //
    printf("hello...\n");
    system("pause");
    main();
    return ;
}
#define  _CRT_SECURE_NO_WARNINGS 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

//类
typedef struct Teacher
{
    int data;
    struct Teacher *next;
}Teacher;

//静态链表
//固定个数  结点的内存生命周期

//动态链表
Teacher *CreatlIST(Teacher **retHead, Teacher **retEnd, Teacher **retmid)
{
    static Teacher t1, t2, t3,t4;
    Teacher *p = NULL;
    t1.data = 1;
    t2.data = 2;
    t3.data = 3;
    t4.data = 4;

    t1.next = &t2;
    t2.next = &t3;
    t3.next = &t4;
    t4.next = 0;


    p = &t1;
    while (p)
    {
        printf("data:%d \n", p->data);
        p = p->next; //指针的下移 
    }
    *retHead = &t1;
    *retEnd = &t4;
    *retmid = &t2;
    return  &t4;
}
void main()
{
    Teacher *head;
    Teacher *end;
    Teacher *end2;
    Teacher *mid;
    end2 = CreatlIST(&head,&end,&mid);
    printf("head:%d\n",head->data);
    printf("end:%d\n", end->data);
    printf("end:%d\n", end2->data);
    printf("mid:%d\n", mid->data);
    printf("hello...\n");
    system("pause");
    return;
}

这里写图片描述

#define  _CRT_SECURE_NO_WARNINGS 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

typedef struct Node
{
    int data;
    struct Node *next;
}SLIST;

SLIST *SList_Create(); //创建链表
int SList_Print(SLIST *pHead); //遍历链表
int SList_NodeInsert(SLIST *pHead, int x, int y); //插入值  在x值之前 删除y
int SList_NodeDel(SLIST *pHead, int y);
int SList_Destory(SLIST *pHead);


SLIST *SList_Create()
{

    SLIST *pHead, *pM, *pCur;
    int     data;
    //创建头节点 并初始化
    pHead = (SLIST *)malloc(sizeof(SLIST));
    if (pHead == NULL)
    {
        return NULL;
    }
    pHead->data = 0;
    pHead->next = NULL;

    printf("\nplease enter you data: ");
    scanf("%d", &data);

    pCur = pHead;

    while (data != -1)
    {
        //创建业务节点 并初始化 不断接受输入 malloc新结点
        pM = (SLIST *)malloc(sizeof(SLIST));
        if (pM == NULL)
        {
            return NULL;
        }
        pM->data = data;
        pM->next = NULL;

        //2 新结点 入链表 
        pCur->next = pM;

        //3 新结点变成当前节点
        pCur = pM;  //链表结点的尾部追加 

        printf("\nplease enter you data: ");
        scanf("%d", &data);
    }

    return pHead;
}
int SList_Print(SLIST *pHead)
{
    SLIST *tmp = NULL;
    if (pHead == NULL)
    {
        return -1;
    }
    tmp = pHead->next;

    printf("\nBegin\t");
    while (tmp)
    {
        printf("%d ", tmp->data);
        tmp = tmp->next;
    }
    printf("\tEnd");
    return 0;
}

int SList_NodeInsert(SLIST *pHead, int x, int y)
{
    SLIST *pM, *pCur, *pPre;

    //创建新的业务节点pM
    pM = (SLIST *)malloc(sizeof(SLIST));
    if (pM == NULL)
    {
        return -1;
    }
    pM->next = NULL;
    pM->data = y;

    //遍历链表
    pPre = pHead;
    pCur = pHead->next;

    while (pCur)
    {
        if (pCur->data == x)
        {
            break;
        }
        pPre = pCur;
        pCur = pCur->next;
    }

    //让新结点 连接 后续链表
    pM->next = pPre->next;
    //让前驱节点 连接 新结点
    pPre->next = pM;

    return 0;
}

int SList_NodeDel(SLIST *pHead, int y)
{
    SLIST  *pCur, *pPre;

    //初始化状态

    pPre = pHead;
    pCur = pHead->next;

    while(pCur != NULL)
    {
        if (pCur->data == y)
        {
            break;
        }
        pPre = pCur;
        pCur = pCur->next;
    }

    //删除操作
    if (pCur == NULL)
    {
        printf("没有找到结点值为:%d 的结点\n", y);
        return -1;
    }
    pPre->next = pCur->next;
    if (pCur != NULL)
    {
        free(pCur);
    }
    return 0;
}

int SList_Destory(SLIST *pHead)
{
    SLIST *tmp = NULL;
    if (pHead == NULL)
    {
        return -1;
    }

    while (pHead != NULL)
    {
        tmp = pHead->next;
        free(pHead);
        pHead = tmp;
    }
    return 0;
}

int SList_Reverse(SLIST *pHead)
{
    SLIST   *p = NULL; //前驱指针
    SLIST   *q = NULL; //当前指针
    SLIST   *t = NULL; //缓存的一个结点

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

    //初始化   //前驱结点
    p = pHead->next;
    q = pHead->next->next;

    //p = pHead;  //代码能兼容
    //q = pHead->next;

    //一个结点 一个结点的逆置
    while(q)
    {
        t = q->next; //缓冲后面的链表

        q->next = p;    //逆置

        p = q; //让p下移一个结点

        q = t;
    }

    //头节点 变成 尾部结点 后  置null
    pHead->next->next = NULL;
    pHead->next = p;  //

    return 0;
}
void main()
{
    int  ret = 0;

    SLIST *pHead = NULL;
    pHead = SList_Create();
    ret = SList_Print(pHead);

    ret = SList_NodeInsert(pHead, 20, 19);
    ret = SList_Print(pHead);

    ret = SList_NodeDel(pHead, 19);
    ret = SList_Print(pHead);

    ret =  SList_Reverse(pHead);
    ret = SList_Print(pHead);

    SList_Destory(pHead);

    printf("hello...\n");
    system("pause");
    return ;
}

链表是单向的，当前节点的位置保存在前驱节点的指针域，所以在插入的时候，要先将新节点的指针域指向当前节点（新节点插入在该节点之前），然后当前节点的前驱结点的指针域指向新节点。需要的辅助变量有三个：
pPre、pCur（指向要比较的节点）、pM（新增节点）
这里写图片描述


//顺序遍历单向动态链表
int  SList_Print(SLIST *pHead)
{
    SLIST *tmp = NULL; 

    if (pHead == NULL)
    {
        return -1;
    }

    tmp = pHead->next;//tmp指向第一个节点（不是头结点）
    printf("\nBegin\n");
    while (tmp)
    {
        printf("%d\n",tmp->data);
        tmp = tmp->next;//tmp永远指向要打印的当前节点
    }
    printf("\nEnd\n");
    return 0;
}

这里写图片描述

/*链表逆置*/
int SList_Reverse(SLIST * pHead)
{
    SLIST * pPre = NULL;//前驱节点
    SLIST * pCur = NULL;//当前节点
    SLIST * pNext = NULL;//后继节点

    /*合法性检测或者只有头节点或者只有一个节点和头结点*/
    if (pHead == NULL || pHead->next == NULL || pHead->next->next == NULL)
    {
        return -1;
    }

    /*初始化的时候将前驱结点指向第一个节点*/
    pPre = pHead->next;
    pCur = pHead->next->next;//当前节点指向第二个节点

    while (pCur)
    {
        pNext = pCur->next;//保存第三个节点的位置或者是NULL（链表尾）

        pCur->next = pPre;//当前节点的指针域指向前驱结点

        /*当前节点和前驱结点一起往后移动一个节点*/
        pPre = pCur;
        pCur = pNext;
    }

    pHead->next->next = NULL;//修正第一个节点的指针域指向NULL变成新的链表尾
    pHead->next = pPre;//修正头结点指向新链表的第一个节点（旧链表的最后一个节点）

    return 0;

}
typedef struct __node{
    int data;//数据域
    struct __node *next;//（指向自己结构体类型的）指针域
}SLIST;

/*创建链表(尾插法插入新节点)*/
SLIST *SList_Create()
{
    SLIST * pHead = NULL;//辅助指针变量之一，表示头结点
    SLIST * pCur = NULL;//让新节点变成当前节点的辅助指针变量
    SLIST * pM = NULL;//用于指向信malloc出的节点的辅助指针变量
    int data = 0;

    /*0.创建头结点*/
    pHead = (SLIST*)malloc(sizeof(SLIST));
    if (pHead == NULL)
    {
        return NULL;
    }
    pHead->data = 0;
    pHead->next = NULL;
    pCur = pHead;//pCur永远指向最后一个节点

    printf("\nplease input your data:");
    scanf("%d",&data);
    /*1.循环malloc出新节点*/
    while (data != 0)
    {
        pM = (SLIST*)malloc(sizeof(SLIST));
        if (pM == NULL)
        {
            return NULL;
        }
        pM->data = data;
        pM->next = NULL;

        /*2.新节点入链表*/
        pCur->next = pM;
        /*3.新节点变成当前节点*/
        pCur = pM;//pCur永远指向最后一个节点

        printf("\nplease input your data:");
        scanf("%d", &data);

    }
    return pHead;
}
/*在x之前插入y*/
int SList_NodeInsert(SLIST * pHead,int x,int y)
{

    SLIST * pPre = NULL;//辅助指针变量之一，表示要插入新节点的前驱结点
    SLIST * pCur = NULL;//表示要插入新节点的后继结点
    SLIST * pM = NULL;//用于指向新节点

    if (pHead == NULL)//合法性判断
    {
        return -1;
    }
    pPre = pHead;//初始化的时候让前驱结点指向头结点
    pCur = pHead->next;//初始化的时候让后继结点指向第一个节点（不是头结点）

    pM = (SLIST*)malloc(sizeof(SLIST));//为新节点开辟空间
    if (pM == NULL)
    {
        return -1;
    }
    /*初始化新节点*/
    pM->data = y;
    pM->next = NULL;

    while (pCur)//pCur指向要插入节点的后继节点，当pCur==NULL的时候表示遍历到链表尾
    {
        if (pCur->data == x){//没有到链表尾的时候判断该节点是否是要寻找的比较节点（这里是后继节点）
            break;
        }

        /*不满足条件时往后挪动辅助指针变量的位置*/
        pPre = pCur;
        pCur = pCur->next;
    }

    /*不管原链表存不存在X节点，都会将新节点插入链表，不存在的时候插入到链表尾，存在的时候插入到X节点前面*/
    pM->next = pCur;
    pPre->next = pM;


    return 0;
}
/*删除链表中数据域为y的节点*/
int SList_NodeDelete(SLIST * pHead, int y)
{   
    SLIST *pPre = NULL;//指向要删除节点的前驱结点
    SLIST *pCur = NULL;//指向要删除的节点或者直到链表尾

    if (pHead == NULL)//合法性检测
    {
        return -1;
    }

    /*初始化的时候前驱结点指向头结点，要删除节点指向第一个非头结点的节点即使是空指针（即链表除了头结点没有任何元素）*/
    pPre = pHead;
    pCur = pHead->next;

    while (pCur)//只要当前节点不是空指针（即没有到链表尾）
    {
        if (pCur->data == y)//满足条件不在移动辅助指针变量的指向
        {
            break;
        }
        /*不满足条件时往后挪动辅助指针变量的位置*/
        pPre = pCur;
        pCur = pCur->next;

    }

    if (pCur == NULL)//寻找到链表尾没有发现要删除的节点
    {
        printf("cant find the node of y\n");
        return -2;
    }

    pPre->next = pCur->next;//删除节点
    if (pCur != NULL)
    {
        free(pCur);//内存回收
        pCur = NULL;//避免野指针
    }


    return 0;
}
/*销毁链表*/
int SList_Destroy(SLIST ** pHead)
{

    SLIST *pCur = NULL;//指向要销毁的当前节点
    SLIST *pTmp = NULL;//用于缓存要销毁的节点的数据，否则一旦销毁以后找不到后继节点,实际上就是指向后一个节点

    if (NULL == pHead)
    {
        return -1;
    }
    if (NULL == *pHead)
    {
        return -1;
    }
    pCur = (SLIST *)(*pHead);//初始化的时候将pCur指向头结点

    while (pCur)
    {
        pTmp = pCur->next;//缓存上一个节点的数据以便找到后继节点
        free(pCur);
        pCur = pTmp;//将pCur指向后继节点
    }
    *pHead = NULL;//避免野指针

    return 0;
}
coolwriter
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C语言链表题目（附答案）.docx
08-07
大一初学C语言时的期末作业，涉及到链表的建立和功能的实现，涉及指针、函数、动态结构建立等方面的知识，初学者可以参考参考尝试尝试哟！！！
C语言数据结构——链表
zcxmjw的博客
12-22 1万+
大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。
C语言—链表
weixin_73588765的博客
01-01 1万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
C语言链表详解（通俗易懂）
weixin_61661271的博客
06-05 5万+
线性表是实际中广泛应用的重要数据结构，本文用通俗易懂的方法讲解它。
C语言链表超详解
热门推荐
k666499436的博客
05-17 9万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
C语言数据结构之链表
qq_53918454的博客
10-19 5103
从某个节点前面插入新节点比从后面插入要多进行一次判断，判断是否为头节点，另一个要注意的地方就是while里的判断条件是用p->next来判断的，这是因为我们可以通过p来找到p的后一个，但是找不到p的前一个，所以这里我们灵活变换一下，代码实现逻辑和从后面插入大同小异。删除一个节点实现逻辑也很好理解，肯定也是要不断遍历，找到对应节点后把原本指向它的结构体指针指向它的下一个，然后按道理我们要把它free掉，上面的代码就是实现尾插法创建链表，这种方式创建出链表中节点的顺序也就是我们正常所认为的顺序，最先的就是头。
C语言链表实现贪吃蛇游戏
08-29
主要介绍了C语言链表实现贪吃蛇游戏源码，适合C语言入门者学习阅读，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
c语言链表的基本操作实现
最新发布
03-28
C语言链表的基本操作主要包括**初始化、创建节点、插入节点、删除节点和查找节点**。具体如下： 1. **初始化**：创建一个空的链表，通常指创建一个头指针，该指针指向NULL，表示链表的开始。 2. **创建节点**：在...
C语言 链表、队列、栈
01-08
链表 通用结点 typedef struct _node{//结点 int value; struct _node *next; }Node; 头结点和尾结点 typedef struct list{//链表 Node* head; Node* tail; }List; 基本链表 存入一连串整数遇到-1结束 #...
数据结构C语言链表的实现
04-18
数据结构C语言链表的实现
C语言之链表详解
Wang_XB_3434的博客
04-10 5378
链表是一种基本的数据结构，它由一系列节点组成，每个节点包含一个值和指向下一个节点的指针。链表的特点是可以动态添加和删除节点，而不需要预先知道数据的数量。与数组不同，链表中的节点不一定是连续的存储空间，因此可以有效地利用内存空间。int val;
【C语言】 链表 超详细解析
m0_56051805的博客
09-29 1万+
【C语言】 链表 超详细解析
C语言中的链表
Innocence网的博客
09-11 3425
链表，一种常见的数据结构。
链表（C语言版）超详细讲解
h220321204的博客
08-15 8839
而如果使用头插法，则需要遍历到链表的第一个节点，时间复杂度为O(n)，而且尾插法是由数据插入的顺序依次存储的，查找起来会更加方便。1、首先我们定义两个指针（x1,p）,x1作为头指针指向头结点（尾插法时不要移动头指针，我们只需移动p即可），p始终指向尾结点（这里我们初始化指向头结点），再申请一块结点并用x指向它。这样我们基础工作完成。
C语言——链表
m0_62386635的博客
11-20 2万+
C语言——链表 链表是一种基础的数据结构类型，一种能够动态维护数据的线性数据表。链表的数据以结点形式存储信息，并通过结点之间的指针实现结点之间的衔接。 为什么要用链表？ 链表和数组类似，但是功能比数组强大得多，数组的空间是固定的，在定义数组的时候，数组的大小已经被固定，在使用时有可能会造成空间的浪费或者面临空间不够的风险，而链表的空间是动态的，则避免了这一问题。 我们来看最基础的单向链表： 1.首先要定义结构体作为链表的结点： typedef struct node { int data; struct
数据结构之链表（C语言）
qq_74260823的博客
05-13 1579
链表是一种、非顺序的存储结构，数据元素的是通过链表中的次序实现的。链表有两个储存区，第一个储存区，第二个储存区储存1.2链表的分类链表可通过以下组合分类为八种。
【C语言】链表入门（配图）
2301_77133706的博客
03-22 1690
本人对于C语言中链表的浅层认识
链表（C语言）
m0_72937472的博客
10-02 1460
本文章介绍了链表的基本结构及链表的增、删、查等功能。（因前后关联性比较强，建议一步步看）
c语言链表
05-31
在C语言中，可以通过定义结构体来实现链表。例如，定义一个包含数据元素和指向下一个节点的指针的链表节点如下： ``` struct ListNode { int val; // 数据元素 struct ListNode *next; // 指向下一个节点的指针 }...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值