线性存储&链式存储（5.14）

最新推荐文章于 2024-07-09 17:26:44 发布
原创 最新推荐文章于 2024-07-09 17:26:44 发布 · 769 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了数据结构中的两种基本存储方式——顺序存储和链式存储。顺序存储通过数组实现，适合线性关系的数据，操作包括增删改查排序。链式存储则利用节点记录下一个节点地址，支持更灵活的操作，如创建、插入和输出链表数据。文中还提出了链表有序插入和逆置的作业挑战。

顺序存储：

一  数据结构

 

(1)数据存储  (顺序存储，链式存储,索引存储，哈希存储)

(2)数据间关系(逻辑关系:线性，非线性)

(3)数据操作  (增 删 改 查 排序)

 

 

二 线性关系-----顺序表 = 存放数据的空间[数组]  + 当前数据的个数

 

1.数据结构 

typedef int DATATYPE;

typedef struct 
{
	DATATYPE buf[MAX];//存放数据 
	int n;//记录当前数据的个数
}SeqList;

2.操作 

SeqList *create_seqlist()
{
	SeqList *L;

	//分配内存
	L = (SeqList *)malloc(sizeof(SeqList));
	L->n = 0;

	return L;
}

int insert_seqlist(SeqList *L,DATATYPE data)
{
	//判断顺序表是否满
	//如果满，则输出"The SeqList is full!",然会返回-1

	
	//插入数据
	L->buf[L->n] = data;

	L->n ++;

	return 0;
}

int printf_seqlist(SeqList *L)
{
	...
}

int sort_seqlist(SeqList *L)
{
	for(i = 0;i < L->n - 1;i ++)
	{
		for(j = 0;j < L->n - i - 1;j ++)
		{
			...
		}
	}

}

int find_seqlist(SeqList *L,DATATYPE data)
{
	for(i = 0;i < L->n;i ++)
	{
		if(L->buf[i] == data)
			break;
	}

	return (i + 1);
}

int insert_post_seqlist(SeqList *L,int post,DATATYPE data)
{
	1.判断是否满 和 合法位置 [1,L->n],如果是非法位置，需要输出位置非法
	2.指定位置插入的思想
	  [1]最后一个元素的下标 L->n - 1
	  [2]从后向前移动
	  for(i = L->n - 1;? ;i --)
	  {
		  L->buf[i + 1] = L->buf[i];
	  }
	 [3]插入 
	 L->buf[?] = data;
	 [4]更新n的值
	
	return 0;
}

int delete_data_seqlist(SeqList *L,DATATYPE data)
{
	...
	//提示:删除字符的选择题思路
}

int main()
{
	SeqList *L;

	L = create_seqlist();
	//插入10个数据到顺序表

	//输出顺序表
}

代码如下： 

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

#define MAX 10

typedef int DATATYPE;

typedef struct 
{
	DATATYPE data[MAX];
	int n;
}SeqList;

SeqList *create_seqlist()
{
	SeqList *L;

	L = (SeqList *)malloc(sizeof(SeqList));
	if(L == NULL){
		printf("NO free memory!\n");
		return NULL;
	}

	L->n = 0;

	return L;
}

int insert_seqlist(SeqList *L,DATATYPE data)
{
	if(L->n == MAX)
	{
		printf("The SeqList is full!\n");
		return -1;
	}

	L->data[L->n] = data;
	L->n ++;

	return 0;
}

int printf_seqlist(SeqList *L)
{
	int i = 0;

	for(i = 0;i < L->n ;i ++)
	{
		printf("%d ",L->data[i]);
	}
	printf("\n");

	return 0;
}

int insert_postion_seqlist(SeqList *L,int post,DATATYPE data)
{
	int last;

	//判断位置合法性[1,L->n]
	if(!(post >= 1 && post <= L->n))
	{
		printf("The invaild postion : %d,must [1,%d]\n",post,L->n);
		return -1;
	}

	//判断是否满
	if(L->n == MAX)
	{
		printf("The SeqList is full\n");
		return -1;
	}
	
	//从后向前移动数据
	for(last = L->n - 1;last >= post - 1;last --)
	{
		L->data[last + 1] = L->data[last];
	}

	//插入数据
	L->data[post - 1] = data;
	
	//更新n的值
	L->n ++;

	return 0;
}

int delete_assign_data(SeqList *L,DATATYPE data)
{
	int i,j;

	//判断是否空 
	if(L->n == 0)
	{
		printf("The SeqList is empty!\n");
		return -1;
	}

	//删除数据代碼
	for(i = 0,j = 0;i < L->n;i ++)
	{
		if(L->data[i] != data)
		{
			L->data[j++] = L->data[i];
			//j ++;
		}
	}
	
	//判断要删除的元素是否存在
	if(i == j){
		printf("The delete data:%d is not exist!\n",data);
		return -1;
	}

	//更新剩余数据的个数
	L->n = j;

	return 0;
}

int sort_seqlist(SeqList *L)
{
	int i,j;
	DATATYPE temp;

	for(i = 0;i < L->n - 1;i ++)//需要排的次数
	{
		for(j = 0;j < L->n - 1  - i;j ++)//比较方法:前一个元素与后一个元素比较，每排序一次则少一个元素
		{
			if(L->data[j] > L->data[j+1])
			{
				temp = L->data[j];
				L->data[j] = L->data[j+1];
				L->data[j+1] = temp;
			}
		}
	}

	return 0;
}

int delete_repeat_data(SeqList *L)
{
	int k;
	int i,j;

	for(i = 0;i < L->n ;i ++)
	{
		for(j = i + 1,k = i + 1;j < L->n;j ++)
		{
			if(L->data[j] != L->data[i])
			{
				L->data[k] = L->data[j];
				k ++;
			}
		}

		L->n = k;
	}


	return 0;
}

int main(int argc, const char *argv[])
{
	int i = 0;
	int a[] = {10,20,10,40,40,90,40,80,20};
	SeqList *L;
	
	L = create_seqlist();
	if(L == NULL)
		return -1;
	
	for(i = 0;i < sizeof(a)/sizeof(a[0]);i ++)
	{
		insert_seqlist(L,a[i]);
	}
	
	printf_seqlist(L);

	insert_postion_seqlist(L,3,100);
	insert_postion_seqlist(L,5,100);
	printf_seqlist(L);
	
	delete_assign_data(L,100);
	
	printf_seqlist(L);

	delete_assign_data(L,101);
	
	sort_seqlist(L);

	printf_seqlist(L);
	
	delete_repeat_data(L);

	printf_seqlist(L);

	return 0;
}


链式存储：

一 链式存储

 

[1]头节点记录第一个有效数据节点的首地址，本身不存放数据 

[1]每个节点会记录下一个节点的地址

[2]尾节点是最后一个节点，它记录的地址为0(NULL)

 

1.节点的类型设计

typedef struct node
{
	DATATYPE data;//存放数据
	struct node *next;//记录下一个节点的地址
}LinkNode;

2.操作

[1]创建空链表

LinkNode *create_empty_linklist()
{
	LinkNode *head;

	head = (LinkNode *)malloc(sizeof(LinkNode));
	head->next = NULL;

	return head;
}

[2]插入新节点

   <1>头插法(每次都是在头节点后面插入数据)

int insert_head_linklist(LinkNode *head,DATATYPE data)
{
		分配一个节点
		将data存放在新节点

		新节点保存头的后一个节点地址
		头节点保存新节点地址
}

   <2>尾插法(每次都是在尾部节点后面插入数据)

int insert_tail_linklist(LinkNode *head,DATATYPE data)

[3]输出链表中的数据

int printf_linklist(LinkNode *head)

作业:

(1)实现一个链表的有序插入

int a[] = {10,3,4,15,6};
LinkNode *L = create_empty_linklist();

for(i  = 0;i < sizeof(a)/sizeof(a[0]);i ++)
{
	insert_order_linklist(L,a[i]);
}

printf_linklist(L);//3,4,6,10,15

(2)实现一个链表的逆置


代码如下：

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

typedef int DATATYPE;

typedef struct node
{
	DATATYPE data;
	struct node *next;
}LinkNode;

LinkNode *create_linklist()
{
	LinkNode *head;

	head = (LinkNode *)malloc(sizeof(LinkNode));
	if(head == NULL){
		printf("No free memory!\n");
		return NULL;
	}
	head->next = NULL;
	
	return head;
}

int insert_head_linklist(LinkNode *head,DATATYPE data)
{
	LinkNode *temp;

	temp = (LinkNode *)malloc(sizeof(LinkNode));
	temp->data = data;

	//用新节点记录头的后一个节点
	temp->next = head->next;
	//用头节点记录新节点
	head->next = temp;
	
	return 0;
}

int insert_tail_linklist(LinkNode *head,DATATYPE data)
{
	LinkNode *temp;
	LinkNode *p = head;

	//找到尾部节点
	while(p->next != NULL)
	{
		p = p->next;
	}

	temp = (LinkNode *)malloc(sizeof(LinkNode));
	temp->data = data;
	temp->next = NULL;

	//在尾部链接新节点
	p->next = temp;

	return 0;
}

int printf_linklist(LinkNode *head)
{
	LinkNode *p;
	
	for(p = head->next;p != NULL;p = p->next)
	{
		printf("%d ",p->data);
	}
	printf("\n");

	return 0;
}

int delete_assign_linklist(LinkNode *head,DATATYPE data)
{
	LinkNode *q = head;
	LinkNode *p = head->next;
	
	while(p)
	{
		if(p->data == data)
		{
			q->next = p->next;
			free(p);
			p = q->next;//重新让p在q的前面
		
		}else{//不是要删除的元素，则p,q一起移动
			p = p->next;
			q = q->next;
		}
	}
	
	return 0;
}

int find_mid_linklist(LinkNode *head)
{
	LinkNode *p = head->next;//走两步
	LinkNode *q = head->next;//走一步

	while(1)
	{
		//走两步 
		p = p->next;
		if(NULL == p)
			break;

		p = p->next;		
		if(p == NULL)
			break;

		//走一步 
		q = q->next;
	}

	printf("mid : %d\n",q->data);
	
	return 0;
}

int insert_order_linklist(LinkNode *head,DATATYPE data)
{
	LinkNode *temp;
	LinkNode *q = head;
	LinkNode *p = head->next;

	while(p)
	{
		if(p->data > data){
			break;
		}else{
			p = p->next;
			q = q->next;
		}
	}

	temp = (LinkNode *)malloc(sizeof(LinkNode));
	temp->data = data;

	temp->next = q->next;
	q->next    = temp;

	return 0;
}

//算法:链表的插入排序
//思想:
//    1.断开头和后面的节点
//    2.有序插入后面的数据节点
int sort_linklist(LinkNode *head)
{
	LinkNode *k;
	LinkNode *t;
	LinkNode *p,*q;

	//断开
	t = head->next;
	head->next = NULL;
	
	while(t != NULL)
	{
		q = head;
		p = head->next;

		while(p)
		{
			if(p->data > t->data)
			{
				break;
			}else{
				p = p->next;
				q = q->next;
			}
		}

		//k先保存t后面的节点
		k = t->next;
		t->next = q->next;
		q->next = t;

		//让t走到k的位置
		t = k;
	}

	return 0;
}

int clean_linklist(LinkNode *head)
{
	LinkNode *temp;

	while(head != NULL)
	{
		//保存头面的节点
		temp = head->next;
		//删除头节点
		free(head);
		//修改head为temp
		head = temp;
	}

	return 0;
}


int main(int argc, const char *argv[])
{
	int i;
	int a[] = {200,100,300};
	LinkNode *L1 = create_linklist();
	LinkNode *L2 = create_linklist();
	LinkNode *L3 = create_linklist();

	for(i = 0;i < sizeof(a)/sizeof(a[0]);i ++)
	{
		insert_head_linklist(L1,a[i]);
		insert_tail_linklist(L2,a[i]);
		insert_order_linklist(L3,a[i]);
	}
	
//	printf_linklist(L3);
	printf_linklist(L2);

	printf("sort L2:");
	sort_linklist(L2);
	printf_linklist(L2);


	printf_linklist(L1);
	
	delete_assign_linklist(L2,250);
	printf_linklist(L2);

	find_mid_linklist(L1);
	find_mid_linklist(L2);
	
	insert_order_linklist(L2,250);
	insert_order_linklist(L2,250);
	printf_linklist(L2);

	return 0;
}

数据结构和算法教程（C语言版）
数据结构和算法教程（C语言版）
11-04 1529
数据结构研究的是数据之间的关系，再进一步说，它研究的是多份数据之间的分布、排列和勾连的关系，以及在此基础之上如何进行高效的增删改查操作。数据结构是计算机专业的基础课程，也是所有程序员的内功心法；不懂数据结构就是写代码的农民，了解数据结构才能成为行业专家。六年创作，三次迭代，千般打磨，成就了现在这套精品的数据结构和算法教程。为了降低阅读门槛，本教程所有代码都基于C语言编写。
数据结构 算法与应用（c++ 描述） 自练答案
qq_57065913的博客
09-12 4896
有不正确请提出 第一章 1.1 应该把形参 换成引用 int x--&gt; int &amp;x 1.2 #include&lt;iostream&gt; using namespace std; template &lt;class T,class T1&gt; //模板形参的类型 int count (T array,int end,T1 value){ int i =0,count=0; while(i&lt;...
数据结构(线性存储)
weixin_45030544的博客
08-12 1201
将具有“一对一”关系的数据“线性”地存储到物理空间中，这种存储结构就称为线性存储结构. 线性表存储数据可细分为以下 2 种： 1.将数据依次存储在连续的整块物理空间中，这种存储结构称为顺序存储结构（简称顺序表）； 2.数据分散的存储在物理空间中，通过一根线保存着它们之间的逻辑关系，这种存储结构称为链式存储结构（简称链表）； 以上是我复习数据结构的一些笔记,如果有错误或者不足,请大家帮忙指正. ...
线性表的线性存储和链式存储
Keep coding
08-18 986
顺序存储结构线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。在C语言中可以用一维数组或连续堆空间来实现顺序存储结构 1. 存储空间的起始位置：数组node 2. 线性表的最大容量：数组长度MAXSIZE，也可用malloc申请对空间 3. 线性表的当前长度：length#define MAXSIZE 20typedef struct _tag_List {
链表反转
dixianmm198686的博客
03-05 199
/* 单链表反转/逆序 */ Status ListReverse(LinkList L) { LinkList current,pnext,prev; if(L == NULL || L-&gt;next == NULL) return L; current = L-&gt;next; /* p1指向链表头节点的下一个节点 */...
线性表的顺序存储和链式存储
2007 年 ~ 2025 年，深耕 SAP 技术 18 年
05-20 400
线性表中的元素之间存在一对一的前驱和后继关系，每个元素都有唯一的前驱和后继（除了首元素和末元素）。数组的索引表示学生的位置，从0开始。例如，要获取第2个学生的年龄，我们可以从头指针开始，沿着链表的指针找到第2个节点，然后读取节点中的年龄字段，对应的值是22。链式存储使用节点的指针来连接线性表中的元素，每个节点包含数据和指向下一个节点的指针。我们可以使用线性表来表示，每个节点包含一个学生的信息以及指向下一个节点的指针。例如，要获取第3个学生的成绩，可以通过访问数组的索引2来获取，对应的成绩是95。
线性存储结构-LinkedList
dengxi7116的博客
11-14 295
LinkedList内部采用链表的形式构建，是一个双向链表。除了继承List外，还继承了Deque接口，可以当做堆栈结构使用。 private static final class Link&lt;ET&gt; { ET data; //数据 Link&lt;ET&gt; previous, next; //前节点、后节点 Link(ET o, Link&...
【数据结构C++】线性表-链式存储：链表类型和单链表（定义+代码实现）
JingYan_Chan的博客
03-15 1592
本章我们介绍线性表的链式存储——链表。链表类型、单链表理论知识和类型定义，具体函数的代码模板
5.14面试复盘
qq_41537989的博客
05-20 1236
5.14面试复盘 5.14上午前端开发面试 笔试题 1.写出一种你最熟悉的排序算法 十大经典算法排序总结对比 名词解释： n: 数据规模 k:“桶”的个数 In-place: 占用常数内存，不占用额外内存 Out-place: 占用额外内存 稳定性：排序后2个相等键值的顺序和排序之前它们的顺序相同 冒泡排序（Bubble Sort） 冒泡排序算法的原理如下： 1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该
Halcon那些事:Halcon算子中文解释
十多年IT经验,专注机器视觉,智能制造半导体行业
01-12 4259
Chapter_1_:Classification 1.1 Gaussian-Mixture-Models 1.add_sample_class_gmm 功能：把一个训练样本添加到一个高斯混合模型的训练数据上。 2.classify_class_gmm 功能：通过一个高斯混合模型来计算一个特征向量的类。 clear_all_class_gmm 功能：清除所有高斯混合模型。 clear_class_gmm 功能：清除一个高斯混合模型。 clear_samples_class_gmm 功能：清除一
队列的线性存储和链式存储实现
xiaoding133的专栏【Stay hungry,Stay foolish】
07-11 1454
队列是只允许在队尾插入元素，在队头删除元素的线性表。它有两种存储结构，即是顺序存储和链式存储结构。 链式存储结构实际上是一个同时带有首指针和尾指针的单链表。实现如下： #include using namespace std; const int MaxSize=20; typedef struct { int data[MaxSize]; int font,rear; }SqQueue
数据结构系列之一线性的链式存储结构
yeputi_WK的博客
10-22 775
定义：线性表的链式存储结构的特点是一组保利任意的存储线性表的数据元素，这组存储单元可以是连续的，也可以不是连续的。这些数组元素可以存储在内存中的任意位置。 在顺序结构中，每个数据元素只需要存数据元素信息就可以了。现在的链式结构中，除了要存数据元素信息外，还要存储它的后续元素的存储地址。 因此，为了表示每个数据元素与其直接后继数据元素之间的逻辑关系，对数据元素a1来说，除了存储其本身的信息之外，...
线性表 链式存储
weixin_60833644的博客
04-10 2959
线性表的链式存储（单向链（循环），双向链（循环））
数据结构（一）线性存储结构
在路上
06-13 9950
线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 线性结构拥有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的，链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。 线性结构中存在两种操作受限的使用场景，即队列和栈。栈的操作只能在线性表的一端进行，...
【数据结构】模块一：线性存储
最新发布
2303_80794742的博客
07-09 302
基础的数组知识在语言程序设计中均已有学习，因此，在数据结构中，要学会如何使用连续存储的知识，综合模拟使用数组与结构体，这是十分重要的。，其二者只不过是简化版的数组或链表，用于特殊应用，因此，学好线性结构，打好基础是十分重要的。今天就从最简单的连续存储（数组）学起来。两种存储方式，共有两种常见的应用，即。线性结构，简单地说，就是。
线性存储结构-线性表
前人栽树，后人乘凉。
02-25 1856
线性存储结构-线性表线性表是什么？特性顺序存储结构和链式存储结构的区别顺序存储结构（线性表）链式存储结构（链表）单向链表链表的节点头节点，头指针和首元节点双向链表单向链表和双向链表的区别？ 线性表是什么？ 全名为线性存储结构，线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性
【线性存储结构总结】
m0_熊猫馆主的博客
11-12 654
详细讲解带头双向循环链表的基本操作，并且对线性表的相关特性进行总结。
线性表的线性存储结构
HDT
12-08 990
用C语言实现线性表的线性存储结构
数据结构笔记之线性存储
kaka的博客
08-04 693
线性结构[把所有的节点用一根直线穿起来] A：连续存储[数组] 1.什么叫数组 元素类型相同，大小相等 2.数组的优缺点 实例：数组操作 #include #include #include struct Arr { int * pBase; //数组第一个元素的地址 int len; //数组长度 int cnt; //有效元素个数 //int incr
Qt 5.14实现Modbus从站与SQLite数据存储解决方案
在这个项目中，SimuWindPower实现了Modbus协议的从站功能，并使用SQLite数据库来存储各类寄存器表的数据，包括coils（线圈）、dis（离散输入）、input（输入寄存器）和hold（保持寄存器）。项目基于Qt 5.14版本，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值