数据结构02(顺序表数组实现，链式表，完整代码实现)

最新推荐文章于 2024-05-05 15:21:21 发布
最新推荐文章于 2024-05-05 15:21:21 发布
阅读量158 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50711528/article/details/126184675
版权

数据结构之顺序表

目录

一、顺序表的介绍

顺序表是在计算机内存中以数组的形式保存的线性表

线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构结构的线性表通常称为顺序表。

顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

二、顺序表的要求

数组实现：

顺序表的数据项：存储元素的连续内存首地址、表的容量、当前元素的数量

支持的运算： 创建、销毁、清空、插入、删除、访问、查询、修改、排序、遍历

链表实现：

元素(结点)的数据项为：1、数据域：可以是任何类型的若干个数据项。2、指针域：指向下一个结点。

其中带有头节点和不带有头节点的链表实现存在差异：

不带头结点的单链表：
第一个结点的数据域存储有效数据
缺点：添加、删除结点时，可能修改指向第一个结点的指针，参数需要使用二级指针，才能更改指针的指向，比较麻烦

带头结点的单链表：
第一个结点的数据域不存储有效元素，仅仅只是使用它的指针域永远指向链表的第一个数据有效的结点，可以使插入、删除等操作变得简便，缺点是浪费了一块内存

三、代码实现

1）顺序表数组实现

/************************************
> 作者：杭电羊皮卷
> weixin:QQ2997675141
************************************/

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

#define TYPE int

// 设计顺序表结构
typedef struct Array{
	TYPE* ptr;	//存储元素的内存首地址
	size_t cal;	//表的容量
	size_t cnt;	//已存储元素的数量
}Array;

//创建
Array* create_array(size_t cal);
//销毁
void destory_array(Array* arr);
//清空
void clean_array(Array* arr);
//插入
bool insert_array(Array* arr,int index,TYPE val);
//删除
bool delete_array(Array* arr,size_t index);
//访问
bool access_array(Array* arr,size_t index,TYPE* val);
//查询
int query_array(Array* arr,TYPE val);
//修改
bool modify_array(Array* arr,size_t index,TYPE val);
//排序
void sort_array(Array* arr);
//遍历
void show_array(Array* arr);

Array* create_array(size_t cal)
{
	//分配顺序表结构的内存
	Array* arr=(Array*)malloc(sizeof(Array));
	if(arr == NULL)
	{
		return NULL;	
	}
	//分配储存元素的内存
	arr->ptr = (TYPE*)malloc(sizeof(TYPE)*cal);
	arr->cal = cal;
	arr->cnt = 0;
	return arr;
}

void destory_array(Array* arr)
{
	free(arr->ptr);
	free(arr);
}

void clean_array(Array* arr)
{
	arr->cnt = 0;	
}

bool insert_array(Array* arr,int index,TYPE val)
{
	//判断表是否满
	if(arr->cal <= arr->cnt)	return false;
	if(index > arr->cnt || index < 0)	return false;
	/*
	for(int i=arr->cnt; i>index; i--)
	{
		arr->ptr[i] = arr->ptr[i-1];	
	}
	*/
	memmove(arr->ptr+index+1,arr->ptr+index,(arr->cnt-index)*sizeof(TYPE));
	arr->ptr[index] = val;
	arr->cnt++;
	return true;
}

bool delete_array(Array* arr,size_t index)
{
	if(index >= arr->cnt)	return false;
	/*
	for(int i=index;i<arr->cnt-1;i++)
	{
		arr->ptr[i] = arr->ptr[i+1];	
	}
	*/
	memmove(arr->ptr+index,arr->ptr+index+1,sizeof(TYPE)*arr->cnt-index-1);
	arr->cnt--;
	return true;
}

bool access_array(Array* arr,size_t index,TYPE* val)
{
	if(index >= arr->cnt)	return false;	
	*val = arr->ptr[index];
	return true;
}

int query_array(Array* arr,TYPE val)
{
	for(int i=0; i<arr->cnt; i++)
	{
		if(arr->ptr[i] == val)
		{
			return i;	
		}
	}
	return -1;
}

bool modify_array(Array* arr,size_t index,TYPE val)
{
	if(index >= arr->cnt)	return false;
	arr->ptr[index] = val;
	return true;
}

void sort_array(Array* arr)
{
	for(int i=0; i<arr->cnt-1; i++)
	{
		for(int j=i+1; j<arr->cnt;j++)
		{
			if(arr->ptr[i]>arr->ptr[j])
			{
				TYPE temp;
				temp = arr->ptr[i];
				arr->ptr[i] = arr->ptr[j];
				arr->ptr[j] = temp;
			}
		}
	}
}

void show_array(Array* arr)
{
	if(arr == NULL)	return;
	for(int i=0; i<arr->cnt;i++)
	{
		printf("%d ",arr->ptr[i]);	
	}
	printf("\n");
}

int main(int argc,const char* argv[])
{
	//这里写测试代码，我就不写了
	return 0;
}

2）链式表不带头结点实现

/************************************
> 作者：杭电羊皮卷
> weixin:QQ2997675141
************************************/

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

#define TYPE int

//设计链表中节点的类型
typedef struct Node{
	TYPE data;			//节点数据域
	struct Node* next;	//节点指针域
}Node;

//创建节点
Node* create_node(TYPE data);
//头添加
void add_head_list(Node** head,int val);
//按值删除
bool del_value_list(Node** head,TYPE data);
//按下标位置删除
bool del_index_list(Node** head,size_t index);
//排序
void sort_list(Node* head);
//遍历
void show_list(Node* head);
//访问
bool access_list(Node* head,int index,TYPE* val);


Node* create_node(TYPE data)
{
	//分配节点所需要的内存
	Node* node = (Node* )malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
}

void add_head_list(Node** head,int val)
{
	Node* node = create_node(val);
	node->next = *head;
	*head = node;
}

bool del_value_list(Node** head,TYPE data)
{
	if(data == (*head)->data)
	{
		Node* temp = *head;	
		*head = (*head)->next;
		free(temp);
		return true;
	}
	for(Node* n=*head; n->next!=NULL; n=n->next)
	{
		if(n->next->data == data)
		{
			Node* temp = n->next;
			n->next = temp->next;
			free(temp);
			return true;
		}
	}
	return false;
}

bool del_index_list(Node** head,size_t index)
{
	if(index == 0)
	{
		Node* node = *head;
		*head = node->next;
		free(node);
		return true;
	}
	Node* pre=*head;
	for(int i=0;i<index-1;i++)
	{
		pre = pre->next;
		if(pre == NULL)
		{
			return false;	
		}
	}
	Node* temp = pre->next;
	pre->next = temp->next;
	free(temp);
	return true;
}

void sort_list(Node* head)
{
	for(Node* i=head; i->next!=NULL; i=i->next)
	{
		for(Node* j=i->next;j!=NULL;j=j->next)
		{
			if(i->data > j->data)
			{
				TYPE temp = i->data;
				i->data = j->data;
				j->data = temp;
			}
		}
	}
}

void show_list(Node* head)
{
	for(Node* n=head; n!=NULL; n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}

bool access_list(Node* head,int index,TYPE* val)
{
	Node* node = head;
	for(int i=0; i<index; i++)
	{
		node = node->next;
		if(node == NULL)	return false;
	}
	*val = node->data;
	return true;
}
int main(int argc,const char* argv[])
{
	//这里写测试代码
	return 0;
}

3）链式表带头结点实现（推荐）

/************************************
> 作者：杭电羊皮卷
> weixin:QQ2997675141
************************************/

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

#define TYPE int

//设计链表中节点的类型
typedef struct Node{
	TYPE data;			//节点数据域
	struct Node* next;	//节点指针域
}Node;

//创建节点
Node* create_node(TYPE data);
//头插法插入节点
void add_head_list(Node* head,TYPE val);
//尾插法插入节点
void add_tail_list(Node* head,TYPE val);
//按值删除
bool del_value_list(Node* head,TYPE val);
//按下标位置删除
bool del_index_list(Node* head,size_t index);
//在指定位置插入（排除头和尾）
bool insert_list(Node* head,size_t index,TYPE val);
//修改
bool modify_list(Node* head,TYPE old,TYPE new);
//访问
bool access_list(Node* head,size_t index,TYPE* val);
//按值查找
int query_list(Node* head,TYPE val);
//啥也不是排序法
void sort_list(Node* head);
//遍历
void show_list(Node* head);

Node* create_node(TYPE data)
{
	//分配节点所需要的内存
	Node* node = (Node* )malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
}

void add_head_list(Node* head,TYPE val)
{
	Node* node = create_node(val);
	node->next = head->next;
	head->next = node;
}

void add_tail_list(Node* head,TYPE val)
{
	while(head->next != NULL)
	{
		head = head->next;	
	}
	Node* node = create_node(val);
	head->next = node;
}

bool del_value_list(Node* head,TYPE val)
{
	while(head->next != NULL)
	{
		if(head->next->data == val)
		{
			Node* temp;
			temp = head->next;
			head->next = temp->next;
			free(temp);
			return true;
		}
	}
	return false;
}

bool del_index_list(Node* head,size_t index)
{
	Node* n = head;
	if(NULL == n->next)	return false;
	for(int i=0; i<index; i++)
	{
		if(NULL == n->next)	return false;
		n=n->next;	
	}
	if(NULL == n->next)	return false;
	Node* temp = n->next;
	n->next = temp->next;
	free(temp);
	return true;
}

bool insert_list(Node* head,size_t index,TYPE val)
{
	Node* n = head;
	if(n->next == NULL || index == 0)	return false;
	for(int i=0; i<index; i++)
	{
		n = n->next;
		if(NULL == n->next)	return false;
	}
	Node* node = create_node(val);
	node->next = n->next;
	n->next = node;
	return true;
}

bool modify_list(Node* head,TYPE old,TYPE new)
{
	for(Node* n=head; NULL!=n; n=n->next)
	{
		if(n->data == old)
		{
			n->data = new;
			return true;
		}
	}
	return false;
}

bool access_list(Node* head,size_t index,TYPE* val)
{
	Node* n = head->next;
	if(NULL == n)	return false;
	for(int i=0; i<index; i++)
	{
		n = n->next;
		if(NULL == n)	return false;	
	}
	*val = n->data;
	return true;
}

int query_list(Node* head,TYPE val)
{
	Node* n = head->next;
	for(int i=0; NULL!=n; i++)
	{
		if(n->data == val)	return i;	
		n = n->next;
	}
	return -1;
}

void sort_list(Node* head)
{
	for(Node* i=head->next; i->next!=NULL; i=i->next)
	{
		for(Node* j=i->next; j!=NULL; j=j->next)
		{
			if(i->data > j->data)
			{
				TYPE t= j->data;
				j->data = i->data;
				i->data = t;
			}
		}
	}
}

void show_list(Node* head)
{
	for(Node* node = head->next; node!=NULL; node=node->next)
	{
		printf("%d ",node->data);	
	}
	printf("\n");
}

int main()
{
	//head就是带头节点链表的头节点
	//head->next永远指向第一个有效数据的节点
	Node* head = create_node(0);
	//这里写测试代码
    return 0;
}

若有瑕疵，联系修改，不胜感激！下一章，我们将学习栈结构的相关知识，敬请期待……

杭电羊皮卷
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实战 -- 线性结构动态数组表示法（C实现源码）
10-24
线性结构动态数组表示法，C实现源码，更多内容请见http://blog.csdn.net/zhongkelee
C++学习之用数组实现顺序表
jacky_wang_123的专栏
06-07 2045
开始学习数据结构，路还长，加油！！ 用C++的template实现顺序表SequenceList ，第一次上传完整代码，比较菜。 SequenceList.h: #ifndef SEQ_LIST_H #define SEQ_LIST_H #include #include //模板的声明和定义要在同一个头文件中 //创建一个顺序表类模板 template class Sequ
数据结构-顺序表的结构与代码实现
m0_61789994的博客
06-06 1004
顺序表是一种线性结构，它是一种连续的存储结构，可以用数组来实现。顺序表中的元素在内存中是连续存储的，每个元素都有一个唯一的下标，可以通过下标来访问元素。顺序表中的元素可以是任意类型的数据，如整数、浮点数、字符、字符串等。顺序表是一种静态的数据结构，它的大小在创建时就已经确定，无法动态地改变大小。如果需要添加或删除元素，需要重新创建一个新的顺序表，并将原来的元素复制到新的顺序表中。
数据结构与算法——顺序表 (完整代码)
zz137955的博客
10-31 1896
基于语言实现数据结构第一节——顺序表 增删查改
【数据结构】C语言实现顺序表（超级详细）
热门推荐
m0_74459723的博客
01-01 1万+
顺序表作为线性表的一种，它是用一段数据元素的线性结构，一般情况下采用。在数组上完成数据的增删查改。顺序表一般分为：1、静态顺序表——使用定长数组进行存储元素。这种存储方式在存储数据时比较有局限性，当数据存储量非常小的时候，数组长度太长，会造成空间的浪费；当数据存储量非常大的时候，数组空间可能会不够，但是这种存储方式不能进行扩容。所以在实现顺序表时，我们通常使用的是动态顺序表。这样能够提高我们的空间利用率。2、动态顺序表——使用动态开辟的数组进行存储元素。
数组的顺序表示和实现
weixin_30278237的博客
08-20 131
// c5-1.h 数组的顺序存储表示(见图5.1) #include<stdarg.h> // 标准头文件，提供宏va_start，va_arg和va_end，用于存取变长参数表 #define MAX_ARRAY_DIM 8 // 假设数组维数的最大值为8 struct Array { ElemType *base; // 数组元素基址，由InitArray分配 int...
顺序表---增删查
anshengla的博客
04-26 228
王道c顺序表
【数据结构】java数组实现顺序表
JZJ_LYH的博客
07-31 246
顺序表是一种线性表的存储结构，它的元素在物理上按照顺序紧密地存储在一块连续的内存空间中。在Java中，可以使用数组来实现顺序表。
数据结构 - 数组的存储表示和实现
Spike的秃头之路
11-28 757
采用书上第93页定义的数组的顺序存储表示，编程实现数组的下列基本操作 （1） 构造数组 （2）销毁数组 （3）取数组元素值 （4） 给数组元素赋值 2.采用书上第98页定义的稀疏矩阵的三元组顺序表存储表示，编程实现矩阵的转置运算算法和快速转置算法。 7.1 #include<malloc.h> #include<stdio.h> #include<process.h> #include<math.h> #include<stdarg.h> #.
数据结构 顺序表
kjl167的博客
06-28 582
顺序表
数据结构顺序表的实现方式.docx
11-26
数据结构顺序表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是...
关于数据结构中数组、链表、队列、散列表、集合的理解
01-08
链表是一种链式数据结构，由若干节点组成，每个节点包含指向下一个节点的指针。链表的物理存储方式是随机存储，访问方式是顺序访问。查找链表节点的时间复杂度是O[n],中间插入、删除节点的时间复杂度是O(1)。 栈 栈...
数据结构和算法必知必会的50个代码实现
06-26
## 栈* 用数组实现一个顺序栈* 用链表实现一个链式栈* 编程模拟实现一个浏览器的前进、后退功能 ## 队列* 用数组实现一个顺序队列* 用链表实现一个链式队列* 实现一个循环队列 ## 递归* 编程实现斐波那契数列求值f(n...
数据结构-顺序表实现.doc
07-11
掌握线性表的基本操作:建表、插入、删除、输出等运算在顺序存储结构和链式存储结 构上的实现； 3. 通过本次实习加深对高级语言C语言的使用(特别是函数参数、指针类型、链表的使用) 。熟悉线性表的基本运算在两种...
【Java数据结构与算法】稀疏数组
01-20
文章目录数据结构类型线性结构与非线性结构稀疏数组实例应用二维数组转稀疏数组的思路稀疏数组转原始的二维数组思路 数据结构类型 数据结构包括：线性结构和非线性结构。 线性结构与非线性结构 线性结构 线性结构...
[数据结构与算法] 线性表之数组基本操作代码实现详解
淋曦的进击手记
08-14 474
数据结构与算法之数组基本操作代码实现详解
数据结构-快速排序算法【C语言版】
极客代码
05-05 578
快速排序是一种高效的排序算法，通过分治法将数组分为两个子序列，然后递归地对子序列进行排序。尽管快速排序的实现细节可能较为复杂，但它是一个非常有用的排序算法，可以在各种编程语言中实现。通过了解快速排序的原理和实现细节，您可以更好地理解和应用它。在实际应用中，快速排序通常不是处理大规模数据的首选算法，但对于教学和算法理解来说，它是一个很好的起点。通过了解快速排序的高级概念和优化技巧，您可以更好地应用它并提高程序的效率。
搜索算法系列之二(二分查找)
磐门的博客
05-02 485
二分查找仅适用于有序数据、有序数组，二分查询大数据情况下表现较好，但数据量仍限制于内存。
数据结构（十一）----图的应用
最新发布
weixin_69884785的博客
05-05 856
数据结构（十一）----图和有向无环图的应用 一.最小生成树 1.Prim算法（普里姆） 2.Kruskal算法(克鲁斯卡尔): 二.最短路径（BFS算法） 1.单源最短路径 （1）BFS算法（无权图） （2）Dijkstra算法（带权图，无权图） 2.各顶点间的最短路径 （1）Floyd（带权图，无权图） 三.有向无环图（DAG） 1.算术表达式 2.拓扑排序 •逆拓扑排序 3.关键路径
数据结构实验数组广义表
06-06
1. 数组实验：可以尝试实现数组的基本操作，如初始化、查找、修改、插入和删除等，同时实现数组的顺序存储结构和链式存储结构。还可以尝试实现数组的基本算法，如顺序查找、二分查找、插入排序和快速排序等。 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值