线性表的单链表存储结构

最新推荐文章于 2024-05-13 20:53:58 发布
最新推荐文章于 2024-05-13 20:53:58 发布
阅读量863 收藏 4
点赞数 2
分类专栏： 数据结构 C语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47919250/article/details/120098317
版权

数据结构
C语言 同时被 3 个专栏收录
73 篇文章 3 订阅
订阅专栏
c++
21 篇文章 0 订阅
订阅专栏
数据结构
20 篇文章 2 订阅
订阅专栏

线性表的单链表存储结构

 

struct LNode

 {

   ElemType data;

   LNode *next;

 };

 typedef LNode *LinkList;

编程实现线性链表的基本操作(12个)

Status InitList(LinkList &L) 

Status DestroyList(LinkList &L) 

Status ClearList(LinkList L)

Status ListEmpty(LinkList L) 

int ListLength(LinkList L) 

Status GetElem(LinkList L,int i,ElemType &e) 

int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType))

Status PriorElem(LinkList L,ElemType cur_e,ElemType &pre_e)

Status NextElem(LinkList L,ElemType cur_e,ElemType &next_e)

Status ListInsert(LinkList L,int i,ElemType e)

Status ListDelete(LinkList L,int i,ElemType &e) 

Status ListTraverse(LinkList L,void(*vi)(ElemType))

主程序验证内容：

编制数据元素判定函数(相等为TRUE,否则为FALSE) Status comp(ElemType c1,ElemType c2)。

编制ListTraverse()调用的函数(类型要一致) void visit(ElemType  c)，输出c。

// c1.h (程序名)
 #include<string.h>
 #include<ctype.h>
 #include<malloc.h> // malloc()等
 #include<limits.h> // INT_MAX等
 #include<stdio.h> // EOF(=^Z或F6),NULL
 #include<stdlib.h> // atoi()
 #include<io.h> // eof()
 #include<math.h> // floor(),ceil(),abs()
 #include<process.h> // exit()
 //#include<iostream.h> // cout,cin
 // 函数结果状态代码
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 // #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
 typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
 typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

 typedef int ElemType;
//#include"c2-2.h"
/* c2-2.h 线性表的单链表存储结构 */
struct LNode
{
    ElemType data;
    struct LNode *next;
};
typedef struct LNode *LinkList; /* 另一种定义LinkList的方法 */

//#include"bo2-2.c"
/* bo2-2.c 单链表线性表(存储结构由c2-2.h定义)的基本操作(12个) */
Status InitList(LinkList *L)
{
    /* 操作结果：构造一个空的线性表L */
    *L=(LinkList)malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点 */
    if(!*L) /* 存储分配失败 */
        exit(OVERFLOW);
    (*L)->next=NULL; /* 指针域为空 */
    return OK;
}

Status DestroyList(LinkList *L)
{
    /* 初始条件：线性表L已存在。操作结果：销毁线性表L */
    LinkList q;
    while(*L)
    {
        q=(*L)->next;
        free(*L);
        *L=q;
    }
    return OK;
}

Status ClearList(LinkList L) /* 不改变L */
{
    /* 初始条件：线性表L已存在。操作结果：将L重置为空表 */
    LinkList p,q;
    p=L->next; /* p指向第一个结点 */
    while(p) /* 没到表尾 */
    {
        q=p->next;
        free(p);
        p=q;
    }
    L->next=NULL; /* 头结点指针域为空 */
    return OK;
}

Status ListEmpty(LinkList L)
{
    /* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
    if(L->next) /* 非空 */
        return FALSE;
    else
        return TRUE;
}

int ListLength(LinkList L)
{
    /* 初始条件：线性表L已存在。操作结果：返回L中数据元素个数 */
    int i=0;
    LinkList p=L->next; /* p指向第一个结点 */
    while(p) /* 没到表尾 */
    {
        i++;
        p=p->next;
    }
    return i;
}

Status GetElem(LinkList L,int i,ElemType *e) /* 算法2.8 */
{
    /* L为带头结点的单链表的头指针。当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
    int j=1; /* j为计数器 */
    LinkList p=L->next; /* p指向第一个结点 */
    while(p&&j<i) /* 顺指针向后查找,直到p指向第i个元素或p为空 */
    {
        p=p->next;
        j++;
    }
    if(!p||j>i) /* 第i个元素不存在 */
        return ERROR;
    *e=p->data; /* 取第i个元素 */
    return OK;
}

int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{
    /* 初始条件: 线性表L已存在,compare()是数据元素判定函数(满足为1,否则为0) */
    /* 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。 */
    /*           若这样的数据元素不存在,则返回值为0 */
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(compare(p->data,e)) /* 找到这样的数据元素 */
            return i;
        p=p->next;
    }
    return 0;
}

Status PriorElem(LinkList L,ElemType cur_e,ElemType *pre_e)
{
    /* 初始条件: 线性表L已存在 */
    /* 操作结果: 若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱, */
    /*           返回OK;否则操作失败,pre_e无定义,返回INFEASIBLE */
    LinkList q,p=L->next; /* p指向第一个结点 */
    while(p->next) /* p所指结点有后继 */
    {
        q=p->next; /* q为p的后继 */
        if(q->data==cur_e)
        {
            *pre_e=p->data;
            return OK;
        }
        p=q; /* p向后移 */
    }
    return INFEASIBLE;
}

Status NextElem(LinkList L,ElemType cur_e,ElemType *next_e)
{
    /* 初始条件：线性表L已存在 */
    /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
    /*           返回OK;否则操作失败，next_e无定义，返回INFEASIBLE */
    LinkList p=L->next; /* p指向第一个结点 */
    while(p->next) /* p所指结点有后继 */
    {
        if(p->data==cur_e)
        {
            *next_e=p->next->data;
            return OK;
        }
        p=p->next;
    }
    return INFEASIBLE;
}

Status ListInsert(LinkList L,int i,ElemType e) /* 算法2.9。不改变L */
{
    /* 在带头结点的单链线性表L中第i个位置之前插入元素e */
    int j=0;
    LinkList p=L,s;
    while(p&&j<i-1) /* 寻找第i-1个结点 */
    {
        p=p->next;
        j++;
    }
    if(!p||j>i-1) /* i小于1或者大于表长 */
        return ERROR;
    s=(LinkList)malloc(sizeof(struct LNode)); /* 生成新结点 */
    s->data=e; /* 插入L中 */
    s->next=p->next;
    p->next=s;
    return OK;
}

Status ListDelete(LinkList L,int i,ElemType *e) /* 算法2.10。不改变L */
{
    /* 在带头结点的单链线性表L中，删除第i个元素,并由e返回其值 */
    int j=0;
    LinkList p=L,q;
    while(p->next&&j<i-1) /* 寻找第i个结点,并令p指向其前趋 */
    {
        p=p->next;
        j++;
    }
    if(!p->next||j>i-1) /* 删除位置不合理 */
        return ERROR;
    q=p->next; /* 删除并释放结点 */
    p->next=q->next;
    *e=q->data;
    free(q);
    return OK;
}

Status ListTraverse(LinkList L,void(*vi)(ElemType))
/* vi的形参类型为ElemType，与bo2-1.c中相应函数的形参类型ElemType&不同 */
{
    /* 初始条件：线性表L已存在 */
    /* 操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败 */
    LinkList p=L->next;
    while(p)
    {
        vi(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

void CreateList(LinkList *L,int n) /* 算法2.11 */
{
    /* 逆位序(插在表头)输入n个元素的值，建立带表头结构的单链线性表L */
    int i;
    LinkList p;
    *L=(LinkList)malloc(sizeof(struct LNode));
    (*L)->next=NULL; /* 先建立一个带头结点的单链表 */
    printf("请输入%d个数据\n",n);
    for(i=n; i>0; --i)
    {
        p=(LinkList)malloc(sizeof(struct LNode)); /* 生成新结点 */
        scanf("%d",&p->data); /* 输入元素值 */
        p->next=(*L)->next; /* 插入到表头 */
        (*L)->next=p;
    }
}

void CreateList2(LinkList *L,int n)
{
    /* 正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表 */
    int i;
    LinkList p,q;
    *L=(LinkList)malloc(sizeof(struct LNode)); /* 生成头结点 */
    (*L)->next=NULL;
    q=*L;
    printf("请输入%d个数据\n",n);
    for(i=1; i<=n; i++)
    {
        p=(LinkList)malloc(sizeof(struct LNode));
        scanf("%d",&p->data);
        q->next=p;
        q=q->next;
    }
    p->next=NULL;
}

void MergeList(LinkList La,LinkList *Lb,LinkList *Lc)/* 算法2.12 */
{
    /* 已知单链线性表La和Lb的元素按值非递减排列。 */
    /* 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列 */
    LinkList pa=La->next,pb=(*Lb)->next,pc;
    *Lc=pc=La; /* 用La的头结点作为Lc的头结点 */
    while(pa&&pb)
        if(pa->data<=pb->data)
        {
            pc->next=pa;
            pc=pa;
            pa=pa->next;
        }
        else
        {
            pc->next=pb;
            pc=pb;
            pb=pb->next;
        }
    pc->next=pa?pa:pb; /* 插入剩余段 */
    free(*Lb); /* 释放Lb的头结点 */
    Lb=NULL;
}

 // main2-2.cpp 检验bo2-2.cpp的主程序
 /*#include"c1.h"
 typedef int ElemType;
 #include"c2-2.h" // 与main2-1.cpp不同
 #include"bo2-2.cpp" // 与main2-1.cpp不同*/

 Status comp(ElemType c1,ElemType c2)
 { // 数据元素判定函数(相等为TRUE,否则为FALSE)
   if(c1==c2)
     return TRUE;
   else
     return FALSE;
 }

 void visit(ElemType c) // 与main2-1.cpp不同
 {
   printf("%d ",c);
 }

int main() // 除了几个输出语句外，主程和main2-1.cpp很像
 {
   LinkList L; // 与main2-1.cpp不同
   ElemType e,e0;
   Status i;
   int j,k;
   i=InitList(&L);
   for(j=1;j<=5;j++)
     i=ListInsert(L,1,j);
   printf("在L的表头依次插入1～5后：L=");
   ListTraverse(L,visit); // 依次对元素调用visit()，输出元素的值
   i=ListEmpty(L);
   printf("L是否空：i=%d(1:是 0:否)\n",i);
   i=ClearList(L);
   printf("清空L后：L=");
   ListTraverse(L,visit);
   i=ListEmpty(L);
   printf("L是否空：i=%d(1:是 0:否)\n",i);
   for(j=1;j<=10;j++)
     ListInsert(L,j,j);
   printf("在L的表尾依次插入1～10后：L=");
   ListTraverse(L,visit);
   GetElem(L,5,&e);
   printf("第5个元素的值为：%d\n",e);
   for(j=0;j<=1;j++)
   {
     k=LocateElem(L,j,comp);
     if(k)
       printf("第%d个元素的值为%d\n",k,j);
     else
       printf("没有值为%d的元素\n",j);
   }
   for(j=1;j<=2;j++) // 测试头两个数据
   {
     GetElem(L,j,&e0); // 把第j个数据赋给e0
     i=PriorElem(L,e0,&e); // 求e0的前驱
     if(i==INFEASIBLE)
       printf("元素%d无前驱\n",e0);
     else
       printf("元素%d的前驱为：%d\n",e0,e);
   }
   for(j=ListLength(L)-1;j<=ListLength(L);j++)//最后两个数据
   {
     GetElem(L,j,&e0); // 把第j个数据赋给e0
     i=NextElem(L,e0,&e); // 求e0的后继
     if(i==INFEASIBLE)
       printf("元素%d无后继\n",e0);
     else
       printf("元素%d的后继为：%d\n",e0,e);
   }
   k=ListLength(L); // k为表长
   for(j=k+1;j>=k;j--)
   {
     i=ListDelete(L,j,&e); // 删除第j个数据
     if(i==ERROR)
       printf("删除第%d个数据失败\n",j);
     else
       printf("删除的元素为：%d\n",e);
   }
   printf("依次输出L的元素：");
   ListTraverse(L,visit);
   DestroyList(&L);
   printf("销毁L后：L=%u\n",L);
 }

结果截图：

数据结构 线性表-单链表的定义及基本操作
Mi-ronin的博客
03-16 2953
文章目录一.引入二.线性表链式存储结构的定义2.1 顺序结构和链式结构的区别2.2结点定义 一.引入 对于线性表来说，有顺序存储结构，然而顺序结构是有缺点的：插入和删除时需要移动大量元素；因此我们需要解决这一系列问题，线性表的链式存储结构刚好解决了这些问题。 二.线性表链式存储结构的定义 2.1 顺序结构和链式结构的区别 在顺序结构中，每个数据元素只需要存数据元素信息就可以了，在链式结构中，除了要存储元素信息外，还要存储后继元素的存储地址，因此，我们引入了结点。 2.2结点定义 为了表示每个数据元素 a 与
数据结构-----链表基本操作
justforfun
05-30 764
// https://code.csdn.net/snippets/369659.js">>
数据结构——线性表的链式存储结构1（单链表）
m0_61705102的博客
11-20 1467
结点是由存放数据元素的数据域和存放后继结点地址的指针域组成
线性链表（线性表的单链表存储结构）
yezeen的博客
07-31 1314
一、单链表存储结构 //线性表的单链表存储结构 typedef struct LNode { int data; struct LNode* next; }LNODE, *LINKLIST; *代码段中的结构体定义也可以表示为 struct LNode { int data; struct LNode* next; }; typedef struct LNode LNODE; typedef struct LNode* LINKLIST; 二、基本操作&其他操作的函数定义 1.
数据结构C语言版-线性表的单链表存储结构表示和实现.doc
07-13
"数据结构C语言版-线性表的单链表存储结构表示和实现" 本文档介绍了线性表的单链表存储结构表示和实现，使用C语言编写，提供了多种操作函数，包括初始化、销毁、清空、判断空表、获取元素、获取元素位序等。 数据...
数据结构 线性表的单链表存储结构PPT学习教案.pptx
10-03
数据结构 线性表的单链表存储结构PPT学习教案.pptx
数据机构 线性表 单链表 栈 汉诺塔 迷宫求解 等的演示
11-27
线性表是最基础的数据结构之一，它是一个有序的元素集，其中的元素类型相同，且可以是连续存储的数组形式，也可以是链式存储的单链表。数组的优势在于可以通过索引实现快速访问，但是插入和删除操作可能因为元素移动...
2024年大数据最全数据结构 · 线性表 单链表，2024年最新【深度思考
最新发布
2401_84182337的博客
05-13 418
线性表（）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
二、数据结构之线性表的单链表存储结构
蛋蛋
06-03 183
代码的方法的参数和第一个的顺序存储的方法参数大同小异，如有疑问，请参考第一个文章 #include <stdio.h> #include <stdlib.h> #include <time.h> #define OK 1 #define ERROR 0 typedef int ElemType; typedef int Status; //线性表的单链表...
第3章：2.线性表的链式存储结构(单链表)
yanghangwww的博客
11-29 280
本篇文章参考的是《大话数据结构》，感谢作者程杰先生。 一：头指针与头结点的异同： 头指针： *头指针是指链表指向第一个节点的指针，若链表有头结点，则是指向头结点的指针； *头指针具有标识作用，所以常用头指针冠以链表的名字； *无论链表是否为空。头指针是链表的必要元素。 头结点： *头结点是为了操作的统一和方便而设立的，放在第一元素的节点之前，其数据域一般无意义(也可存放链表的长度) *有了头结点，对在第一元素节点前插入节点和删除结点，其操作与其他节点的操作就统一了。 *头结点不一定是链表的必须要素。 二
单链表的存储结构
12-17
此为数据结构的实验，单链表的存储结构，具有可读性，且运行能通过
数据结构——单链表存储结构
热门推荐
Effie_mumu的博客
12-31 1万+
单链表的链式存储结构 链式存储结构顾名思义其存储方式不再是物理地址开辟一块连续空间存储所有结点的方式，而是通过指针将结点连接起来的存储方式。因此，单链表的每一个结点在物理空间可以不相邻，而在逻辑空间上连续存在，是单向存储。
数据结构c版（1）-线性表之单链表代码
11-19
在这个“数据结构C版（1）-线性表之单链表代码”中，我们将深入探讨线性表这一基础数据结构的C语言实现，特别是单链表。 单链表是一种线性数据结构，其中的元素并非在内存中连续存储，而是通过指针连接。每个元素...
1.3.1、单链表（链式存储结构）
融码一生：专注 Python、C/C++、Linux、机器学习 & 深度学习、NLP、算法领域分享
04-13 1105
链表（链式存储结构、单链表）用于存储逻辑关系为“一对一”的数据。与顺序表不同，链表不限制数据的物理存储状态，使用链表存储的数据元素，其物理存储位置是随机的。
【数据结构】线性表的链式存储——单链表
蒙奇D索大的博客
12-26 1653
【数据结构】第二章——线性表(4) 详细介绍了单链表的基本概论与两种形式的单链表的初始化……
线性表链式存储结构——单链表
qq_43243728的博客
09-19 597
线性表链式存储结构 线性表的链式存储结构，与顺序结构中的数组不同的是，不需要开辟连续的内存，链式，主要是内存中一些比较离散的数据通过存储相互之间的地址，来联系到一起。每个数据元素除了存储自己的数据以外，还需要存储后继元素的地址。**注意：这里说的是后继。因为有可能是双向链表。**下图就是一个链表。前面也说过，链式比顺序好的一点是，删除元素，添加元素相对于顺序比较容易。 单链表 单向链表，只...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值