线性表的顺序存储结构和链式存储结构分别是,线性表的顺序存储结构

　　线性表的顺序存储结构和链式存储结构分别是,线性表的顺序存储结构

　　存储顺序的定义：线性表的顺序存储结构是指用一段地址连续的存储单元顺序存储线性表的数据元素。

　　一维数组在C语言中的实现是一种顺序存储结构。

　　/**

　　ADT(列表)

　　数据

　　线性表的数据对象集是{a1，a2，an}，每个元素的类型都是DataType。除了第一个元素A1，每个元素只有一个直接的前置元素。

　　同样，除了最后一个元素an，每个元素都只有一个直接后继元素，数据元素之间是一一对应的关系。

　　操作

　　InitList(* L)；//初始化创建空线性表的操作。

　　list empty(L)；//线性表为空则返回true，否则返回false。

　　clear list(* L)；//清空线性表。

　　GetElem(L，I，* e)；//将线性表L中第I个元素的值返回给e .

　　LocateElem(L，e)；//在线性表L中查找与给定值E相等的元素，如果查找成功，返回该元素在表中的序号；否则，返回0，表示失败。

　　ListInsert(*L，I，e)；//在线性表l中第I个位置插入新元素E .

　　ListDelete(*L，I，* e)；//删除线性表L中第I个位置的元素，用元素e返回其值.

　　列表长度(L)；//返回线性表元素的个数。

　　endADT

　　* */下面是顺序存储的线性表的结构代码：

　　/*模式1 */

　　#定义MAXSIZE 10 //初始分配数量

　　typedef int Elemtype//这里很灵活。通常，您可以使用原子类型的数据，如char、int和float。

　　typedef结构

　　{

　　elem type r[MAXSIZE]；//最大存储容量：数据长度(data length)，宏定义后一般不变，以非指针形式描述。

　　int长度；//当前长度=MAXSIZE，线性表长度可变，由于添加或删除。

　　} Sqlist//这个很好理解，但是实际写代码的时候会遇到L.r=a(表达式必须是可修改的左值)

　　//报告错误是因为r[MAXSIZE]中R的数组名不是指针，不能修改。它是在。bss段。

　　/*方法2，更灵活，使用指针*/

　　#定义MAXSIZE 10

　　typedef int ELemtype

　　typedef结构

　　{

　　elem type * r；

　　int长度；

　　int大小；//可以，我们可以优化结构，把r[MAXSIZE]拆分成指针和一个int原子数据类型。初始化会非常方便。

　　}//这是我的数据结构书里的

　　//当然，如果考虑引入类似SqlistInit()的函数，使用循环结构也可以达到同样的目的，但是会比较麻烦。

　　/*

　　*区分数据长度和线性表长度，数据长度一般是常数，线性表长度受实际元素个数的限制。

　　*顺序存储的时间复杂度为O(1)，因为地址LOC(AI)=LOC(A0)Sizeof(elem type)* I。

　　*具有LOC等特征的结构称为随机存储结构(如数组)

　　*/顺序存储结构错误演示：L- data在结构中没有指针声明(第一种方式声明)，会显示左值不能修改的提示。这里的声明方法和上面的方式一样，所以这个时候不能更改地址，可以做修改数据内容等其他事情。

　　注意：线性表的长度不同于数组的长度。

　　获取元素3.5.1线性表获取元素

　　#定义确定1

　　#定义错误0

　　typedef int状态；//显示函数的状态

　　Status GetElem(SqList *L，int i，ElemType *e)

　　{

　　/*检查I的值*/

　　if (i 0 i L- length L- length！=0) //确保Sqlist不为空

　　* e=L-data[I]；

　　退货OK；

　　其他

　　printf(找不到值)；

　　返回错误；

　　}插入元素3.5.2关于插入算法的注释：

　　如果插入位置不合适，抛出异常(异常处理)L- length L- size，就需要动态扩展容量或者抛出异常。反向遍历后，移动一个元素，插入到第I个位置L- length=1#define OK 1。

　　#定义错误0

　　typedef int状态；//显示函数的状态

　　状态插入元素(Sqlist *L，int i，Elemtype e)

　　{

　　if (i L- length i 1) //确保索引正常

　　返回错误；

　　else if (L- length=L- size)//充分调整空间

　　返回错误；

　　其他

　　{

　　for(int j=L-length；j I；j - )//移动元素

　　左数据[j]=左数据[j-1]

　　l-data[I]=e；//j的范围以for循环的结尾结束

　　}

　　}链接列表

　　链接列表节点typedef结构节点

　　{

　　元素类型数据；

　　结构节点* next//下一个节点的地址

　　}节点；

　　typedef结构节点*链表；//Linklist是从线性表和节点类型链表中获取GetElem()的指针。

　　//获取线性表对应位置的元素

　　#包含“stdio.h”

　　#定义确定1

　　#定义错误0

　　#定义正确1

　　#定义假0

　　typedef int状态；//Status返回函数的状态码，表示函数的执行情况。

　　/*

　　*int GetElem( Sqlist * L，Elemtype e)，返回位置。

　　*获取元素的前提是线性表已经存在。传统上，因为返回位置不为0，即0表示该元素不在线性表中。

　　*要求1=i=L- length(即I有意义)，运算结果：返回元素在相应位置的值。

　　*/

　　#define MAXSIZE 10 //指定数组的容量，即数据长度。

　　typedef int Elemtype

　　typedef结构

　　{

　　elem type * r；

　　int长度；//解释线性表的长度

　　int大小；

　　} Sqlist

　　int main()；

　　Status GetElem(Sqlist *L，int i，elem type * e)；//回到这里，做优化处理。原来的int变成了状态码和返回值。

　　int main()

　　{

　　SQL list L；

　　int loc

　　int a[MAXSIZE]={1，2，3，4，5，7，6，8，9，10 }；

　　l . r=a；//r这里是指针，可以修改。

　　L.length=MAXSIZE

　　Elemtype ch

　　GetElem( L，7，ch)；

　　Printf(第七个元素是：%d ，ch)；

　　返回0；

　　}

　　Status GetElem(Sqlist *L，int i，Elemtype* e)

　　{

　　If(i 1i L- length)//比较实际线性表长度。

　　返回错误；

　　其他

　　{

　　* e=L-r[I-1]；

　　退货OK；

　　}

　　}//读取单链表：GetElem()

　　/*单链表的定位一开始比较复杂，有点类似于在一棵树上遍历。

　　*操作目的：获取单链表第I个元素的数据字段的值。

　　* L- next是a1，以此类推，一定要注意循环条件。

　　*涉及二级指针。

　　*/

　　#includestdio.h //No文件包含未定义标识符“NULL”的错误

　　#包含“malloc.h”

　　#定义MAXSIZE 10

　　#定义确定0

　　#定义错误1

　　typedef int状态；

　　typedef int Elemtype

　　typedef结构节点

　　{

　　elem type r；

　　结构节点* next

　　}节点；

　　typedef节点*链表；//级别1指针

　　int main()；

　　Status LinkListInit(Node** L，int * a)；

　　void GetElem(链表L，int i，int * e)；

　　int main()

　　{ elem type e；

　　链表L；

　　int a[MAXSIZE]={1，2，3，4，5，6，7，8，9，0 }；

　　LinkListInit( L，a)；//指针更新，这个写法不能改变L的值，可以知道L是指针，我们的目的是修改指针。

　　GetElem(L，6，e)；

　　printf(%d ，e)；

　　}

　　状态列表init (node * * l，int * a)//二级指针闻起来不错

　　{

　　node * p；//此处使用LinkList的消息必须使用指向该结构的类型。

　　p=(节点*)malloc(sizeof(节点))；//头节点应用

　　* L=p；//记录执行头指针的P，赋给L；

　　如果(！p)

　　返回错误；//头节点应用失败

　　for(int I=0；I=9；我)

　　{

　　p- next=(节点*)malloc(sizeof(节点))；

　　p-r=a[I]；

　　p=p-next；

　　}

　　p-next=NULL；

　　返回0；

　　}

　　void GetElem(链表L，int i，int *e)

　　{ Node * p；

　　p=L；

　　int j=1；

　　while(p j=i-1)

　　{

　　p=p-next；

　　j；

　　}

　　* e=p-r；

　　}链表插入到节点InsertElem()

　　/**

　　ADT(列表)

　　数据

　　线性表的数据对象集是{a1，a2，an}，每个元素的类型都是DataType。除了第一个元素A1，每个元素只有一个直接的前置元素。

　　同样，除了最后一个元素an，每个元素都只有一个直接后继元素，数据元素之间是一一对应的关系。

　　操作

　　InitList(* L)；//初始化创建空线性表的操作。

　　list empty(L)；//线性表为空则返回true，否则返回false。

　　clear list(* L)；//清空线性表。

　　GetElem(L，I，* e)；//将线性表L中第I个元素的值返回给e .

　　LocateElem(L，e)；//在线性表L中查找与给定值E相等的元素，如果查找成功，返回该元素在表中的序号；否则，返回0，表示失败。

　　ListInsert(*L，I，e)；//在线性表l中第I个位置插入新元素E .

　　ListDelete(*L，I，* e)；//删除线性表L中第I个位置的元素，用元素e返回其值.

　　列表长度(L)；//返回线性表元素的个数。

　　endADT

　　**/

　　/* Target:将线性表Lb中而不是线性表La中的所有数据元素插入La */#includestdio.h //No文件包含未定义标识符 NULL 的错误

　　#包含" malloc.h "

　　#定义最大尺寸10

　　#定义确定0

　　#定义错误一

　　整型状态；

　　数据类型

　　数据类型说明结构节点

　　{

　　elem型；

　　结构节点*下一个

　　}节点；

　　数据类型说明节点*链表；//一级指针

　　int main()；

　　Status LinkListInit(Node** L，int * a)；

　　状态元素插入（链表* L，int i，元素类型e)；

　　void elem print(节点* * L)；

　　int main()

　　e型元素；

　　链表l；

　　int a[MAXSIZE]={1，2，3，4，5，6，7，8，9，0 }；

　　LinkListInit( L，a)；//指针更新，可以知道L为指针，我们的目的是可以修改一级指针

　　ElemInsert( L，2，11)；

　　elem打印(左)；

　　}

　　状态链接表Init(Node** L，int *a)//二级指针真香

　　{

　　node * p；//这里使用链接列表的话必须使用指向结构的类型

　　p=(节点*)malloc(sizeof(节点));//头结点申请

　　* L=p；//记录执行头指针的p，赋值给l；

　　如果(!p)

　　返回错误；//头结点申请失败

　　for(int I=0；I=9；我)

　　{

　　p- next=(节点*)malloc(sizeof(节点));

　　p-next-r=a[I]；

　　p=p-next；

　　}

　　p-next=NULL；

　　返回0;

　　}

　　//如果有头节点

　　状态元素插入（节点**L，int i，元素类型e){

　　node * p=* L；

　　int j=1；

　　当(p . j . I)

　　{

　　p=p-next；//j的节点

　　j；//j

　　}

　　如果(!p j i)

　　返回错误；

　　Node * new=(Node *)malloc(sizeof(Node))；

　　new-r=e；

　　new-next=p-next；//j 1=i

　　p-next=new；

　　退货OK；

　　}

　　void ElemPrint(节点** L)

　　{

　　node * p=* L；

　　while(p- next)

　　{

　　printf(%d ，p-next-r)；

　　p=p-next；

　　}

　　}问答：

　　执行正在…之前，申请的链表之间顺次链接，从外界传入我是2，p一开始是头结点，L是头指针

　　当j=2时，插入节点会被放到第二个节点后面

　　p- r在末节点处非法读出，报段错误

　　头结点的数据域被写入的，引发异常

　　删除节点状态节点删除（链表*L，int i，Elemtype *e)

　　{

　　node * p=* L；

　　int j=1；

　　while(p- next j i) //aj

　　{

　　p=p-next；

　　j；

　　}

　　如果(!(p- next)j i)

　　返回错误；

　　node * q=p-next；//q是我的节点

　　p-next=q-next；

　　* e=q-r；

　　免费(q)；

　　退货OK；

　　}

　　单链表的创建状态链接表Init(Node** L，int *a)//二级指针真香

　　{

　　node * p；//这里使用链接列表的话必须使用指向结构的类型

　　p=(节点*)malloc(sizeof(节点));//头结点申请

　　* L=p；//记录执行头指针的p，赋值给l；

　　如果(!p)

　　返回错误；//头结点申请失败

　　for(int I=0；I=9；我)

　　{

　　p- next=(节点*)malloc(sizeof(节点));

　　p-next-r=a[I]；

　　p=p-next；

　　}

　　p-next=NULL；//尾指针域置空

　　返回0;

　　}静态链表用数组描述的链表叫做静态链表，也称为游标实现法。

　　#包含" stdio.h "

　　#包含" malloc.h "

　　#定义最大尺寸1000

　　#定义确定0

　　#定义错误一

　　整型状态；

　　数据类型

　　数据类型说明结构

　　{

　　元素类型数据；

　　内部电流

　　}节点，静态链表[MAXSIZE]；//StaticLinkList是光电带读数机(photoelectric tape reader)

　　int main()；

　　status InitStaticLinkList(静态链表L)；

　　状态元素插入（链表* L，int i，元素类型e)；

　　void elem print(节点* * L)；

　　状态InitStaticLinkList(静态链接表L)

　　{

　　int I；

　　for(I=0；I MAXSIZE-1；我)

　　L[i].cur=I 1；

　　L[MAXSIZE-1].cur=0；//喜欢链表中的头节点

　　退货OK；

　　}静态链表的插入与删除#包含" stdio.h "

　　#定义最大尺寸1000

　　#定义确定0

　　#定义错误一

　　整型状态；

　　数据类型

　　数据类型说明结构

　　{

　　元素类型数据；

　　内部电流

　　}组件，静态链表[MAXSIZE]；//StaticLinkList是指针点tp组件[MAXSIZE]

　　//typedef静态链接表SLL；

　　数据类型说明组件* SSL

　　int main()；

　　int Malloc _ SSL(静态链表L)；

　　void Free_SSL(StaticLinkList L，int k)；

　　int列表长度(静态链表L)；

　　status InitStaticLinkList(静态链表L)；

　　状态元素插入(静态链表L，int i，元素类型e)；

　　status elem delete(静态链表L，int I)；

　　void elem print(静态链表L)；

　　int Malloc_SSL(StaticLinkList L)

　　{

　　int next=L[0].cur//当前空值

　　if(L[0].cur)

　　L[0].cur=L[下一个]。cur//下一个空值

　　下一个返回；

　　}

　　void Free_SSL(StaticLinkList L，int k)

　　{

　　L[k].cur=L[0].坏蛋

　　L[0].cur=k；//像malloc免费中的容器

　　}

　　int ListLength(StaticLinkList L)

　　{ int I=0；

　　//最后一个元素坏蛋为空

　　int cursor=L[MAXSIZE-1].坏蛋

　　而(光标)

　　{

　　光标=L[光标]。坏蛋

　　我；

　　}

　　返回我；

　　}

　　状态InitStaticLinkList(静态链接表L)

　　{

　　int I；

　　for(I=0；I MAXSIZE-1；我)

　　L[i].cur=I 1；

　　L[MAXSIZE-1].cur=0；//喜欢链表中的头节点

　　退货OK；

　　}

　　状态元素插入（静态链接表l，int i，元素类型e)

　　{

　　int j，k，l；

　　k=MAXSIZE-1；

　　if(i 0 i ListLength(L) 1)

　　返回错误；

　　j=Malloc _ SSL(L)；

　　如果(j)

　　{

　　//遍历列表，直到我的索引

　　L[j].数据=e；

　　for(l=1；l=I-1；l)

　　k=L[k].cur//更新k

　　L[j].cur=L[k].cur//等于L[i-1].坏蛋

　　L[k].cur=j；

　　退货OK；

　　}

　　}

　　状态元素删除(静态链表L，int i)

　　{

　　int j，k，l；

　　k=MAXSIZE-1；

　　if(i 0 i ListLength(L) 1)

　　返回错误；

　　//遍历列表，直到我的索引

　　for(l=1；l=I-1；l)

　　k=L[k].cur//更新k

　　j=L[k].坏蛋

　　L[k].cur=L[j].cur//等于L[i-1].坏蛋

　　Free_SSL(L，I)；//以防光标移动

　　退货OK；

　　}

　　void ElemPrint(StaticLinkList L)

　　{

　　int cursor=L[MAXSIZE-1].坏蛋

　　而(光标)

　　{

　　printf(%d ，L[cursor].数据);

　　光标=L[光标]。坏蛋

　　}

　　}

　　int main()

　　{

　　int List[6]={1，2，3，4，5，6 }；

　　StaticLinkList InitSSL

　　SSL L=InitSSL

　　InitStaticLinkList(L)；

　　for(int I=0；i6；我)

　　ElemInsert(L，I，List[I])；

　　elem打印(左)；

　　返回0;

　　}广发银行调试的时候发现一个局部变量在Malloc_SSL函数中出错，导致没有输出。