静(动)态顺序表的实现

最新推荐文章于 2023-07-26 19:50:28 发布
最新推荐文章于 2023-07-26 19:50:28 发布
阅读量357 收藏
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25424545/article/details/72822743
版权

静态顺序表和动态顺序表是其他表结构的基础

静态顺序表

SeqList.h

#ifndef __SEQLIST__H__
#define __SEQLIST__H__


#include <stdio.h>
#include <string.h>
#include <assert.h>

#define MAX 100 
typedef int DateType;

typedef struct SeqList 
{
	DateType data[MAX];
	int sz;
	
}SeqList,*pSeqList;


void InitSeqlist(pSeqList ps);
void PushBack(pSeqList ps, DateType d);
void PrintSeqist(const pSeqList ps);
void PopBack(pSeqList ps);
void PushFront(pSeqList ps, DateType d);
void PopFront(pSeqList ps);
void Insert(pSeqList ps, int pos, DateType d);
int Find(pSeqList ps, DateType d);
void Remove(pSeqList ps, DateType d);
void ReverseSeqlist(pSeqList ps);
void SortSeqlist(pSeqList ps);
int BinarySearch(pSeqList ps, DateType d);

#endif//__SEQLIST__H__

SeqList.c 

#include "SeqList.h"
void InitSeqlist(pSeqList ps)
{
	assert(ps);
	memset(ps->data,0,sizeof(ps->data[0])*MAX);
	ps->sz=0;
	return;
}
void PrintSeqist(const pSeqList ps)
{
	int i = 0;
	for(i=0;i<ps->sz;i++)
	{
		printf("%d ",ps->data[i]);
	}
	printf("\n");
	return;
}
void PushBack(pSeqList ps, DateType d)
{
	assert(ps);
	if(ps->sz==MAX)
	{
		return;
	}
	ps->data[ps->sz]=d;
	ps->sz++;
	return;

}
void PopBack(pSeqList ps)
{
	assert(ps);
	if(ps->sz==0)
	{
		return;
	}
	ps->sz--;
	return;

}
void PushFront(pSeqList ps, DateType d)
{
	int i = 0;
	assert(ps);
	if (ps->sz==MAX)
	{
		return;
	}
	for (i=ps->sz;i>0;i--)//在这种有判断的地方留一个心，可以假设最后那个值，看是否合适
	{
		ps->data[i]=ps->data[i-1];
	}
	ps->data[0]=d;
	ps->sz++;
	
	return;
}
void PopFront(pSeqList ps)
{
	int i = 0;
	assert(ps);
	if (ps->sz==0)
	{
		return;
	}
	for (i=0;i<ps->sz-1;i++)
	{
		ps->data[i]=ps->data[i+1];
	}
	ps->sz--;
	return;
}
void Insert(pSeqList ps, int pos, DateType d)
{
	int i = 0;
	assert(ps);
	if (ps->sz==MAX)
	{
		return;
	}
	for (i=ps->sz;i>pos;i--)
	{
		ps->data[i]=ps->data[i-1];
	}
	ps->data[pos]=d;
	ps->sz++;
	return;
}
int Find(pSeqList ps, DateType d)
{
	int i = 0;
	assert(ps);
	if(ps->sz!=0)
	{
		for (i=0;i<ps->sz;i++)
		{
			if(ps->data[i]==d)
				return i;
		}

	}
	return -1;
}
void Remove(pSeqList ps, DateType d)
{
	int ret = 0;
	int i = 0;
	assert(ps);
	if (ps->sz==0)
	{
		return;
	}
	ret = Find(ps,d);
	if (ret!=-1)
	{
		for (i=ret;i<ps->sz-1;i++)
		{
			ps->data[i]=ps->data[i+1];
		}
		ps->sz--;
	}
	return;
}
void ReverseSeqlist(pSeqList ps)
{
	
	int left = 0;
	int right = ps->sz-1;
	int tmp = 0;
	assert(ps);
	if (ps->sz==0)
	{
		return;
	}
	while(left<right)
	{
		tmp = ps->data[right];
		ps->data[right] = ps->data[left];
		ps->data[left] = tmp;
		left++;
		right--;
	}
	return;

}
void SortSeqlist(pSeqList ps)
{
	int i = 0;
	int j = 0;
	int tmp = 0;
	assert(ps);
	if (ps->sz==0)
	{
		return;
	}
	for (i=0;i<ps->sz-1;i++)
	{
		for (j=0;j<ps->sz-1-i;j++)
		{
			if (ps->data[j]>ps->data[j+1])
			{
				tmp = ps->data[j];
				ps->data[j] = ps->data[j+1];
				ps->data[j+1] = tmp;
			}
		}

	}
	return;
}
int BinarySearch(pSeqList ps, DateType d)
{
	int left = 0;
	int right = ps->sz-1;
	int mid = 0;
	SortSeqlist(ps);
	assert(ps);
	if (ps->sz!=0)
	{
		while (left<=right)//注意是小于等于
		{
			mid = (left+right)/2;
			if (ps->data[mid]==d)
			{
				return mid;
			}
			else if (ps->data[mid]<d)
			{
				left = mid+1;
			}
			else
			{
				right = mid-1;
			}
		}
	}
	return -1;
	
}
test.c 

#include "SeqList.h"
void test()
{
	SeqList s;
	int ret = 0;
	InitSeqlist(&s);
	PushBack(&s,1);
	PushBack(&s,3);
	PushBack(&s,2);
	PushBack(&s,4);
	PrintSeqist(&s);
	return;
}
int main()
{
	test();
	return 0;
}

上述功能均测试通过，有兴趣可以自行再测试。

动态顺序表

SeqList_D.h

#ifndef __SEQLIST_D_H__
#define __SEQLIST_D_H__

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

typedef int DataType;



#define DEFALUT_INC 5

typedef struct SeqList
{
	DataType* pdata;//指向数据的存储位置
	int sz;//有效个数
	int capacity;//容量
}SeqList, *pSeqList;


//初始化顺序表
void InitSeqList(pSeqList ps);//初始化表
void DestroySeqList(pSeqList ps);//销毁表
void PushBack(pSeqList ps, DataType d);//在尾部添加
void PrintSeqList(const pSeqList ps);//打印顺序表
void PopBack(pSeqList ps);//删除尾部元素
void PushFront(pSeqList ps, DataType d);//在头部添加
void PopFront(pSeqList ps);//删除头部元素
void Insert(pSeqList ps, int pos, DataType d);//在输入位置前端插入
int Find(pSeqList ps, DataType d);//查找某元素位置
void Remove(pSeqList ps, DataType d);//删除输入的元素
void ReverseSeqlist(pSeqList ps);//逆序顺序表
void SortSeqlist(pSeqList ps);//排序顺序表(冒泡)
int BinarySearch(pSeqList ps, DataType d);//二分查找


#endif//__SEQLIST_D_H__


SeqList.c

#include "SeqList_D.h"
void InitSeqList(pSeqList ps)
{
	ps->sz=0;//
	ps->capacity=DEFALUT_INC;
	ps->pdata=(DataType*)malloc(sizeof(DataType)*(DEFALUT_INC));
	if(ps->pdata==NULL)
		return;	
}
void DestroySeqList(pSeqList ps)
{
	ps->sz=0;
	ps->capacity=DEFALUT_INC;
	free(ps->pdata);//释放这个，并且之后要给空值
	ps->pdata=NULL;
}
int Check_Capacity(pSeqList ps)
{
	DataType* temp = ps->pdata;//预防开辟失败
	assert(ps);
	if(ps->capacity==ps->sz)
	{
		ps->pdata=(DataType*)realloc(ps->pdata,sizeof(DataType)*(ps->capacity+DEFALUT_INC));//realloc中还有个参数是内存起始地址

		if(ps->pdata==NULL)
		{ 
			ps->pdata=temp;
			return -1;
		} 
		else
		{
			ps->capacity=ps->capacity+DEFALUT_INC;
		}
		
	}
	return 1;

}
void PushBack(pSeqList ps, DataType d)
{
	int ret= Check_Capacity(ps);//这个动态开辟也就是在添加时候需要
	assert(ps);
	if(ret==1)
	{
		ps->pdata[ps->sz]=d;
		ps->sz++;
	}
}
void PrintSeqList(const pSeqList ps)
{
	int i = 0;
	for(i=0;i<ps->sz;i++)
	{
		printf("%d ",ps->pdata[i]);
	}
	printf("\n");
	return;
}
void PopBack(pSeqList ps)
{
	assert(ps);
	if(ps->sz==0)
	{
		return;
	}
	ps->sz--;
	return;

}
void PushFront(pSeqList ps, DataType d)
{
	int i = 0;
	int ret = Check_Capacity(ps);
	assert(ps);
	if(ret==1)
	{
		for (i=ps->sz;i>0;i--)
		{
			ps->pdata[i]=ps->pdata[i-1];
		}
		ps->pdata[0]=d;
		ps->sz++;
	}
}
void PopFront(pSeqList ps)
{
	int i = 0;
	assert(ps);
	if (ps->sz==0)
	{
		return;
	}
	for (i=0;i<ps->sz-1;i++)
	{
		ps->pdata[i]=ps->pdata[i+1];
	}
	ps->sz--;
	return;
}
void Insert(pSeqList ps, int pos, DataType d)
{
	int i = 0;
	int ret = Check_Capacity(ps);
	assert(ps);
	if (ret==1)
	{
		for (i=ps->sz;i>pos;i--)
		{
			ps->pdata[i]=ps->pdata[i-1];
		}
		ps->pdata[pos]=d;
		ps->sz++;
		
	}

	return;
}
int Find(pSeqList ps, DataType d)
{
	int i = 0;
	assert(ps);
	if(ps->sz!=0)
	{
		for (i=0;i<ps->sz;i++)
		{
			if(ps->pdata[i]==d)
				return i;
		}

	}
	return -1;
}
void Remove(pSeqList ps, DataType d)
{
	int ret = 0;
	int i = 0;
	assert(ps);
	if (ps->sz==0)
	{
		return;
	}
	ret = Find(ps,d);
	if (ret!=-1)
	{
		for (i=ret;i<ps->sz-1;i++)
		{
			ps->pdata[i]=ps->pdata[i+1];
		}
		ps->sz--;
	}
	return;
}
void ReverseSeqlist(pSeqList ps)
{

	int left = 0;
	int right = ps->sz-1;
	int tmp = 0;
	assert(ps);
	if (ps->sz==0)
	{
		return;
	}
	while(left<right)
	{
		tmp = ps->pdata[right];
		ps->pdata[right] = ps->pdata[left];
		ps->pdata[left] = tmp;
		left++;
		right--;
	}
	return;

}

void SortSeqlist(pSeqList ps)
{
	int i = 0;
	int j = 0;
	int tmp = 0;
	assert(ps);
	if (ps->sz==0)
	{
		return;
	}
	for (i=0;i<ps->sz-1;i++)
	{
		for (j=0;j<ps->sz-1-i;j++)
		{
			if (ps->pdata[j]>ps->pdata[j+1])
			{
				tmp = ps->pdata[j];
				ps->pdata[j] = ps->pdata[j+1];
				ps->pdata[j+1] = tmp;
			}
		}

	}
	return;
}
int BinarySearch(pSeqList ps, DataType d)
{
	int left = 0;
	int right = ps->sz-1;
	int mid = 0;
	SortSeqlist(ps);
	assert(ps);
	if (ps->sz!=0)
	{
		while (left<=right)
		{
			mid = (left+right)/2;
			if (ps->pdata[mid]==d)
			{
				return mid;
			}
			else if (ps->pdata[mid]<d)
			{
				left = mid+1;
			}
			else
			{
				right = mid-1;
			}
		}
	}
	return -1;

}

test.c

#include "SeqList_D.h"
void test()
{
	SeqList s;
	InitSeqList(&s);
	PushBack(&s,1);
	PushBack(&s,2);
	PushBack(&s,5);
	PushBack(&s,4);
	PushBack(&s,3);
	PrintSeqList(&s);
	SortSeqlist(&s);
	PrintSeqList(&s);
	return;
}
int main()
{
	test();
	return 0;
}

T_tangc
关注
专栏目录
【数据结构】之 动态顺序表（C语言）（含完整代码）
weixin_53936115的博客
12-18 1217
顺序表概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下用数组存储。在数组上完成数据的增删查改。 代码解析： 1.准备工作 1.首先对一些头文件的引用和创建一个结构体，结构体包含一个数组，size表示该数组目前有多少个元素，capacity表示目前数组能存多少个元素。例如： #include<stdio.h> #include<stdlib.h> #include<malloc.h> #include&l...
动态顺序表
melody_1016的博客
11-12 416
我们对静态顺序表可能比较熟悉，它的定义方式是 struct SeqList { int arr[100]; int _size;//当前存放数据的个数 }; 主要思想就是利用数组可以一次性开辟一整块空间，存放我们想要的数据。从这个结构体的定义，我们可以获得如下信息： 开辟的空间大小为100，（即可以存放100个整型数据），_size记录了当前数组中有效元素的个数，为什么要有这一...
顺序表（动态）
L_R
09-13 376
上篇博客介绍了静态顺序表的增删查改以及排序，我们知道了: 静态顺序表的长度是固定的，但是如果我们在使用顺序表是并不知道顺序表的长度，或者在使用过程中，顺序表的长度不够了，难道我们要重新再创建一个新的顺序表吗？这样显然是很麻烦的。所以本篇博客将讨论动态顺序表。 那么动态顺序表和静态顺序表又有什么区别呢？ 上面我们提到了静态顺序表的局限性，那么动态顺序表很有效的解决了静态的不足之处，当在使用顺序...
数据结构之动态顺序表
qq_56012214的博客
04-18 1826
数据结构——动态顺序表
【数据结构】动态顺序表
卑微楽的开发之路
09-26 206
线性表 在说顺序表之前我们先来了解一下线性表, 线性表就是n个类型相同的数据元素的有限序列. 线性表在逻辑上是线性的结构, 可以理解为一条直线, 但是在物理上不一定是连续的, 物理上通常是以数组和链式结构形式存储 比如: 顺序表 概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据 ...
动态场景的像素自适应和全局-局部过滤模块的高效运动去模糊
1用于自适应运动去模糊的MaitreyaSuinKuldeepPurohitN....尽管端到端全卷积设计最近在非均匀运动去模糊方面已经发展了最...现有方法通过增加通用卷积层的数量和内核大小来实现大的感受野，但这是以模型大小和推理速度的
"追踪互联簇的递减动态算法" - 李德贾 等
++SoftwareX 7（2018）273原始软件出版物一种追踪互联簇的递减动态算法Deokjae Leea，S. Hwangb，S. Choic，B. Kahnga，*a韩国首尔国立大学物理和天文学系，韩国首尔08826b科隆大学理论物理研究所，科隆，50937，...
动态多态和静态多态（C++）
takashi77的博客
10-03 3440
多态：即一个接口多种实现方式；C++中的多态分为两种：静态多态与动态多态 一、静态多态：也成为编译时的多态；在编译时期就已经确定要执行了的函数地址了；主要有函数重载和函数模板（这里只写函数重载） （1）函数重载 因为C++中确定执行的函数是根据函数名与函数的参数顺序、个数等来确定的，因此我们可以有多个同名的函数；例如我们现在有一个类中已经有了一个函数名为show无参的函数，我们在派生类中再写一个名为show但是带有一个参数的show函数，这叫函数重载也称为覆盖和重写； 测试代码： #include &l
多互一致性学习的人体运动分割
10277基于多互一致性的传输子空间学习的人体运动分割周涛1、傅华珠1、陈功2、沈建兵1、邵凌1、波里克利31Inception Institute of Artificial Intelligence，Abu Dhabi，UAE。2南京理工大学高维信息智能感知与系统...
自动微分算法的C99代码及其实现与物理模拟和几何处理相关的自动区分算法
软件X 17（2022）100901原始软件出版物ACORNS：一个易于使用的梯度和黑森的Deshana Desai1，Etai Shuchatowitz1，Zhongshi Jiang，Teseo Schneider，DanielePanozzo地址：60 5th Ave，New York，NY 10011ar t i cl e...
数据结构之动态顺序表（附带完整程序）
最新发布
2301_77203593的博客
07-26 788
int age;int height;} Student;//Student类型的数组 int length;//元素的有效个数 int listsize;//最多容纳多少个元素 } SqList;5int age;int height;} Student;//Student类型的数组 int length;//元素的有效个数 int listsize;//最多容纳多少个元素 } SqList;2int age;int height;} Student;
动态顺序表的实现
apt1203JN的博客
07-28 625
上次实现静态的顺序表，今天我们来实现一下动态的顺序表(动态开辟内存空间) SeqListD.h#ifndef __SEQLISTD_H__ #define __SEQLISTD_H__ #include <stdio.h> #include <assert.h> #include <string.h> #include <stdlib.h> #define DEFAULT_SZ 2 #define
【数据结构】动态顺序表和静态顺序表的对比(C语言)
Qingmou's_blog
09-19 2010
静态顺序表的定义 #define MAX_SIZE (100) typedef int DataType; typedef struct SeqList { DataType data[MAX_SIZE]; int size; } SeqListR; 动态顺序表的定义 typedef int DDataType; typedef struct { DDataTyp...
动态顺序表(C语言)
学代码的咸鱼的博客
03-28 3064
轻松带你搞定顺序表！
Verilog 序列信号发生器的三种设计思路
热门推荐
qq_38573940的博客
11-28 1万+
在数字电路中， 序列信号是指在同步脉冲作用下循环地产生一串周期性的二进制信号.能产生这种信号的逻辑器件就称为序列信号发生器.根据结构不同,它可分为反馈移位型和计数型两种。 移位型序列信号发生器是由移位寄存器和组合电路两部分构成，组合电路的输出，作为移位寄存器的串行输入。 　　计数型序列信号发生器能产生多组序列信号,这是移位型发生器所没有的功能.计数型序列信号发生器是由计数器和组合电路构成的。 　　本实验的目的就是设计一个序列信号发生器。设计产生序列11100100、11100100、···的计数型序列信号发
【数字电路】期末不挂科复习笔记
woodwhale的博客
06-21 1万+
【数字电路】期末不挂科复习笔记 数制与码制 1、将二进制转为十进制 从小数点向左，依次乘2的0次方，1次方…依次类推 2、将十进制转为二进制 将整数部分和小数部分分别转换即可 3、将二进制转为八进制 二进制先转十进制，再转八进制 4、将八进制转为二进制 八进制转十进制，再转二进制 5、将二进制转为十六进制 从小数点开始，四个一组，转为十进制 6、将十六进制转为二进制 十六进制先转为十进制，再转二进制 凑够四位，不够补0 总结 余3码就是8421码＋3 数字信号： 高电平是1，低电平是0 补码： 正数的源码和
Verilog学习笔记（3）:Verilog数字逻辑电路设计方法
ixue
09-23 1万+
verilog学习笔记；verilog知识总结；verilog考试知识点汇总；Verilog数字逻辑电路设计方法；数字加法器；数据比较器；数字编码器；数字译码器；奇偶校验器；时序电路；触发器；D触发器；带复位端D触发器；复杂功能D触发器；T触发器；计数器；二进制计数器；任意模数的计数器；移位寄存器；序列信号发生器；有限同步状态机
5分钟带你了解什么是顺序表，并用它写一个简单的增删查改(画图讲解,详细代码)
sjp11的博客
04-14 1939
顺序表的概念及结构 顺序表在数据结构中一种很重要的逻辑结构 ,它是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。也就是说，顺序表本质是一个数组，它的存储的数据从左向右必须是连续的。 顺序表的结构： 下面这种结构不是顺序表，因为数据不是连续的,5和6中间空了一块空间。 顺序表可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。 顺序表的静态的存储： #define N 100 typedef int SLDa
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值