C语言数据结构——单链表

最新推荐文章于 2024-03-09 17:23:07 发布
最新推荐文章于 2024-03-09 17:23:07 发布
阅读量1.5k 收藏 28
点赞数 12
分类专栏： 数据结构 文章标签： c语言 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cckevincyh/article/details/78171896
版权

链表存储结构定义

不同于顺序的线性表，链表的存储单元不连续，数据元素可以存在内存任何未被占用的任意位置。因此除了要存储数据元素的信息之外，还要存储它的后继元素的存储地址，因此每个元素Ai与其后继的元素Ai+1是通过一个存储地址来关联的。
对于元素Ai来说，除了本身的数据，还有一个指向Ai+1的数据域，通过这个数据域才能够索引到Ai+1元素，我们把存储数据的域叫做数据域，存储地址部分的域叫做指针域。指针域中存放的信息叫做指针或者链。
这两部分信息组成的叫做结点。n个结点组成一个链表，我们把链表的第一个结点或头结点的存储位置叫做头指针（指向第一个结点的存储位置；如果有头结点，则是指向头结点的存储位置）。为了更方便链表的操作，会在单链表的第一个结点前设置一个节点，称为头结点。头结点的数据域不存储任何信息，头结点的指针域存储指向第一个结点点指针，如图：
这里写图片描述

头指针与头结点

头指针：

  • 头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针
  • 头指针具有标识作用，所以常用头指针冠以链表的名字
  • 无论链表是否为空，头指针均不为空。头指针是链表的必要的元素

头结点：

  • 头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义(也可以存放链表的长度)
  • 有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其他结点的操作就统一了
  • 头结点不一定是链表必须要素

单链表的存储结构

不带头结点的结构：
这里写图片描述

带头结点的结构：
这里写图片描述

空链表：
这里写图片描述

单链表的存储结构

单链表中，我们可以用结构指针来描述。

typedef int ElemType;   //假定ElemType的类型为int

typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node;  //定义Node

typedef struct Node * LinkList; //定义LinkList，指向Node的指针

结点由存放数据元素的数据域和存放后继结点地址的指针域组成，假设p是指向线性表第i个元素的指针，则该结点ai的数据域我们可以用p->data表示，p->data的值是个数据元素，结点ai的指针域可以用p->next表示，p->next的值是个指针，p->next指向第i+1各元素，即指向ai+1的指针。也就是，如果p->data=ai,那么p->next->data=ai+1

这里写图片描述

单链表整表的创建(头插法）

单链表整表创建的算法思路：

  1. 声明一结点p和计数器变量i
  2. 初始化一空链表L
  3. 让L的头结点的指针指向NULL，即建立一个带头结点的单链表
  4. 循环
    a.生成一新结点赋值给p
    b.随机生成一数字赋值给p的数据域p->data
    c.将p插入到头结点与前一新结点之间

头插法：
每次都把新的结点都放在最前面。
这里写图片描述


#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef int ElemType;   //假定ElemType的类型为int

typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node;  //定义Node

typedef struct Node * LinkList; //定义LinkList，指向Node的指针


//随机产生n个元素的值，建立带头结点的单链表L(头插法)
void CreateListHead(LinkList * L,int n)
{
    LinkList p; //声明了一个指向Node的指针p
    srand(time(0)); //初始化随机数种子
    (*L) = (LinkList)malloc(sizeof(Node));  //为头结点分配内存空间,创建一个头结点，(*L)相当于头结点
    (*L)->next = NULL;  //建立一个空的头结点
    for(int i=0;i<n;i++)
    {
        p = (LinkList) malloc(sizeof(Node));//生成新结点
        p->data = rand()%10 + 1;    //随机生成10以内的数字
        p->next = (*L)->next;
        (*L)->next = p; //插入到表头
    }
}

//打印单链表
void PrintLinkList(LinkList L)
{
    LinkList P;
    P = L->next;
    while(P)
    {
        printf("%d ",P->data);
        P = P->next;
    }
    printf("\n");
}




int main()
{
    LinkList L;
    CreateListHead(&L,5);//随机创建5个元素的单链表
    PrintLinkList(L);   //打印单链表
    return 0;
}

运行结果：
这里写图片描述

单链表整表的创建(尾插法）

尾插法：
每次都把新结点都插在终端结点的后面。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ERROR 0
#define OK 1
typedef int ElemType;   //假定ElemType的类型为int

typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node;  //定义Node

typedef struct Node * LinkList; //定义LinkList，指向Node的指针


//随机产生n个元素的值，建立带头结点的单链表(尾插法)
void CreateListTail(LinkList * L,int n)
{
    LinkList p,r;
    srand(time(0));//初始化随机数种子
    (*L) = (LinkList)malloc(sizeof(Node));  //创建头结点
    r = (*L);   //r为指向尾部的结点
    for(int i=0;i<n;i++)
    {
        p = (LinkList)malloc(sizeof(Node));//生成新结点
        p->data = rand()%10 + 1;    //随机生成10以内的数字
        r->next = p;    //将尾部结点的指针指向新结点
        r = p;  //将r重新指向为尾部新的终端结点
    }
    r->next = NULL; //表明当前链表结束

}

//打印单链表
void PrintLinkList(LinkList L)
{
    LinkList P;
    P = L->next;
    while(P)
    {
        printf("%d ",P->data);
        P = P->next;
    }
    printf("\n");
}




int main()
{
    LinkList L;
    CreateListTail(&L,5);
    PrintLinkList(L);   //打印单链表
    return 0;
}

运行结果：
这里写图片描述

单链表的读取

单链表读取第i个数据的算法：
1. 声明一个结点p指向链表的第一个节点，初始化j从1开始
2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1
3. 若链表末尾p为空，则说明第i个元素不存在
4. 否则查找成功，返回结点p的数据

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ERROR 0
#define OK 1
typedef int ElemType;   //假定ElemType的类型为int

typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node;  //定义Node

typedef struct Node * LinkList; //定义LinkList，指向Node的指针


//随机产生n个元素的值，建立带头结点的单链表L(头插法)
void CreateListHead(LinkList * L,int n)
{
    LinkList p; //声明了一个指向Node的指针p
    srand(time(0)); //初始化随机数种子
    (*L) = (LinkList)malloc(sizeof(Node));  //为头结点分配内存空间,创建一个头结点，(*L)相当于头结点
    (*L)->next = NULL;  //建立一个空的头结点
    for(int i=0;i<n;i++)
    {
        p = (LinkList) malloc(sizeof(Node));//生成新结点
        p->data = rand()%10 + 1;    //随机生成10以内的数字
        p->next = (*L)->next;
        (*L)->next = p; //插入到表头
    }
}


void CreateListTail(LinkList * L,int n)
{
    LinkList p,r;
    srand(time(0));//初始化随机数种子
    (*L) = (LinkList)malloc(sizeof(Node));  //创建头结点
    r = (*L);   //r为指向尾部的结点
    for(int i=0;i<n;i++)
    {
        p = (LinkList)malloc(sizeof(Node));//生成新结点
        p->data = rand()%10 + 1;    //随机生成10以内的数字
        r->next = p;    //将尾部结点的指针指向新结点
        r = p;  //将r重新指向为尾部新的终端结点
    }
    r->next = NULL; //表明当前链表结束

}

//打印单链表
void PrintLinkList(LinkList L)
{
    LinkList P;
    P = L->next;
    while(P)
    {
        printf("%d ",P->data);
        P = P->next;
    }
    printf("\n");
}


int GetElem(LinkList L,int i,ElemType * e)
{
    int j;
    LinkList p;
    p = L->next;    //p指向第一个节点
    j = 1;  //计数器
    while(p && j < i)   //p不为空或者计数器j还没有等于1，循环继续
    {
        p = p->next;    //p指向下一个结点
        ++j;
    }
    if(!p || j>i)
    {
        return ERROR;//第i个元素不存在
    }
    *e = p->data;   //取出第i个元素的数据
    return OK;
}




int main()
{
    LinkList L;
//  CreateListHead(&L,5);//随机创建5个元素的单链表
    CreateListTail(&L,5);
    PrintLinkList(L);   //打印单链表
    ElemType e;
    GetElem(L,5,&e);
    printf("%d\n",e);
    return 0;
}

运行结果：
这里写图片描述

单链表的插入

单链表的插入：
这里写图片描述
单链表第i个数据插入结点的算法思路：

  1. 声明一结点p指向链表第一个结点，初始化j从1开始
  2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1
  3. 若到链表末尾p为空，则说明第i个元素不存在
  4. 否则查找成功，在系统中生成一个空结点s
  5. 将数据元素e赋值给s->data
  6. 单链表的插入标准语句s->next = p->next;p->next = s;
  7. 返回成功

实现代码算法如下：

//单链表的插入
int InsertList(LinkList * L,int i,ElemType e)
{
    int j;
    LinkList p,s;
    p = (*L);   //p指向头结点
    j = 1;  //计数器
    while(p && j < i)   //寻找第i个结点
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i)
    {
        return ERROR;   //第i个元素不存在
    }

    s = (LinkList)malloc(sizeof(Node)); //生成新结点
    s->data = e;
    s->next = p->next;  //将p的后继结点赋值给s的后继
    p->next = s;    //将s赋值给p的后继
    return OK;

}

运行主程序

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ERROR 0
#define OK 1
typedef int ElemType;   //假定ElemType的类型为int

typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node;  //定义Node

typedef struct Node * LinkList; //定义LinkList，指向Node的指针


//随机产生n个元素的值，建立带头结点的单链表L(头插法)
void CreateListHead(LinkList * L,int n)
{
    LinkList p; //声明了一个指向Node的指针p
    srand(time(0)); //初始化随机数种子
    (*L) = (LinkList)malloc(sizeof(Node));  //为头结点分配内存空间,创建一个头结点，(*L)相当于头结点
    (*L)->next = NULL;  //建立一个空的头结点
    for(int i=0;i<n;i++)
    {
        p = (LinkList) malloc(sizeof(Node));//生成新结点
        p->data = rand()%10 + 1;    //随机生成10以内的数字
        p->next = (*L)->next;
        (*L)->next = p; //插入到表头
    }
}


void CreateListTail(LinkList * L,int n)
{
    LinkList p,r;
    srand(time(0));//初始化随机数种子
    (*L) = (LinkList)malloc(sizeof(Node));  //创建头结点
    r = (*L);   //r为指向尾部的结点
    for(int i=0;i<n;i++)
    {
        p = (LinkList)malloc(sizeof(Node));//生成新结点
        p->data = rand()%10 + 1;    //随机生成10以内的数字
        r->next = p;    //将尾部结点的指针指向新结点
        r = p;  //将r重新指向为尾部新的终端结点
    }
    r->next = NULL; //表明当前链表结束

}

//打印单链表
void PrintLinkList(LinkList L)
{
    LinkList P;
    P = L->next;
    while(P)
    {
        printf("%d ",P->data);
        P = P->next;
    }
    printf("\n");
}


int GetElem(LinkList L,int i,ElemType * e)
{
    int j;
    LinkList p;
    p = L->next;    //p指向第一个节点
    j = 1;  //计数器
    while(p && j < i)   //p不为空或者计数器j还没有等于1，循环继续
    {
        p = p->next;    //p指向下一个结点
        ++j;
    }
    if(!p || j>i)
    {
        return ERROR;//第i个元素不存在
    }
    *e = p->data;   //取出第i个元素的数据
    return OK;
}


//单链表的插入
int InsertList(LinkList * L,int i,ElemType e)
{
    int j;
    LinkList p,s;
    p = (*L);   //p指向头结点
    j = 1;  //计数器
    while(p && j < i)   //寻找第i个结点
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i)
    {
        return ERROR;   //第i个元素不存在
    }

    s = (LinkList)malloc(sizeof(Node)); //生成新结点
    s->data = e;
    s->next = p->next;  //将p的后继结点赋值给s的后继
    p->next = s;    //将s赋值给p的后继
    return OK;

}




int main()
{
    LinkList L;
//  CreateListHead(&L,5);//随机创建5个元素的单链表
    CreateListTail(&L,5);
    PrintLinkList(L);   //打印单链表
    InsertList(&L,3,7); //第三个位置插入元素7
    PrintLinkList(L);   //打印单链表
    return 0;
}

运行结果：
这里写图片描述

单链表的删除

这里写图片描述

单链表第i个数据删除结点的算法思路：

  1. 声明一结点p指向链表第一个结点，初始化j从1开始
  2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加
  3. 若到链表末尾p为空，则说明第i个元素不存在
  4. 否则查找成功，将欲删除的结点p->next赋值给q
  5. 单链表的删除标准语句p->next = q->next
  6. 将q结点中的数据赋值给e，作为返回
  7. 释放q结点
  8. 返回成功

实现代码算法如下：

//删除单链表元素
int DeleteLinkList(LinkList * L,int i,ElemType * e)
{
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while(p && j<i) //遍历寻找第i个元素
    {
        p = p->next;
        ++j;
    }
    if(!p || j > i)
    {
        return ERROR;   //第i个元素不存在
    }
    q = p->next;
    p->next = q->next;  //将q的后继赋值给p的后继
    *e = q->data;
    free(q);//让系统回收此结点，释放内存
    return OK;
}

运行主程序：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ERROR 0
#define OK 1
typedef int ElemType;   //假定ElemType的类型为int

typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node;  //定义Node

typedef struct Node * LinkList; //定义LinkList，指向Node的指针


//随机产生n个元素的值，建立带头结点的单链表L(头插法)
void CreateListHead(LinkList * L,int n)
{
    LinkList p; //声明了一个指向Node的指针p
    srand(time(0)); //初始化随机数种子
    (*L) = (LinkList)malloc(sizeof(Node));  //为头结点分配内存空间,创建一个头结点，(*L)相当于头结点
    (*L)->next = NULL;  //建立一个空的头结点
    for(int i=0;i<n;i++)
    {
        p = (LinkList) malloc(sizeof(Node));//生成新结点
        p->data = rand()%10 + 1;    //随机生成10以内的数字
        p->next = (*L)->next;
        (*L)->next = p; //插入到表头
    }
}


void CreateListTail(LinkList * L,int n)
{
    LinkList p,r;
    srand(time(0));//初始化随机数种子
    (*L) = (LinkList)malloc(sizeof(Node));  //创建头结点
    r = (*L);   //r为指向尾部的结点
    for(int i=0;i<n;i++)
    {
        p = (LinkList)malloc(sizeof(Node));//生成新结点
        p->data = rand()%10 + 1;    //随机生成10以内的数字
        r->next = p;    //将尾部结点的指针指向新结点
        r = p;  //将r重新指向为尾部新的终端结点
    }
    r->next = NULL; //表明当前链表结束

}

//打印单链表
void PrintLinkList(LinkList L)
{
    LinkList P;
    P = L->next;
    while(P)
    {
        printf("%d ",P->data);
        P = P->next;
    }
    printf("\n");
}


int GetElem(LinkList L,int i,ElemType * e)
{
    int j;
    LinkList p;
    p = L->next;    //p指向第一个节点
    j = 1;  //计数器
    while(p && j < i)   //p不为空或者计数器j还没有等于1，循环继续
    {
        p = p->next;    //p指向下一个结点
        ++j;
    }
    if(!p || j>i)
    {
        return ERROR;//第i个元素不存在
    }
    *e = p->data;   //取出第i个元素的数据
    return OK;
}


//单链表的插入
int InsertList(LinkList * L,int i,ElemType e)
{
    int j;
    LinkList p,s;
    p = (*L);   //p指向头结点
    j = 1;  //计数器
    while(p && j < i)   //寻找第i个结点
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i)
    {
        return ERROR;   //第i个元素不存在
    }

    s = (LinkList)malloc(sizeof(Node)); //生成新结点
    s->data = e;
    s->next = p->next;  //将p的后继结点赋值给s的后继
    p->next = s;    //将s赋值给p的后继
    return OK;

}

//删除单链表元素
int DeleteLinkList(LinkList * L,int i,ElemType * e)
{
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while(p && j<i) //遍历寻找第i个元素
    {
        p = p->next;
        ++j;
    }
    if(!p || j > i)
    {
        return ERROR;   //第i个元素不存在
    }
    q = p->next;
    p->next = q->next;  //将q的后继赋值给p的后继
    *e = q->data;
    free(q);//让系统回收此结点，释放内存
    return OK;
}




int main()
{
    LinkList L;
//  CreateListHead(&L,5);//随机创建5个元素的单链表
    CreateListTail(&L,5);
    PrintLinkList(L);   //打印单链表
    ElemType e;
    //GetElem(L,5,&e);
    //printf("%d\n",e);
    InsertList(&L,3,7); //第三个位置插入元素7
    PrintLinkList(L);   //打印单链表
    DeleteLinkList(&L,3,&e);//删除第三个位置的元素
    PrintLinkList(L);   //打印单链表
    printf("%d\n",e);
    return 0;
}

运行结果：
这里写图片描述

单链表的整表删除

单链表整表删除的算法思路：

  1. 声明一结点p和q
  2. 将第一个结点赋值给q
  3. 循环
    a.将下一结点赋值给q
    b.释放p
    c.将q赋值给p

实现代码算法如下：

int ClearList(LinkList * L)
{
    LinkList p,q;
    p = (*L)->next; //p指向第一个结点
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;  //头结点指针域为空
    return OK;
}

运行主程序：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ERROR 0
#define OK 1
typedef int ElemType;   //假定ElemType的类型为int

typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node;  //定义Node

typedef struct Node * LinkList; //定义LinkList，指向Node的指针


//随机产生n个元素的值，建立带头结点的单链表L(头插法)
void CreateListHead(LinkList * L,int n)
{
    LinkList p; //声明了一个指向Node的指针p
    srand(time(0)); //初始化随机数种子
    (*L) = (LinkList)malloc(sizeof(Node));  //为头结点分配内存空间,创建一个头结点，(*L)相当于头结点
    (*L)->next = NULL;  //建立一个空的头结点
    for(int i=0;i<n;i++)
    {
        p = (LinkList) malloc(sizeof(Node));//生成新结点
        p->data = rand()%10 + 1;    //随机生成10以内的数字
        p->next = (*L)->next;
        (*L)->next = p; //插入到表头
    }
}


void CreateListTail(LinkList * L,int n)
{
    LinkList p,r;
    srand(time(0));//初始化随机数种子
    (*L) = (LinkList)malloc(sizeof(Node));  //创建头结点
    r = (*L);   //r为指向尾部的结点
    for(int i=0;i<n;i++)
    {
        p = (LinkList)malloc(sizeof(Node));//生成新结点
        p->data = rand()%10 + 1;    //随机生成10以内的数字
        r->next = p;    //将尾部结点的指针指向新结点
        r = p;  //将r重新指向为尾部新的终端结点
    }
    r->next = NULL; //表明当前链表结束

}

//打印单链表
void PrintLinkList(LinkList L)
{
    LinkList P;
    P = L->next;
    while(P)
    {
        printf("%d ",P->data);
        P = P->next;
    }
    printf("\n");
}


int GetElem(LinkList L,int i,ElemType * e)
{
    int j;
    LinkList p;
    p = L->next;    //p指向第一个节点
    j = 1;  //计数器
    while(p && j < i)   //p不为空或者计数器j还没有等于1，循环继续
    {
        p = p->next;    //p指向下一个结点
        ++j;
    }
    if(!p || j>i)
    {
        return ERROR;//第i个元素不存在
    }
    *e = p->data;   //取出第i个元素的数据
    return OK;
}


//单链表的插入
int InsertList(LinkList * L,int i,ElemType e)
{
    int j;
    LinkList p,s;
    p = (*L);   //p指向头结点
    j = 1;  //计数器
    while(p && j < i)   //寻找第i个结点
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i)
    {
        return ERROR;   //第i个元素不存在
    }

    s = (LinkList)malloc(sizeof(Node)); //生成新结点
    s->data = e;
    s->next = p->next;  //将p的后继结点赋值给s的后继
    p->next = s;    //将s赋值给p的后继
    return OK;

}

//删除单链表元素
int DeleteLinkList(LinkList * L,int i,ElemType * e)
{
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while(p && j<i) //遍历寻找第i个元素
    {
        p = p->next;
        ++j;
    }
    if(!p || j > i)
    {
        return ERROR;   //第i个元素不存在
    }
    q = p->next;
    p->next = q->next;  //将q的后继赋值给p的后继
    *e = q->data;
    free(q);//让系统回收此结点，释放内存
    return OK;
}

int ClearList(LinkList * L)
{
    LinkList p,q;
    p = (*L)->next; //p指向第一个结点
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;  //头结点指针域为空
    return OK;
}



int main()
{
    LinkList L;
//  CreateListHead(&L,5);//随机创建5个元素的单链表
    CreateListTail(&L,5);
    PrintLinkList(L);   //打印单链表
//  ElemType e;
    //GetElem(L,5,&e);
    //printf("%d\n",e);
//  InsertList(&L,3,7); //第三个位置插入元素7
//  PrintLinkList(L);   //打印单链表
//  DeleteLinkList(&L,3,&e);//删除第三个位置的元素
    ClearList(&L);//删除整个链表
    PrintLinkList(L);   //打印单链表
    //printf("%d\n",e);
    return 0;
}

运行结果：
这里写图片描述

c.
关注
  • 12
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构单链表（C语言）
03-27
通过c语言实现单链表的建立、初始化、尾插法插入结点、头插法插入结点、数据的查找、删除、在指定位置插入结点、在指定位置删除结点、打印输出数据、统计单链表的长度等功能。
C语言2种方式实现简单单链表的创建
02-02
C语言：数组创建单链表；键盘输入数值创建单链表。 int main() { pNode tmp=(pNode)malloc(sizeof(struct Node) ); tmp=creatList(); tmp=inputCreatList(); return 0; }
学习c语言： 单链表
最新发布
bskmns的博客
03-09 752
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表的结构跟⽕⻋⻋厢相似，淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。只需要将⽕⻋⾥的某节⻋厢去掉/加上，不会影响其他⻋厢，每节⻋厢都是独⽴存在的。⻋厢是独⽴存在的，且每节⻋厢都有⻋⻔。想象⼀下这样的场景，假设每节⻋厢的⻋⻔都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从⻋头⾛到⻋尾？最简单的做法：每节⻋厢⾥都放⼀把下⼀节⻋厢的钥匙。
用C语言创建一个单链表的方法
10-18
创建一个C语言单链表的方法如下： 定义链表节点结构体： typedef struct Node { int data; // 数据域 struct Node* next; // 指针域，指向下一个节点 } Node; 定义链表的插入函数，用于在链表末尾插入节点： void insert(Node** head, int data) { Node* newNode = (Node*)malloc(sizeof(Node)); // 创建新节点 newNode->data = data; // 设置新节点的数据值 newNode->next = NULL; // 将新节点的指针域置为NULL if (*head == NULL) { // 链表为空，将新节点设为头节点 *head = newNode; } else { // 链表不为空，遍历到链表末尾 Node* curr = *head; while (curr->next != NULL) {
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
数据结构C语言版之单链表的逆置.cpp
10-07
数据结构老师布置的作业，运用课本代码，较为基础经典，适合大学本科在上数据结构这门课的同学参考，简单易懂，关于单链表的逆置问题
【数据结构】单链表
m0_46612488的博客
11-19 486
线性表：同一种类型的有顺序的一组数据元素 线性表的形式：顺序表、链表 顺序表：表中元素按顺序放在一大块连续的内存中，元素中的顺序由存储顺序来表示 链表：表中元素放在一系列的结点中，通过连接构造。结点可以连续也可以不连续。 结点分为「数据域」和「指针域」。 数据域：保存着作为表元素的数据项； 指针域：保存同一个表里的下一个结点的标识。 头结点和头指针的区分 头结点 的设立是为了操作的统一和方便，是放在第一个元素的节点之前，它的数据域一般没有意义，并且它本身也不是链表必须要带的。那设立头节点的目的是什么呢？其
C++链表基础使用——创建链表、删除第n个节点、删除前n个节点、插入节点、更改某个节点的值
weixin_42477773的博客
04-10 3205
后附创建链表的两种方法的示意图。 #include<iostream> typedef struct Node{ int value; Node *next; }node,*linklist; const int numoflink = 10;//创建有10个节点的链表 const int delete_n = 9;//删除第9个节点 const int delete_f...
2012年7月4日 题：创建一个 10节点 内容随机但不重复的 链表
txin123的小屋
07-04 1376
# include # include # include 　 struct node { int num; struct node *next; }; void creat(struct node *head,int n) { struct node *p,*q; struct node *scanf; randomize();
c语言线性表建立10个节点,数据结构（C语言版）求一个创建线性表、插入运算的程序和算法...
weixin_33900596的博客
05-21 449
//Windows7环境 VS2017编译#define _CRT_SECURE_NO_WARNINGS#include#includetypedef struct NAME//自定义名字{int data;struct NAME *next;} name;name *creat(int n)//创建长度为n的单链表{name *head, *node, *end;he...
c语言创建一个长度为10的链表,C语言链表基本操作（10页）-原创力文档
weixin_32000561的博客
05-24 835
// 链表操作 :建立、插入、删除、查找、倒置、删除等基本操作// 喜洋洋制作#include #include typedefstruct LNode{int data;struct LNode *next;}LNode,*Llist;LNode *creat_head(); // 创建一个空表void creat_list(LNode *, ...
C语言创建和操作单链表数据结构的实例教程
12-31
1，为什么要用到链表 数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个大小的数组，有时需要5 0个数组的大小，难于统一。我们只能够根据可能的最大需求来定义数组，常常会造成一定存储空间的浪费。 我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链表就是我们需要的动态数组。它是在程序的执行过程中根据需要有数据存储就向系统要求申请存储空间，决不构成对存储区的浪费。 链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种
C语言单链表创建打印
05-28
C语言单链表创建与打印的演示程序。VISUAL C++6.0环境编译成功。
单链表（数据结构C语言版）
07-05
单链表（数据结构C语言版） 链表的创建，插入，删除，排序等操作并建立有菜单，可以选择操作
C语言数据结构实现链表去重的实例
01-20
C语言数据结构实现链表去重的实例 题目及分析 链表去重 时间限制 300 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 给定一个带整数键值的单链表L，本题要求你编写程序，删除那些键值的绝对值有重复的结点。即对任意键值K，只有键值或其绝对值等于K的第一个结点可以被保留。同时，所有被删除的结点必须被保存在另外一个链表中。例如：另L为21→-15→-15→-7→15，则你必须输出去重后的链表21→-15→-7、以及被删除的链表-15→15。 输入格式： 输入第一行包含链表第一个结点的地址、以及结点个数N（<= 105 的正整数）。结点地址是一个非负的
数据结构——单链表.zip
09-16
完全实现严蔚敏数据结构教材中的单链表，可测试。包含初始化，插入，删除，连接等操作
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
数据结构——单链表的具体操作
12-22
该程序包括单链表结构类型以及对单链表 操作的具体的函数定义。 2. 程序中的单链表（带头结点）结点为结构类型，结点值为整型。 3. 本程序完成单链表的生成，任意位置的插入、删除，以及确定某一元 素在单链表中的...
c语言单链表的初始化创建增删等
09-16
C语言单链表是一种常用的数据结构，可以用来存储和操作数据。下面我来详细介绍一下单链表的初始化、创建、增删等操作。 1. 初始化链表：首先，我们需要定义一个链表节点的结构体，包含一个数据域和一个指向下一个节点的指针。然后，通过给指针赋初值NULL，使链表为空。 2. 创建链表：创建链表需要先定义一个头指针，初始化为空。然后，通过不断申请新的节点并将数据存入节点的数据域，再将新节点连接在链表的尾部。直到输入结束标志，即可创建完整的单链表。 3. 链表的插入操作：可以在链表的任意位置插入一个新节点。需要先让新节点的指针指向被插入位置的下一个节点，然后让被插入位置的节点指针指向新节点。 4. 链表的删除操作：可以删除链表中的任意节点。需要先找到待删除节点的前一个节点，然后将前一个节点的指针指向待删除节点的下一个节点，最后释放待删除节点的内存空间。 总结：单链表的初始化是通过给指针赋初值NULL来表示链表为空。链表的创建是通过不断申请新节点并将新节点连接在链表尾部来创建完整的链表。链表的插入操作是将新节点插入到链表的任意位置。链表的删除操作是通过重新连接节点的指针，并释放待删除节点的内存空间来删除节点。 以上是对C语言单链表初始化、创建、增删等操作的简要介绍，希望对你有帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值