数据结构导论 四 线性表的顺序存储VS链式存储

前几章已经介绍到了顺序存储、链式存储

顺序存储:初始化、插入、删除、定位

链式存储:初始化、插入、删除、定位

顺序存储:初始化

strudt student{
int ID;//ID
char name[30];//姓名
char sex; //性别
int class;//班级
int age;//年龄

}
student={"01",“zhangsan”,"m","201","20"};

  

链式存储:初始化

//建立一个空链表
LinkList InitiateLinkList(){
LinkList head;  //头指针
head =malloc (sizeof(node)); //动态构建一节点,它是头结点
head->next=null;
return head;

顺序存储:插入

void InsertSeqlist(SeqList ,DataType x,int i){
//将元素x插入到顺序表中L的第i个数据元素之前
if(L.length==Maxsize)
exit("表已满");
if(i<1||i>L.ength+1)
exit("位置错误");
for(j=L.length;j>=i;j--) //初始化
L.data[j]=L.data[j-1];//依次后移
L.data[j-1]=x;//元素x到下标为i-1的位置
L.length++;//表长度加1

}

链式存储:插入

void InsertLinklist (LinkList head, DataType x, int i)
//在表head的第i个数据元素结点之前插入一个以x为值的新结点
{
Node *p,*q;
if (i==1) q=head;
else q=GetLinklist (head, i-1); //找第 i-1个数据元素结点
if (q==NULL) //第i-1个结点不存在
exit(“找不到插入的位置”);
else
{
p=malloc(sizeof (Node) );p->data=x; //生成新结点
p->next=q->next; //新结点链域指向*q的后继结点
q->next=p; //修改*q的链域
}
}

顺序存储的插入i是先将插入后面的往后移动插入i-1个位置,空出插入的地方在进行插入

链式存储:插入结点d,先将d的尾结点连接到b的首结点,接着d的首结点连接a的尾结点,放弃a到b之间的连接

顺序存储:删除

1 void DeleteSeqList(SeqList L,int i) {
2 //删除线性表L中的第i个数据结点
3 if(i<1 || i>L.length) //检查位置是否合法
4 exit(“非法位置”);
5 for(j=i;j<L.length;j ++) //第i个元素的下标为i-1
6 L.data[j-1]=L.data[j]; //依次左移
7 L.length--; //表长度减1
8 }

链式存储:删除

void DeleteLinklist(LinkList head, int i)
//删除表head的第i个结点
{
Node *q;
if(i==1) q=head;
else q=GetLinklist(head, i-1); //先找待删结点的直接前驱
if(q !== NULL && q->next != NULL) //若直接前驱存在且待删结点存在
{
p=q->next; //p指向待删结点
q->next=p->next; //移出待删结点
free(p); //释放已移出结点p的空间
}
else exit (“找不到要删除的结点”); //结点不存在
}

数据存储:定位

int LocateSeqlist(SeqList L, DataType x)
{
int i=0;
while ((i<L. length) && (L.data[i]!=x) ) //在顺序表中查找值为 x 的结点
i++;
if(i<L.length) return i+1; //若找到值为x的元素,返回元素的序号
else return 0; //未查找到值为x的元素,返回0
}
//顺序表的求表长操作,直接输出L.length即可

链式存储:定位

int LocateLinklist (LinkList head ,Data Type x){
//求表head中第一个值等于x的结点的序号,若不存在这种结点,返回结果为0
Node *p=head;//p是工作指针
p=p->next;//初始时P指向首结点
int i=0;//i代表 结点的序号,这里初值为
while(p!=null&&p->data!=x){//访问链表
i++;
p=p->next;
}
if(p!=null)
return i+1;
else return 0;}

原文地址:https://www.cnblogs.com/X404/p/12061462.html

时间: 2024-10-10 14:47:26

数据结构导论 四 线性表的顺序存储VS链式存储的相关文章

数据结构学习笔记(二) 线性表的顺序存储和链式存储

线性表:由同类型数据元素构成有序序列的线性结构 -->表中元素的个数称为线性表的长度 -->没有元素时,成为空表 -->表起始位置称表头,表结束位置称表尾 顺序存储: 1 package test; 2 3 /** 4 * 线性表(数组) 5 * 6 */ 7 public class Test { 8 private static int m ; 9 private static int[] a; 10 public static void main(String[] args) {

线性表的顺序存储和链式存储

顺序存储是分配了一块连续的内存,把这块内存平均分为N份,每份存放一个线性表的单元.从内存利用角度讲,顺序存储需要的是一块连续的内存.特点是查找节点容易,插入. 删除节点比较耗时. 链式存储是分配了几个零散的非连续单元,从内存利用角度讲,它能充分利用那些碎片化的内存.特点是查找节点慢,但插入删除节点快. 怎么理解呢? 下文说的酒店均没有客户记录,就是没有登记某个人住在某个房间. 顺序存储就和某个酒店的一层房间,比如在第一层有100个房间,从1号房间按顺序一致排到底100号房间.你去找一个人,打开1

线性表的Java实现--链式存储(单向链表)

线性表的Java实现--链式存储(单向链表) 单向链表(单链表)是链表的一种,其特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始. 链式存储结构的线性表将采用一组任意的存储单元存放线性表中的数据元素.由于不需要按顺序存储,链表在插入.删除数据元素时比顺序存储要快,但是在查找一个节点时则要比顺序存储要慢. 使用链式存储可以克服顺序线性表需要预先知道数据大小的缺点,链表结构可以充分利用内存空间,实现灵活的内存动态管理.但是链式存储失去了数组随机存取的特点,同时增加了节点的指针域,空

2、线性表的实现:链式存储、单链表

1 package ren.laughing.datastructure.baseImpl; 2 3 import ren.laughing.datastructure.base.List; 4 import ren.laughing.datastructure.base.Strategy; 5 import ren.laughing.datastructure.exception.OutOfBoundaryException; 6 /** 7 * 线性表的实现:链式存储结构:单链表 8 * @

c数据结构 -- 线性表之 复杂的链式存储结构

复杂的链式存储结构 循环链表 定义:是一种头尾相接的链表(即表中最后一个结点的指针域指向头结点,整个链表形成一个环) 优点:从表中任一节点出发均可找到表中其他结点 注意:涉及遍历操作时,终止条件是判断 p->next == L? 双向链表 定义:在单链表的每个结点离再增加一个指向直接前驱的指针域 prior,这样链表中就形成了有 两个方向不用的链,故称为双向链表 双向循环链表 定义: 和单链的循环表类似,双向链表也可以有循环表 ·让头节点的前驱指针指向链表的最后一个结点 ·让最后一个结点的后继指

线性表的Java实现--链式存储(双向链表)

有了单向链表的基础,双向链表的实现就容易多了. 双向链表的一般情况: 增加节点: 删除节点: 双向链表的Java实现: package com.liuhao.algorithm;      public class DuLinkList<T> {          /**       * 内部类:链表中的一个节点       *        * @author liuhao data 节点中的数据 prev 指向前一个节点的引用 next 指向下一个节点的引用       */       

队列的定义与操作——顺序存储和链式存储

队列的 存储结构 有 顺序存储 和 链式存储. 1. 队列的顺序存储与操作 (循环队列) 1 typedef int Position; 2 struct QNode { 3 ElementType *Data; // 存储元素的数组 4 Position Front, Rear; // 队列的 头.尾指针 5 int Cap; // 队列最大大容量 6 }; 7 typedef struct QNode *Queue; 8 9 // 操作集 10 Queue CreateQueue(int M

C 数据结构1——线性表分析(顺序存储、链式存储)

之前是由于学校工作室招新,跟着大伙工作室招新训练营学习数据结构,那个时候,纯碎是小白(至少比现在白很多)那个时候,学习数据结构,真的是一脸茫然,虽然写出来了,但真的不知道在干嘛.调试过程中,各种bug也不懂怎么修改,那个时候,电脑一直被我弄蓝屏,这个寒假,重新学习一遍数据结构,获益良多,整理一下,发布出来,求拍砖,共同进步. 线性表(List),0个或者多个数据元素的有限序列 线性表的顺序存储,即线性表通过数组的方式实现,指用一段地址连续的存储单元一次存储线性表的数据元素.如图: A1 A2 -

Java实现线性表-顺序表示和链式表示

顺序表示和链式表示的比较: 1.读写方式:顺序表可以顺序存取,也可以随机存取:链表只能从表头顺序存取元素: 2.逻辑结构与物理结构:顺序存储时,逻辑上相邻的元素其对应的物理存储位置也相邻:链式存储时,逻辑上相邻的元素,其物理存储位置则不一定相邻: 3.查找.插入和删除操作: 按值查找,当线性表在无序的情况下,两者的时间复杂度均为o(n):而当顺序表有序时,可采用折半查找,此时时间复杂度为o(log n): 按位查找,顺序表支持随机访问,时间复杂度为o(1):而链表的平均时间复杂度为o(n). 顺