链表－链式存储

最新推荐文章于 2024-08-14 16:59:14 发布
最新推荐文章于 2024-08-14 16:59:14 发布
阅读量688 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 链表 链表链式存储结构 链表实现代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ddreaming/article/details/52289791
版权
链表的线性存储 





//
//  main.c
//  线性表－链式存储
//


#include "stdio.h"
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20

typedef int Status;
typedef int ElemType;


Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

//单链表的存储结构，由数据域和指针域组成
typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;

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

//初始化
Status InitList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(Node));//向系统申请sizeof(Node)大小的内存空间，地址存放到*L中
    if(!(*L))
        return ERROR;
    (*L)->next=NULL;//L是指向LinkList的指针，(*L)就是一个LinkList变量，也就是一个指向Node的指针
    
    return OK;
}


Status ListEmpty(LinkList L)
{
    if(L->next)
        return FALSE;
    else
        return TRUE;
}


Status ClearList(LinkList *L)
{
    LinkList p,q;
    p=(*L)->next;
    while(p)
    {
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next=NULL;
    return OK;
}

//返回链表长度，不包含头节点
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next;//这里L是LinkList变量，指向Node的指针，p是链表中第一个节点
    while(p)
    {
        i++;
        p=p->next;
    }
    return i;
}


Status GetElem(LinkList L,int i,ElemType *e)
{
    int j;
    LinkList p;
    p = L->next;
    j = 1;
    while (p && j<i)
    {
        p = p->next;
        ++j;
    }
    if ( !p || j>i )
        return ERROR;
    *e = p->data;
    return OK;
}

//链表中值为e的节点所在位置
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e)
            return i;
        p=p->next;
    }
    
    return 0;
}


//在链表中第i个节点后面插入值为e的节点
Status ListInsert(LinkList *L,int i,ElemType e)
{
    int j;
    LinkList p,s;//p,s是两个指向Node型数据的指针变量
    p = *L;
    j = 1;
    //找到第i个结点
    while (p && j < i)
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
        return ERROR;   /* 若没有找到第i个节点，报错 */
    s = (LinkList)malloc(sizeof(Node));  /*  生成一个Node节点 */
    s->data = e;
    s->next = p->next;      /* 令新生成节点的next指向第i＋1个节点 */
    p->next = s;          /* 令第i个节点的next指向新生成节点 */
    return OK;
}

/* 删除链表中第i个结点，并返回第i个结点的值*/
Status ListDelete(LinkList *L,int i,ElemType *e)
{
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while (p->next && j < i)	/* 寻找第i-1个结点p */
    {
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i)
        return ERROR;           /* 若不存在第i个结点报错 */
    q = p->next;
    p->next = q->next;			/* 第i-1个结点的next指向第i+1个结点 */
    *e = q->data;               /* 将第i个结点的值赋给e*/
    free(q);                    /* 释放第i个结点的内存 */
    return OK;
}


/* 打印链表中每个节点的数值 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

//生成链表，头插法，即新节点插入在表头
void CreateListHead(LinkList *L, int n)
{
    LinkList p;
    int i;
    srand(time(0));//生成随机数
    *L = (LinkList)malloc(sizeof(Node));//生成一个头节点
    (*L)->next = NULL;
    
    for (i=0; i<n; i++)
    {
        p = (LinkList)malloc(sizeof(Node));//生成一个新节点
        p->data = rand()%100+1;
        
        p->next = (*L)->next;//将新节点插入表头
        (*L)->next = p;
    }
}

//尾插法，新节点插入在表尾
void CreateListTail(LinkList *L, int n)
{
    LinkList p,r;
    int i;
    srand(time(0));                      /* 初始化随机数种子*/
    *L = (LinkList)malloc(sizeof(Node)); /* 创建头节点 */
    r=*L;                                /* r始终指向表尾节点 */
    for (i=0; i<n; i++)
    {
        p = (Node *)malloc(sizeof(Node)); /*  生成新节点 */
        p->data = rand()%100+1;
        r->next=p;                        /* 新生成节点放在表尾 */
        r = p;                            /* 让r指向新的表尾 */
    }
    r->next = NULL;                       /* 表示当前链表结束 */
}

int main()
{
    LinkList L;//L是指向头节点的
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化后链表的长度ListLength(L)=%d\n",ListLength(L));
    for(j=1;j<=5;j++)
        i=ListInsert(&L,1,j);
    printf(" 插入1～5五个数字后L.data=");
    ListTraverse(L);
    
    printf("ListLength(L)=%d \n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否为空i=%d(1:是  0:否)\n",i);
    
    i=ClearList(&L);
    printf("清空后ListLength(L)=%d\n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否为空i=%d(1:是  0:否)\n",i);
    
    for(j=1;j<=10;j++)
        ListInsert(&L,j,j);
    printf("将1～10插入到链表中L.data=");
    ListTraverse(L);
    
    printf("ListLength(L)=%d \n",ListLength(L));
    
    ListInsert(&L,1,0);
    printf("将0插入到链表中第一个节点后L.data=");
    ListTraverse(L);
    printf("ListLength(L)=%d \n",ListLength(L));
    
    GetElem(L,5,&e);
    printf("链表中第五个节点的值为%d\n",e);
    for(j=3;j<=4;j++)
    {
        k=LocateElem(L,j);//链表L中，值为j的节点所在位置，为k
        if(k)
            printf("链表中第%d个元素的值为%d\n",k,j);
        else
            printf("没有值为%d的元素",j);
    }
    
    
    k=ListLength(L); /* 返回链表的长度*/
    for(j=k+1;j>=k;j--)
    {
        i=ListDelete(&L,j,&e);/* 删除第j个元素，并返回第j个元素的值 */
        if(i==ERROR)
            printf("不存在第%d个结点\n",j);
        else
            printf("第%d个结点的值为%d\n",j,e);
    }
    printf("删除该结点后L.data=");
    ListTraverse(L);
    
    j=5;
    ListDelete(&L,j,&e); /* 删除链表中第5个元素，并返回第五个节点的值 */
    printf("删除第%d的数据值为%d\n",j,e);
    
    printf("删除该结点后L.data=");
    ListTraverse(L);
    
    i=ClearList(&L);
    printf("清空链表后ListLength(L)=%d\n",ListLength(L));
    CreateListHead(&L,20);
    printf("头插法生成链表L.data=");
    ListTraverse(L); 
    
    i=ClearList(&L);
    printf("清空链表后ListLength(L)=%d\n",ListLength(L));
    CreateListTail(&L,20);
    printf("尾插法生成链表L.data=");
    ListTraverse(L); 
    
    
    return 0;
}

运行结果： 
初始化后链表的长度ListLength(L)=0
 插入1～5五个数字后L.data=5 4 3 2 1 
ListLength(L)=5 
L是否为空i=0(1:是  0:否)
清空后ListLength(L)=0
L是否为空i=1(1:是  0:否)
将1～10插入到链表中L.data=1 2 3 4 5 6 7 8 9 10 
ListLength(L)=10 
将0插入到链表中第一个节点后L.data=0 1 2 3 4 5 6 7 8 9 10 
ListLength(L)=11 
链表中第五个节点的值为4
链表中第4个元素的值为3
链表中第5个元素的值为4
不存在第12个结点
第11个结点的值为10
删除该结点后L.data=0 1 2 3 4 5 6 7 8 9 
删除第5的数据值为4
删除该结点后L.data=0 1 2 3 5 6 7 8 9 
清空链表后ListLength(L)=0
头插法生成链表L.data=3 82 59 18 62 3 84 91 75 71 92 55 63 51 57 12 18 28 16 78 
清空链表后ListLength(L)=0
尾插法生成链表L.data=78 16 28 18 12 57 51 63 55 92 71 75 91 84 3 62 18 59 82 3 
Program ended with exit code: 0
上述程序中，在函数CreateListTail和CreateListHead中，都用到了函数stand(time(0)),
rand()函数产生的是“伪”随机数，它是由软件做成m序列发生器输出的。这个m序列发生器在初始状态不变的情况也，产生的“序列”是相同的——比如说在某一种状态（如0000...）下，它产生的序列是1 2 3 4 5 2 3 5 1 6......那么，下一次在0000...的初始状态下产生的序列还是1 2 3 4 5 2 3 5 1 6......但是，如果初始状态不同，则产生的序列就不同了。为了使我们得到的“伪”随机数更像“真”随机数，我们希望每次调用rand()函数前的初始状态是变化的。为此，C设计了一个srand()函数，它预置m序列发生器的初始状态，而且用一个随时可变的时间函数的返回值来调用srand()，这样它预置的初始状态就是随时间变化的，这样产生的m序列尽管仍然是“伪”的，但就有了以假乱真的效果。
Ddreaming
关注
专栏目录
C++链表存储和输出
04-23
本程序 使用C++链表完成了 数据的录入和读取 适合新接触C++链表的人使用 我当初才学链表的时候 就看这个看明白的
2. 线性表-链式存储-链表1
08-03
本篇主要讨论的是链式存储，特别是链表这一实现方式。 链表是一种动态数据结构，它的特点是元素（也称为节点）在内存中不是连续存放的，而是通过指针连接起来。这与数组的主要区别在于，数组中的元素在内存中是连续...
链表之链式存储
weixin_34205826的博客
01-26 88
优点： 1 空间存储方便，现用现申请 2 插入删除，只针对单一数据，不需要移动大量数据 缺点： 1 读取，插入，删除慢，需要从头查找，时间复杂度均为O(n)   数据结构声明 typedef struct Node{ int data; struct Node * next; }Node; int main(){ ... Node *p =...
数据结构-链表篇
最新发布
weixin_68007995的博客
08-14 342
什么是链表，链表是一种通过指针串联在一起的数据结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针）链表的入口节点称为链表的头节点，也就是head。// 单链表int val;// 节点上存储的元素// 指向下一个节点的指针ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数。
链式存储（链表）
m0_67349760的博客
04-06 955
有头单向链表 #include<stdio.h> #include<stdlib.h> typedef struct node { int data; struct node* next; }link_node_t; /* 创建空单向链表 */ link_node_t* createEmptynode () { link_node_t* p = malloc(sizeof(link_node_t)); if(p == NULL) { printf("goto ba
链式存储表
Z5433523的博客
08-19 89
申请一个结构的头 存储数据的首地址，以及这个结构的其他参数。链式 物理上不连续 增加 元素逻辑的关系。在第二个位置上，进行插入操作时，如果索引指针指向第二个节点，无法进行后续操作。链式存储维护 表内容的首结点，首结点逐个寻找其他节点。一旦把节点的next赋新值，之前的下一个元素的关系，就断开。单链表中，一旦索引指针往前走一步，之前的元素就再也找不到。删除A元素，站在A元素的前一个元素上，才能删除A元素。链式存储的特点和核心操作逻辑。
【数据结构】链式存储：链表
m0_72161237的博客
01-01 2035
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 而链表分为单向或双向、带头或不带头、循环或非循环，组合起来就有8种链表结构。 接下来我们会学习：单向不带头非循环链表（笔试、面试都是这个结构）和双向不带头非循环链表（集合类底层这样操作）
双链表-循环链表-静态链表.pdf
04-14
双链表、循环链表和静态链表是数据结构中的三种不同类型的链式存储结构。它们各自有其特点和适用场景，下面我们将详细介绍这三种链表及其基本操作。 首先，双链表是一种线性数据结构，它的每个节点包含两个指针，...
数据结构课程-链式存储
04-05
链式存储是一种非顺序的存储方式，与数组不同，它不依赖于物理位置的连续性。在链式存储中，每个元素称为节点，每个节点包含数据和指向下一个节点的指针。这种结构允许动态地插入和删除元素，而不必考虑预先分配的...
栈-队列的顺序-链式储存结构(数据结构试验报告).pdf
09-30
2. 栈的链式存储结构： * 链栈的定义：使用链表来存储栈元素，每个结点包含数据和指向下一结点的指针。 * 链栈的操作：包括入栈、出栈、输出操作。在入栈时需要判断栈是否满了，否则出现空间溢出；在出栈和读取栈顶...
双向链表的链式存储与实现
07-29
本文将深入探讨双向链表的链式存储结构及其实现。 首先，我们要理解链式存储的概念。链式存储不同于数组的连续内存空间存储，它的每个节点由两部分组成：数据域和指针域。数据域用于存放实际的数据，而指针域则存放...
链表（线性表的一种存储结构）
Mafia的博客
03-08 4155
链表一、单链表1.代码定义单链表2.两种实现带头结点不带头结点3.单链表的操作插入按位序插入指定结点的后插操作指定结点的前插操作删除按位序删除指定结点的删除查找 链表分为 单链表 双链表 循环链表 静态链表 一、单链表 顺序表（顺序存储）： 每个节点中只存放数据元素。优点：可随机存取，存储密度高；缺点：要求大片连续空间，改变容量较为麻烦。 单链表（链式存储）： 每个结点除了存放数据元素外，还要存储指向下一个节点的指针。优点：不要求大量连续空间，可以很方便地拓展容量；缺点：不可随机存取，要耗费一定空间存放
Js实现-链表存储
Forest
05-04 369
var LinkList = function (){ var heard = null var length = 0 var node = function(element){ this.element = element this.next = null } // 向链表后面添加元素 this.append =...
链表存储基本操作
za30312的博客
12-01 627
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <windows.h> /*定义表示结点的结构体类型*/ typedef struct list { int data; struct list* next; }LIST; void add(int data); LIST* findBack(
链表之线性表的链式存储（及面试题）
weixin_65477256的博客
07-29 902
​ 在链式存储结构中，每一个数据元素的存储都是以结点形式表示，在结点中包含数据域和指针域两部分内容：​ 数据域：结点的数据部分，存储的是当前结点数据信息；​ 指针域：相邻结点数据存储空间地址，可以包含前驱指针域(前驱结点存储空间地址)和后继指针域(后继结点存储空间地址)；/* 单向链表结点数据类型的定义 */ /* 结点数据类型的定义：由实际存储数据元素的字段信息抽象实现 */ # if 0 typedef struct stu {int id;int score;} data_t;
数据结构—链表-链式存储
魂小猫的博客
04-30 656
头节点里面不放任何东西 头指针指向头节点 有些链表没有头节点 头指针直接指向首节点 头节点是为了方便插入和删除运算的实现 单链表的存储结构其实就是描述每一个节点是如何构成的 首先他数据域和数据类型是什么，实际应用中数据域是一个复合数据类型 在单链表这样一个数据结构里面，我们首先要定义每一个节点是如何构成的 数据域 指针域（指向下一个节点） 一个节点通过指针指向另外一个节点，数据结构中
单向链表（链式存储）
binger-csdn的博客
04-23 377
1、定义链表节点以及表头数据结构 typedef struct ListNode{ struct ListNode* next; }ListNode_t; typedef struct LinkList{ ListNode_t header; //头结点 int length; //链表长度 }LinkList_t; 2、链表的初始化 LinkList_t *...
循环链表（链式存储）
binger-csdn的博客
05-06 937
1、定义链表节点以及表头数据结构 typedef struct CircleLinkNode{ void* data; struct CircleLinkNode* next; }CircleLinkNode; typedef struct CircleLinkList{ CircleLinkNode* head; //头结点 CircleLinkNode*...
1.3.1、单链表（链式存储结构）
融码一生：专注 Python、C/C++、Linux、机器学习 & 深度学习、NLP、算法领域分享
04-13 923
链表（链式存储结构、单链表）用于存储逻辑关系为“一对一”的数据。与顺序表不同，链表不限制数据的物理存储状态，使用链表存储的数据元素，其物理存储位置是随机的。
数据结构--链式存储结构
10-19
数据结构中的链式存储结构是一种非连续、非顺序的存储结构，它通过指针将一组零散的存储单元串联起来，形成一个链表。链表中的每个节点包含两个部分，一个是数据域，用于存储数据元素，另一个是指针域，用于指向下一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值