数据结构——顺序表

最新推荐文章于 2024-04-05 23:32:07 发布
原创 最新推荐文章于 2024-04-05 23:32:07 发布 · 310 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#线性表——顺序存储

顺序表是一种线性表，采用物理地址连续的数组存储数据元素。包括静态顺序表（定长数组）和动态顺序表（动态内存开辟）。虽然便于随机存取，但增删操作时间复杂度高，可能导致内存浪费。

顺序表

顺序表从字面意思就能理解它的一个顺序存储的一种线性表，按物理地址连续的存储单元来存储数据元素，一般情况下是用数组来存储，因为数组中的元素是随机存取的，并且根据具体要求所需的增添和删除等的操作都是在数组里进行的。一般顺序表分为两种：
1.静态顺序表：使用定长数组存储。
2.动态顺序表：使用动态开辟的内存存储。
在这里插入图片描述

根据需要的动态分配大小，实现接口，代码如下：

顺序表代码

#ifndef _COMMON_H_
#define _COMMON_H_

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

typedef enum{FALSE, TRUE} BOOL;

#define DataType int

#define DEFAULT_SIZE 8
#define INC_SIZE      3


#endif /* _COMMON_H_ */

#ifndef _SEQLIST_H_
#define _SEQLIST_H_

#define NULL_DATA -1

typedef struct SeqList
{
	DataType *base;
	size_t    capacity;
	size_t    size;
}SeqList;

//内部方法
static BOOL _Inc(SeqList *psl);

BOOL SeqListIsFull(SeqList *psl);//是否满
BOOL SeqListIsEmpty(SeqList *psl);//是否空
void SeqListInit(SeqList* psl, size_t capacity);//初始化
void SeqListPushBack(SeqList* psl, DataType x);//尾插
void SeqListPushFront(SeqList* psl, DataType x);//头插
void SeqListShow(SeqList *psl);//展示表

void SeqListPopBack(SeqList* psl);//尾删
void SeqListPopFront(SeqList* psl);//头删
size_t SeqListLength(SeqList *psl);//长度
void SeqListClear(SeqList *psl);//清除
DataType SeqListFindByPos(SeqList *psl, int pos);//通过位置查找
int SeqListFindByVal(SeqList *psl, DataType key);//通过值查找

BOOL SeqListEraseByVal(SeqList *psl, DataType key);//通过值删除
BOOL SeqListEraseByPos(SeqList *psl, int pos);//按位置删除
BOOL SeqListInsertByPos(SeqList *psl, int pos, DataType x);//按位置插入
void SeqListReverse(SeqList *psl);//逆序

void SeqListRemoveAll(SeqList* psl, DataType x);//移除所有
void SeqListSort(SeqList *psl);//排序
void SeqListDestroy(SeqList *psl)//;摧毁表

BOOL _Inc(SeqList *psl)
{
	DataType *new_base = 
		(DataType *)malloc(sizeof(DataType)*(psl->capacity + INC_SIZE));
	if (new_base == NULL)
		return FALSE;
	
	memcpy(new_base, psl->base, sizeof(DataType)*psl->capacity);
	free(psl->base);

	psl->base = new_base;
	psl->capacity += INC_SIZE;
	return TRUE;
}

BOOL SeqListIsFull(SeqList *psl)
{
	if (psl->size >= psl->capacity)
		return TRUE;
	return FALSE;
}
BOOL SeqListIsEmpty(SeqList *psl)
{
	if (psl->size == 0)
		return TRUE;
	return FALSE;
}

////////////////////////////////////////////////////////////
void SeqListInit(SeqList* psl, size_t capacity)
{
	psl->base = (DataType*)malloc(sizeof(DataType)*capacity);
	assert(psl->base != NULL);
	psl->capacity = capacity;
	psl->size = 0;
}

void SeqListPushBack(SeqList* psl, DataType x)
{
	if (SeqListIsFull(psl) && !_Inc(psl))
	{
		printf("顺序表空间已满,%d不能插入.\n", x);
		return;
	}
	psl->base[psl->size++] = x;
}
void SeqListPushFront(SeqList* psl, DataType x)
{
	if (SeqListIsFull(psl) && !_Inc(psl))
	{
		printf("顺序表空间已满,%d不能插入.\n", x);
		return;
	}

	for (int i = psl->size; i > 0; --i)
	{
		psl->base[i] = psl->base[i - 1];
	}
	psl->base[0] = x;
	psl->size++;
}

void SeqListShow(SeqList *psl)
{
	for (int i = 0; i < psl->size; ++i)
	{
		printf("%d ", psl->base[i]);
	}
	printf("\n");
}

void SeqListPopBack(SeqList* psl)
{
	if (SeqListIsEmpty(psl))
	{
		printf("顺序表已空，不能删除.\n");
		return;
	}
	psl->size--;
}

void SeqListPopFront(SeqList* psl)
{
	if (SeqListIsEmpty(psl))
	{
		printf("顺序表已空，不能删除.\n");
		return;
	}
	for (int i = 0; i<psl->size-1; ++i)
	{
		psl->base[i] = psl->base[i + 1];
	}
	psl->size--;
}

size_t SeqListLength(SeqList *psl)
{
	return psl->size;
}

void SeqListClear(SeqList *psl)
{
	psl->size = 0;
}

DataType SeqListFindByPos(SeqList *psl, int pos)
{
	//assert(pos >= 0 && pos < psl->size);
	if (pos < 0 || pos >= psl->size)
	{
		printf("查询的位置无效.\n");
		return NULL_DATA;
	}
	return psl->base[pos];
}

int SeqListFindByVal(SeqList *psl, DataType key)
{
	for (int i = 0; i < psl->size; ++i)
	{
		if (key == psl->base[i])
			return i;
	}
	return -1;
}

BOOL SeqListEraseByPos(SeqList *psl, int pos)
{
	if (pos < 0 || pos >= psl->size)
		return FALSE;
	for (int i = pos; i < psl->size - 1; ++i)
		psl->base[i] = psl->base[i + 1];
	psl->size--;
	return TRUE;
}

BOOL SeqListEraseByVal(SeqList *psl, DataType key)
{
	int index = SeqListFindByVal(psl, key);
	if (index == -1)
		return FALSE;
	return SeqListEraseByPos(psl, index);
}

BOOL SeqListInsertByPos(SeqList *psl, int pos, DataType x)
{
	if (pos<0 || pos>psl->size)
		return FALSE;
	if (SeqListIsFull(psl) && !_Inc(psl))
	{
		printf("顺序表空间已满,%d不能插入.\n", x);
		return FALSE;
	}
	for (int i = psl->size; i > pos; --i)
		psl->base[i] = psl->base[i - 1];
	psl->base[pos] = x;
	psl->size++;
	return TRUE;
}

void SeqListReverse(SeqList *psl)
{
	if (psl->size >= 2)
	{
		int begin = 0;
		int end = psl->size - 1;
		while (begin < end)
		{
			Swap(&(psl->base[begin]), &(psl->base[end]));
			begin++;
			end--;
		}
	}
}

void SeqListRemoveAll(SeqList* psl, DataType x)
{
	for (int i = 0; i < psl->size; ++i)
	{
		if (x == psl->base[i])
		{
			for (int j = i; j < psl->size-1; ++j)
				psl->base[j] = psl->base[j + 1];
			psl->size--;
			i--;
		}
	}
}
void SeqListSort(SeqList *psl)
{
	for (int i = 0; i < psl->size - 1; ++i)
	{
		for (int j = 0; j < psl->size - i - 1; ++j)
		{
			if (psl->base[j] > psl->base[j + 1])
			{
				Swap(&(psl->base[j]), &(psl->base[j + 1]));
			}
		}
	}
}

void SeqListDestroy(SeqList *psl)
{
	free(psl->base);
	psl->base = NULL;
	psl->capacity = psl->size = 0;
}

/*
BOOL SeqListEraseByVal(SeqList *psl, DataType key)
{
	int index = SeqListFindByVal(psl, key);
	if (index == -1)
	return FALSE;

	for (int i = index; i < psl->size - 1; ++i)
	psl->base[i] = psl->base[i + 1];
	psl->size--;
	return TRUE;
}
*/

#endif /* _SEQLIST_H_ */

#include"common.h"
#include"seqlist.h"
int main(int argc, char *argv[])
{
	seqlist mylist;
	seqlistinit(&mylist, default_size);

	datatype item;
	int pos, index;
	bool flag;
	int select = 1;
	while (select)
	{
		printf("************************************\n");
		printf("* [1] push_back     [2] push_front *\n");
		printf("* [3] show_list     [0] quit_system*\n");
		printf("* [4] pop_back      [5] pop_front  *\n");
		printf("* [6] find_pos      [7] find_val   *\n");
		printf("* [8] insert_pos    [9] delete_val *\n");
		printf("* [10] delete_pos   [11]length     *\n");
		printf("* [12] remove_all   [13] reverse   *\n");
		printf("* [14] sort         [15] clear     *\n");
		printf("************************************\n");
		printf("请选择:>");
		scanf("%d", &select);
		if (select == 0)
			break;
		switch (select)
		{
		case 1:
			printf("请输入要插入的数据(以-1结束):>");
			while (scanf("%d", &item), item != -1)
			{
				seqlistpushback(&mylist, item);
			}
			break;
		case 2:
			printf("请输入要插入的数据(以-1结束):>");
			while (scanf("%d", &item), item != -1)
			{
				seqlistpushfront(&mylist, item);
			}
			break;
		case 3:
			seqlistshow(&mylist);
			break;
		case 4:
			seqlistpopback(&mylist);
			break;
		case 5:
			seqlistpopfront(&mylist);
			break;
		case 6:
			printf("请输入要查询的位置:>");
			scanf("%d", &pos);
			printf("要查询的数据:%d\n", seqlistfindbypos(&mylist, pos));
			break;
		case 7:
			printf("请输入要查询的数据:>");
			scanf("%d", &item);
			index = seqlistfindbyval(&mylist, item);
			if (index == -1)
				printf("要查询的数据%d不存在.\n", item);
			else
				printf("要查询数据的下标为:>%d\n", index);
			break;
		case 8:
			printf("请输入要插入的位置:>");
			scanf("%d", &pos);
			printf("请输入要插入的数据:>");
			scanf("%d", &item);
			flag = seqlistinsertbypos(&mylist, pos, item);
			if (flag)
				printf("插入成功.\n");
			else
				printf("插入失败.\n");
			break;
		case 9:
			printf("请输入要删除的数据:>");
			scanf("%d", &item);
			flag = seqlisterasebyval(&mylist, item);
			if (flag)
				printf("删除%d成功.\n", item);
			else
				printf("删除%d失败.\n", item);
			break;
		case 10:
			printf("请输入要删除的位置:>");
			scanf("%d", &pos);
			flag = seqlisterasebypos(&mylist, pos);
			if (flag)
				printf("删除成功.\n");
			else
				printf("删除失败.\n");
			break;
		case 11:
			printf("seqlist length = %d\n", seqlistlength(&mylist));
			break;
		case 12:
			printf("请输入要删除的数据:>");
			scanf("%d", &item);
			seqlistremoveall(&mylist, item);
			break;
		case 13:
			seqlistreverse(&mylist);
			break;
		case 14:
			seqlistsort(&mylist);
			break;
		case 15:
			seqlistclear(&mylist);
			break;
		}
	}

	seqlistdestroy(&mylist);
	return 0; 
}

线性表的不足和问题也很明显:
1.时间复杂度为o(n)
2.有不小的消耗
3.内存的浪费

数据结构 顺序表的定义
Exusiai_的博客
04-03 4375
文章目录1.2.1 顺序表的定义1.2.2 顺序表上基本操作的实现（1）顺序表的建立（2）顺序表元素的插入（3）顺序表元素的删除 1.2.1 顺序表的定义 1.2.2 顺序表上基本操作的实现 （1）顺序表的建立 （2）顺序表元素的插入 （3）顺序表元素的删除 （4）顺序表的查找 1.2.1 顺序表的定义 **定义：**顺序表是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使的逻辑上相邻的两个元素在物理位置上也相邻。 特点： 表中元素的逻辑顺序与物理顺序相同。 随机访问，即通过首地址和元素序号可
数据结构顺序表定义和实现
u010096443的专栏
03-30 1842
首先是顺序表的抽象数据类型的定义 // file: sequence.h #define MAXSIZE 100 // 定义顺序表最大的容量为100 typedef int datatype; //给int 取了个别名叫datatype typedef struct { datatype arr[MAXSIZE]; int size; }sequence; 接
数据结构顺序表的定义（Java）
c_yejiajun的博客
10-29 1411
定义顺序表的接口public interface ILinarList<E> { public abstract boolean add(E item); //添加元素 public abstract boolean add(int i,E item); //插入元素 public abstract E remove(int i);
数据结构-顺序表
weixin_53023816的博客
08-31 892
文章目录 一、顺序表的概念 1.顺序存储概念 二、顺序表的实现 1.静态顺序表的实现 (1).静态顺序表的概念 (2).静态顺序表的结构体定义 一、顺序表的概念 1.顺序存储概念 顺序存储结构，是指用一段地址连续的存储单元依次存储线性表的数据元素。 2.存储方式 在编程语言中，用一维数组来实现顺序存储，在c语言中，把第一个数据元素存储到下标为0的位置中...
精选资源
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
python数据结构——顺序表
fyire的博客
08-15 844
1. 顺序表的定义 数据元素连续存储，并且每个元素的存储空间大小相同，元素下标是逻辑地址，元素的物理地址可通过存储区的起始地址加上逻辑地址和存储单元大小来确定。 2. 顺序表的优点 由于元素的物理地址可通过存储区的起始地址加上逻辑地址和存储单元大小来确定，因此要访问一个元素不用做遍历操作，只需给定逻辑地址就可是实现访问。 计算物理地址的公式如下： 其中表示逻辑地址，表示第 给元素，表示存储区的起始地址， 表示每个元素存...
数据结构——顺序表（C语言）
最新发布
2302_81016149的博客
04-05 1554
这里说明一下：数据结构这方面主要是：数组、指针、结构体这方面内容，因此数据结构可以让我们更好的理解以上内容。我们实现顺序表一共会用两个源文件和一个头文件，具体为什么，扫雷里说过可自行查阅。//大家可想一想把int 命名成seqlist的好处seqlist* a;int size;//有效数据个数//总容量}sl;//结构体命名。
顺序表的基本操作（new）
傻红就是不爱跑步的博客
03-28 618
#include <stdio.h> #include <stdlib.h>#define MAXSIZE 20struct SeqList{ int data[MAXSIZE]; int len; };SeqList * initSeqlist(){ SeqList * L; L = (SeqList *)malloc(sizeof(SeqList)); L
数据结构---顺序表
blue_jun_的博客
04-22 1298
1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 1. 静态顺序表：使用定长数组存储元素 2. 动态顺序表：使用动态开辟的数组存储。 由于静态顺序表数组定长，所以存在数组过小不够用，数组过大空间浪费等问题。 所以我们一般使用动态顺序表，接下来我们就讲解一个动态顺序表的实现。 2.动态顺序表的实现 首先，创建一个项目，定义一个头文件“seqlist....
【数据结构】~顺序表
分享技术
08-14 1375
震惊学会顺序表! 此篇足已。
数据结构——顺序表（定义、实现）
weixin_62677583的博客
12-19 3407
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
《数据结构》--2.2-1顺序表的定义
Mr.Liu 的数据结构之路
10-23 384
《数据结构》--2.2-1顺序表的定义
数据结构--顺序表定义及python实现
xzfreewind的博客
07-08 4190
顺序表即线性表的顺序存储结构。它是通过一组地址连续的存储单元对线性表中的数据进行存储的，相邻的两个元素在物理位置上也是相邻的。比如，第1个元素是存储在线性表的起始位置LOC(1)，那么第i个元素即是存储在LOC(1)+(i-1)*sizeof(ElemType)位置上，其中sizeof(ElemType)表示每一个元素所占的空间。     下面是顺序表的python实现： #codi
数据结构-顺序表的定义及python实现
yanqianglifei的专栏
03-09 643
1 顺序表的定义 线性表 是具有相同数据类型的n个数据元素的有限序列。 顺序表 使用组地址连续的存储单元、依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。顺序表是线性表的顺序存储。 假设线性表L存储的起始位置为LOC(A),sizeof(ElemType)是每个数据元素所占用存储空间的大小，则表L所对应的顺序存储如下图所示...
顺序表new
CYD1231的博客
03-05 284
线性结构：有次序 String 为char 组合的线性结构 顺序表与链表区别： 1.顺序表：逻辑上线性且内存存储也为逻辑上次序保存 2.链表：逻辑上线性但内存存储时不一定连续 数组为不完备的线性表，它无法区分容量与数据个数，无法自行扩容 顺序表与数组不同： 容量：capacity 元素个数：size顺序表必须连续 boolean add(e) 相当于尾插，一定会返回true void add(index,e) 插入e到index位置，index取值范围为：【0，size】，取size为尾插 /*Arra
【数据结构初阶】顺序表
m0_70811813的博客
10-26 2317
顺序表的定义、顺序表的分类、动态顺序表的实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值