【数据结构】详解顺序表(图解)


一、顺序表的概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般采用数组存储,在数组上完成数组的增删查改操作。

顺序表可分为:

1.1、静态顺序表

静态顺序表是使用定长数组存储元素。空间小了,不够用,空间大了,浪费。所以静态顺序表不实用。

#define N 10
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType a[N]; // 定长数组
	int size; // 记录存储多少个数据
}SL;

1.2、动态顺序表

动态顺序表是使用动态开辟的数组存储

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a; // 指向动态开辟的数组
	int size; // 记录存储多少个有效数据
	int capacity; // 空间容量大小
}SL;

二、接口实现

由于静态顺序表不实用,所以现实中基本都是使用动态顺序表,下面我们来实现动态顺序表

2.1、开辟一个动态顺序表及初始化

1、开辟一个动态顺序表

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a; // 指向动态开辟的数组
	int size; // 记录存储多少个有效数据
	int capacity; // 空间容量大小
}SL;

在这里插入图片描述

2、顺序表的初始化

void SLInit(SL* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

将指向动态开辟的数组置为NULL。

2.2、顺序表的增容

先对空间进行判断,若空间为0,则先开辟空间,空间不够,再自动增加空间

代码实现:

void SLCheckCapacity(SL* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity*sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}

2.3、顺序表的尾插及尾删

1、顺序表的尾插

尾插即是向数组的尾部插入数据,先调用扩容函数SLCheckCapacity判断空间,当尾部空间不够时,就会自动扩容。

在这里插入图片描述

代码实现:

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	// 扩容
	SLCheckCapacity(ps);
	
	ps->a[ps->size] = x;
	ps->size++;
}

2、顺序表的尾删

尾删就是将数据从尾部开始删除

在这里插入图片描述

代码实现:

void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size > 0); // 检查数据是否为NULL
	ps->size--;
}

2.4、顺序表的头插及头删

1、顺序表的头插

顺序表头插就是从数组的起始位置开始插入数据。先判断空间,再把已有的数据向后挪动,然后在头部插入数据。

在这里插入图片描述
代码实现:

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	// 挪动数据
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}

	ps->a[0] = x;
	ps->size++;
}

2、顺序表的头删

顺序表的头删是从数组的起始位置删除数据。把起始位置之后的数据向前挪动,覆盖要删除的数据

在这里插入图片描述

代码实现:

void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

2.5、顺序表在pos处插入及删除数据

1、顺序表在pos处插入数据

顺序表在pos处插入数据是在数组中自定义位置插入数据。先判断空间,再把要插入数据位置之后的数据向后挪动,然后插入数据。

在这里插入图片描述
代码实现:

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

pox=ps->size,则函数SLInsert等价于尾插
pox=0,则函数SLInsert等价于头插

2、顺序表在pos处删除数据

顺序表在pos处删除数据是在数组中自定义位置删除数据。把自定义位置处的数据向前挪动,覆盖要删除的数据。

在这里插入图片描述
代码实现:

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->size);
	// 挪动数据覆盖
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

pox=ps->size-1,则函数SLInsert等价于尾删
pox=0,则函数SLInsert等价于头删

2.6、顺序表的销毁及打印

1、顺序表的销毁

由于动态顺序表开辟空间,所用的函数均是动态内存函数,所以使用完后需要释放空间

代码实现:

void SLDestroy(SL* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
		ps->a = NULL;
		ps->size = ps->capacity = 0;
	}
}

2、顺序表的打印
代码实现:

void SLPrint(SL* ps)
{
	assert(ps);

	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

2.7、顺序表的查找及修改

1、顺序表的查找

从begin处开始查找

代码实现:

int SLFind(SL* ps, SLDataType x, int begin)
{
	assert(ps);
	for (int i = begin; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}

	return -1;
}

2、顺序表的修改

把pos处的数据修改成x
代码实现:

void SLModify(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	ps->a[pos] = x;
}
  • 9
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
链表是一种常见的数据结构,用于存储一系列的元素。在Java中,链表可以使用LinkedList类来实现。下面是关于Java链表的详细解释: 链表由节点(Node)组成,每个节点包含两部分:数据域(存储元素的值)和指针域(指向下一个节点的指针)。链表的头节点是链表的起始点,尾节点是链表的结束点。 Java中的LinkedList类实现了List接口和Deque接口,因此可以用作列表和双端队列。LinkedList在内存中以链式结构存储元素,相邻元素通过节点的指针连接。 与数组相比,链表的一个优势是可以快速地插入和删除元素。由于链表中的元素在内存中不连续存储,所以插入和删除只需要改变指针的指向,而不需要移动其他元素。然而,链表的一个劣势是访问特定索引的元素比较慢,因为需要从头节点开始遍历链表。 下面是一些常用的操作示例: 1. 创建一个空链表: LinkedList<String> list = new LinkedList<>(); 2. 在链表末尾添加元素: list.add("A"); list.add("B"); list.add("C"); 3. 在指定位置插入元素: list.add(1, "D"); // 在索引为1的位置插入元素D 4. 获取链表的大小: int size = list.size(); 5. 获取指定索引位置的元素: String element = list.get(2); // 获取索引为2的元素 6. 修改指定索引位置的元素: list.set(0, "E"); // 将索引为0的元素修改为E 7. 删除指定索引位置的元素: list.remove(1); // 删除索引为1的元素 8. 遍历链表: for (String element : list) { System.out.println(element); } 需要注意的是,LinkedList类不是线程安全的,如果在多线程环境中使用链表,需要进行适当的同步处理。此外,由于链表中的元素不是连续存储,所以对于大量元素的访问和操作,可能会导致性能下降。在这种情况下,可以考虑使用ArrayList或其他更适合的数据结构

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

柒个葫芦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值