数据结构：顺序表

已于 2023-05-25 09:10:40 修改
阅读量731 收藏 13
点赞数 15
分类专栏： 数据结构与算法(C语言) 文章标签： 数据结构 c语言
于 2023-04-16 00:57:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yikefore/article/details/130167965
版权

朋友们、伙计们，我们又见面了，本期来给大家解读一下数据结构方面有关顺序表的相关知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！

C语言专栏：C语言：从入门到精通

数据结构专栏：数据结构

个人主页：stackY、

目录

1.线性表 

2.顺序表

2.1概念及结构 

2.2接口实现 

2.2.1初始化顺序表 

2.2.2释放顺序表 

2.2.3容量检查

2.2.4从尾部插数据

2.2.5从头部插入数据 

2.2.6从尾部删除数据 

2.2.7从头部删除数据 

2.2.8 指定位置插入数据

2.2.9 指定位置删除数据

 2.2.10优化插入、删除数据 

2.2.11查找数据 

2.2.12修改数据 

2.2.13打印顺序表 

2.2.14未优化的完整代码

2.2.15优化过后的完整代码 

2.3顺序表的问题及思考

1.线性表 

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...


线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储
 

2.顺序表

2.1概念及结构 

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表一般可以分为：

    1.静态顺序表：使用定长数组储存元素

//静态顺序表
#define N 5
typedef  int SLDataType;
typedef struct SeqList
{
	SLDataType a[N]; //定长数组 
	int Size;        //顺序表中的有效元素的个数
}SL;

   2. 动态顺序表：使用动态开辟的数组存储

//动态顺序表
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* a;  //指向动态开辟的数组
	int Size;       //有效元素的个数
	int Capactiy;	//容量
}SL;


 

2.2接口实现 

 静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。在动态顺序表中我们主要实现增删查改的功能，我们可以分板块来写，类似于通讯录的样式，这样方便使用，当然大家也可以在一个源文件中写，我们这里创建两个源文件：Test.c和SeqList.c，再创建一个头文件：SeqList.h,这里的文件命名不做要求，表示的有意义就行。同样的我们在Test.c中实现基本逻辑，在SeqList.c中实现顺序表的细节，在SeqList.h中进行函数声明和头文件包含等，话不多说，我们直接开始：

2.2.1初始化顺序表 

在初始化通讯录里面我们需要为顺序表动态开辟一块空间，然后初始给顺序表的容量为4，默认有效元素个数是0。

头文件：SeqList.h

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

//静态顺序表
//#define N 5
//typedef  int SLDataType;
//typedef struct SeqList
//{
//	SLDataType a[N]; //定长数组 
//	int Size;        //顺序表中的有效元素的个数
//}SL;

//动态顺序表
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* a;  //指向动态开辟的数组
	int Size;       //有效元素的个数
	int Capactiy;	//容量
}SL;

//初始化
void SLInit(SL* ps);

源文件：Test.c

#include "SeqList.h"
//   数据结构————顺序表

int main()
{
	SL s;
	//初始化
	SLInit(&s);
    return 0;
}

源文件：SeqList.c

#include "SeqList.h"

//初始化
void SLInit(SL* ps)
{
    assert(ps);
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);  //由于类型重新命名了，我们直接用即可
	if (ps->a == NULL)
	{
		perror("malloc fail:");
		return;
	}
	ps->Size = 0;
	ps->Capactiy = 4;  //默认是4个容量
}

2.2.2释放顺序表 

 释放顺序表指的就是把为顺序表动态开辟的空间释放掉，将有效的元素个数和顺序表的容量都置为0。

头文件：SeqList.h

//释放
void SLDestroy(SL* ps);

源文件：Test.c

#include "SeqList.h"
//   数据结构————顺序表

int main()
{
	SL s;
	//初始化
	SLInit(&s);
	
	//释放
	SLDestroy(&s);
	return 0;
}

源文件：SeqList.c

//释放
void SLDestroy(SL* ps)
{
    assert(ps);
	free(ps->a);   //释放
	ps->a = NULL;  //释放之后一定要置为NULL
	ps->Size = 0;  //有效元素个数置为0
	ps->Capactiy = 0; //容量置为0
}

2.2.3容量检查

容量检查就是要检查顺序表中有效元素的个数是否达到了顺序表的最大容量，如果等于最大容量，那么就表示满了、放不下了，就需要进行扩容，那怎么扩容呢？

由于我们的顺序表是由malloc开辟来的，所以可以通过realloc 来进行扩容，我们这里就规定每次扩容至原空间的2倍：

头文件：SeqList.h

//容量检测
void SLCheckCapactiy(SL* ps);

源文件：SeqList.c

//检测容量
void SLCheckCapactiy(SL* ps)
{
    assert(ps);

	if (ps->Size == ps->Capactiy) //有效元素个数等于顺序表的容量之后
	{
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->Capactiy * 2);
		if (tmp == NULL)
		{
			perror("realloc fail:");
			return;
		}
		ps->a = tmp;  //将扩充之后的空间再赋给原空间
		ps->Capactiy *= 2;  //容量扩容值2倍
	}
}

2.2.4从尾部插数据

 从尾部插入数据就比较简单了，首先要进行容量检查，然后就是将要插入的放在顺序表中下标为Size的位置上，放完之后需要对Size进行加一。

头文件：SeqList.h

//尾插
void SLPushBack(SL* ps, SLDataType num);

源文件：SeqList.c

//尾插
void SLPushBack(SL* ps, SLDataType num)
{
	SLCheckCapactiy(ps);
	ps->a[ps->Size] = num;  //将要插入的数据放在最后面
	ps->Size += 1;
}

2.2.5从头部插入数据 

从头部插入数据首先还是要进行容量检查，然后就是将数据放在顺序表中下标为0的位置上， 然后将数据依次向后面挪动一个位置，在这里的挪动就有说法了，是从前面的开始挪还是从后面的开始挪呢？答案是从后面的开始挪，如果你从前面开始挪，那你把你挪动的数据放在下一个位置上面是不是把它覆盖掉了，所以我们需要从后面的开始挪动：

头文件：SeqList.h

//头插
void SLPushFront(SL* ps, SLDataType num);

源文件：SeqList.c

//头插
void SLPushFront(SL* ps, SLDataType num)
{
	SLCheckCapactiy(ps);
	int end = ps->Size - 1;  //注意这里的判断条件不唯一，是根据end的值来进行判断
                             //可以进行画图来区分
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[0] = num;   //将要插入的数据放在顺序表的头部
	ps->Size++;
}

2.2.6从尾部删除数据 

 从尾部删除数据就更加简单了，首先我们得检查我们的顺序表中是否有元素，有元素才可以进行删除，没有元素删不了，所以可以将顺序表的有效元素个数进行断言，删除尾部元素最简单的方法就是直接对有效元素的个数进行减1，因为顺序表就相当于数组嘛，我们是通过数组的下标来进行访问数组，所以直接将顺序表的有效元素减一之后就访问不到最后一个元素了，这不也就达到了我们所想要的效果了嘛，当然有的老铁会想到将最后一个元素改为0，但是如果最后一个元素本来就是0呢？因此最简单有效的方法就是我们直接对顺序表的有效元素的个数减一就可以达到我们从尾部删除数据的效果。

头文件：SeqList.h

//尾删
void SLPopBack(SL* ps);

源文件：SeqList.c

//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->Size > 0);  //判断是否存在数据
	ps->Size--;
}

2.2.7从头部删除数据 

从头部删除数据就是将顺序表中下标为0的数据删掉，那我们可以直接进行覆盖，这里的覆盖也有门道了，我们是从前面开始挪呢？还是从后面开始挪呢？答案是从前面开始依次向前挪动一个位置，这里要注意，如果从后面依次开始挪动，那么最后面的数据挪到前面会将前一个数据覆盖掉 ，这样就达不到我们预期的效果了，当然了，在删除之前我们也需要进行判断顺序表中是否有数据，删除成功之后需要将我们的有效元素个数减一。

头文件：SeqList.h

//头删
void SLPopFront(SL* ps);

源文件：SeqList.c

//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->Size > 0);  //判断是否存在数据
	int start = 0;
	while (start < ps->Size - 1)  //判断条件还是需要进行画图来观察，切记不要越界访问
	{
		ps->a[start] = ps->a[start + 1];
		start++;
	}
	ps->Size--;
}

2.2.8 指定位置插入数据

将数据插入顺序表中下标为pos的位置上，首先呢我们需要进行容量检查，然后再判断pos的合法性，是否在0~Size之间，如果是0那么就代表头插，如果是Size就代表尾插，所以在这里我们还是需要进行挪动数据，腾出地方来让我们插入数据，所以呢，就需要将pos位置后面的数据依次挪动一个位置，这里注意需要从后面开始挪动，以防数据被覆盖掉，挪动之后将数据放在pos的位置上，然后顺序表的有效元素个数加1。

 头文件：SeqList.h

//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDataType num);

源文件：SeqList.c

//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDataType num)
{
	SLCheckCapactiy(ps); //容量检测
	assert(pos >= 0 && pos <= ps->Size);  //判断pos位置的合法性
	//挪动
	int end = ps->Size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = num;  //插入数据
	ps->Size++;
}

2.2.9 指定位置删除数据

在指定位置删除数据就直接挪动覆盖就好了，所以呢我们需要先进行pos的合法性检查，是否在0~Size之间，如果是0那么就代表头删，如果是Size就代表尾删，在这里的挪动也是需要先从前面的开始挪动，在删除成功之后就将顺序表的有效元素个数减1。

 头文件：SeqList.h

//在pos位置删除数据
void SLErase(SL* ps, int pos);

源文件：SeqList.c

//在pos位置删除数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->Size);  //判断pos位置的合法性
	int start = pos;
	while (start < ps->Size)
	{
		ps->a[start] = ps->a[start + 1];
		start++;
	}
	ps->Size--;
}

 2.2.10优化插入、删除数据 

 当我们写出了从指定位置插入或删除数据的时候，我们可以发现，当我们指定的位置是0和Size的时候就表示从顺序表的头部和尾部进行插入或删除，因此我们可以直接在头插、头删、尾插、尾删中套用SLInsert和SLErase这两个函数，在传参的时候直接传递0或Siez即可。

源文件：SeqList.c

//尾插
void SLPushBack(SL* ps, SLDataType num)
{
	
	SLInsert(ps, ps->Size - 1, num);

}


//头插
void SLPushFront(SL* ps, SLDataType num)
{
	
	SLInsert(ps, 0, num);
}

//尾删
void SLPopBack(SL* ps)
{
	
	SLErase(ps, ps->Size - 1);

}

//头删
void SLPopFront(SL* ps)
{
	
	SLErase(ps, 0);
}

//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDataType num)
{
	SLCheckCapactiy(ps); //容量检测
	assert(pos >= 0 && pos <= ps->Size);  //判断pos位置的合法性
	//挪动
	int end = ps->Size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = num;  //插入数据
	ps->Size++;
}

//在pos位置删除数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->Size);  //判断pos位置的合法性
	int start = pos;
	while (start < ps->Size)
	{
		ps->a[start] = ps->a[start + 1];
		start++;
	}
	ps->Size--;
}

2.2.11查找数据 

 查找顺序表中的某一个数据，如果查找成功就返回它的下标，如果查找失败就返回-1，所以我们需要遍历一下顺序表进行查找。

 头文件：SeqList.h

//查找数据
int SLFind(SL* ps, SLDataType num);

源文件：SeqList.c

//查找数据
int SLFind(SL* ps, SLDataType num)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->Size; i++)
	{
		if (ps->a[i] == num)
		{
			return i;
		}
	}
	return -1;
}

2.2.12修改数据 

修改数据就更加简单了，直接将pos位置的数据进行赋值你所要改的值，所以先要进行对pos的合法性检查，然后再修改。

 头文件：SeqList.h

//修改数据
void SLModify(SL* ps, int pos, SLDataType num);

源文件：SeqList.c

//修改数据
void SLModify(SL* ps, int pos, SLDataType num)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->Size);
	ps->a[pos] = num;
}

2.2.13打印顺序表 

打印顺序表和打印数组一模一样，通过有效元素个数来控制打印次数。

头文件：SeqList.h

//打印
void SLPrint(SL* ps);

源文件：SeqList.c

//打印
void SLPrint(SL* ps)
{
	assert(ps);

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

2.2.14未优化的完整代码

这里指的是没有优化插入和删除数据的代码：

源文件：Test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "SeqList.h"
//   数据结构————顺序表

int main()
{
	SL s;
	//初始化
	SLInit(&s);
	
	//在这里可以加上增添、查找、删除、修改等函数的调用
	//...
	//...
	//...
	
	//打印
	SLPrint(&s);
	//释放
	SLDestroy(&s);
	return 0;
}

 头文件：SeqList.h

#pragma once


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


//静态顺序表
//#define N 5
//typedef  int SLDataType;
//typedef struct SeqList
//{
//	SLDataType a[N]; //定长数组 
//	int Size;        //顺序表中的有效元素的个数
//}SL;

//动态顺序表
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* a;  //指向动态开辟的数组
	int Size;       //有效元素的个数
	int Capactiy;	//容量
}SL;

//初始化
void SLInit(SL* ps);
//释放
void SLDestroy(SL* ps);
//容量检测
void SLCheckCapactiy(SL* ps);


//尾插
void SLPushBack(SL* ps, SLDataType num);
//头插
void SLPushFront(SL* ps, SLDataType num);
//尾删
void SLPopBack(SL* ps);
//头删
void SLPopFront(SL* ps);

//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDataType num);

//在pos位置删除数据
void SLErase(SL* ps, int pos);

//查找数据
int SLFind(SL* ps, SLDataType num);

//修改数据
void SLModify(SL* ps, int pos, SLDataType num);

//打印
void SLPrint(SL* ps);

源文件：SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

//初始化
void SLInit(SL* ps)
{
	assert(ps);

	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);  //由于类型重新命名了，我们直接用即可
	if (ps->a == NULL)
	{
		perror("malloc fail:");
		return;
	}
	ps->Size = 0;
	ps->Capactiy = 4;  //默认是4个容量
}

//释放
void SLDestroy(SL* ps)
{
	assert(ps);

	free(ps->a);   //释放
	ps->a = NULL;  //释放之后一定要置为NULL
	ps->Size = 0;  //有效元素个数置为0
	ps->Capactiy = 0; //容量置为0
}


//检测容量
void SLCheckCapactiy(SL* ps)
{
	assert(ps);
	if (ps->Size == ps->Capactiy) //有效元素个数等于顺序表的容量之后
	{
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->Capactiy * 2);
		if (tmp == NULL)
		{
			perror("realloc fail:");
			return;
		}
		ps->a = tmp;  //将扩充之后的空间再赋给原空间
		ps->Capactiy *= 2;  //容量扩容值2倍
	}
}

//尾插
void SLPushBack(SL* ps, SLDataType num)
{
	SLCheckCapactiy(ps);
	ps->a[ps->Size] = num;
	ps->Size += 1;

}


//头插
void SLPushFront(SL* ps, SLDataType num)
{
	SLCheckCapactiy(ps);
	int end = ps->Size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[0] = num;
	ps->Size++;
}

//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->Size > 0);  //判断是否存在数据
	ps->Size--;

}

//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->Size > 0);  //判断是否存在数据
	int start = 0;
	while (start < ps->Size - 1)
	{
		ps->a[start] = ps->a[start + 1];
		start++;
	}
	ps->Size--;
}

//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDataType num)
{
	SLCheckCapactiy(ps); //容量检测
	assert(pos >= 0 && pos <= ps->Size);  //判断pos位置的合法性
	//挪动
	int end = ps->Size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = num;  //插入数据
	ps->Size++;
}

//在pos位置删除数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->Size);  //判断pos位置的合法性
	int start = pos;
	while (start < ps->Size)
	{
		ps->a[start] = ps->a[start + 1];
		start++;
	}
	ps->Size--;
}

//查找数据
int SLFind(SL* ps, SLDataType num)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->Size; i++)
	{
		if (ps->a[i] == num)
		{
			return i;
		}
	}
	return -1;
}

//修改数据
void SLModify(SL* ps, int pos, SLDataType num)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->Size);
	ps->a[pos] = num;
}

//打印
void SLPrint(SL* ps)
{
	assert(ps);

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

2.2.15优化过后的完整代码 

 这里是优化过插入和删除数据的代码：

源文件：Test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "SeqList.h"
//   数据结构————顺序表

int main()
{
	SL s;
	//初始化
	SLInit(&s);
	
	//在这里可以加上增添、查找、删除、修改等函数的调用
	//...
	//...
	//...
	
	//打印
	SLPrint(&s);
	//释放
	SLDestroy(&s);
	return 0;
}

 头文件：SeqList.h

#pragma once


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


//静态顺序表
//#define N 5
//typedef  int SLDataType;
//typedef struct SeqList
//{
//	SLDataType a[N]; //定长数组 
//	int Size;        //顺序表中的有效元素的个数
//}SL;

//动态顺序表
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* a;  //指向动态开辟的数组
	int Size;       //有效元素的个数
	int Capactiy;	//容量
}SL;

//初始化
void SLInit(SL* ps);
//释放
void SLDestroy(SL* ps);
//容量检测
void SLCheckCapactiy(SL* ps);


//尾插
void SLPushBack(SL* ps, SLDataType num);
//头插
void SLPushFront(SL* ps, SLDataType num);
//尾删
void SLPopBack(SL* ps);
//头删
void SLPopFront(SL* ps);

//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDataType num);

//在pos位置删除数据
void SLErase(SL* ps, int pos);

//查找数据
int SLFind(SL* ps, SLDataType num);

//修改数据
void SLModify(SL* ps, int pos, SLDataType num);

//打印
void SLPrint(SL* ps);

源文件：SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

//初始化
void SLInit(SL* ps)
{
	assert(ps);

	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);  //由于类型重新命名了，我们直接用即可
	if (ps->a == NULL)
	{
		perror("malloc fail:");
		return;
	}
	ps->Size = 0;
	ps->Capactiy = 4;  //默认是4个容量
}

//释放
void SLDestroy(SL* ps)
{
	assert(ps);

	free(ps->a);   //释放
	ps->a = NULL;  //释放之后一定要置为NULL
	ps->Size = 0;  //有效元素个数置为0
	ps->Capactiy = 0; //容量置为0
}


//检测容量
void SLCheckCapactiy(SL* ps)
{
	assert(ps);
	if (ps->Size == ps->Capactiy) //有效元素个数等于顺序表的容量之后
	{
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->Capactiy * 2);
		if (tmp == NULL)
		{
			perror("realloc fail:");
			return;
		}
		ps->a = tmp;  //将扩充之后的空间再赋给原空间
		ps->Capactiy *= 2;  //容量扩容值2倍
	}
}

//尾插
void SLPushBack(SL* ps, SLDataType num)
{
	SLInsert(ps, ps->Size - 1, num);
}


//头插
void SLPushFront(SL* ps, SLDataType num)
{
	SLInsert(ps, 0, num);
}

//尾删
void SLPopBack(SL* ps)
{
	SLErase(ps, ps->Size - 1);
}

//头删
void SLPopFront(SL* ps)
{
	SLErase(ps, 0);
}

//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDataType num)
{
	SLCheckCapactiy(ps); //容量检测
	assert(pos >= 0 && pos <= ps->Size);  //判断pos位置的合法性
	//挪动
	int end = ps->Size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = num;  //插入数据
	ps->Size++;
}

//在pos位置删除数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->Size);  //判断pos位置的合法性
	int start = pos;
	while (start < ps->Size)
	{
		ps->a[start] = ps->a[start + 1];
		start++;
	}
	ps->Size--;
}

//查找数据
int SLFind(SL* ps, SLDataType num)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->Size; i++)
	{
		if (ps->a[i] == num)
		{
			return i;
		}
	}
	return -1;
}

//修改数据
void SLModify(SL* ps, int pos, SLDataType num)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->Size);
	ps->a[pos] = num;
}

//打印
void SLPrint(SL* ps)
{
	assert(ps);

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

注意：

1.这些函数在这里就不使用案例来测试了，大家有兴趣可以自己动手来敲一敲，熟能生巧！

2.在顺序表的一些操作中是需要通过画图来判断它的限制条件，一定要画图！一定要画图！一定要画图！ 

2.3顺序表的问题及思考

问题：
1. 中间/头部的插入删除，时间复杂度为O(N)。


2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。


3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

思考：

如何解决这些问题呢？这时就需要用到我们的链表啦，关于链表的知识我们下期再聊。

朋友们、伙计们，美好的时光总是短暂的，我们本期的的分享就到此结束，欲知后事如何，请听下回分解~，最后看完别忘了留下你们弥足珍贵的三连喔，感谢大家的支持！

stackY、
关注
  • 15
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
数据结构：顺序表的实现——C语言描述
qq_43825377的博客
11-13 813
顺序表顺序表的概念定义顺序表的结构基本操作初始化顺序表尾部插入元素头部插入元素尾部删除元素头部删除元素打印顺序表的元素查找元素按位置插入元素按位置删除元素完整代码 顺序表的概念 顺序表是指用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。 顺序表一般可分为静态顺序表（使用定长数组存储）和动态顺序表（使用动态开辟的数组存储），这里我们只为大家分享动态顺序表的创建以及相关操作。 1.顺序表的静态存储： #define N 100 typedef int ElemType; typ
数据结构-C语言描述：顺序表
小二温华
11-23 587
数据结构的开端 数据结构分为线性结构和非线性结构，线性结构就是指数据中的元素仅存在一对一的逻辑关系，只有一个直接前驱和一个直接后继，当然最开始的元素只有后继，最后面的元素只有前驱。 线性结构包括：线性表（顺序表和链表），栈，队列，串 非线性结构包括：树，图 对于不同的数据结构，常常存在不同的存储或算法上的问题，要求我们灵活应对，熟记应对这些问题已有的高效而便捷的方法。本篇的主题为顺序表。 顺序表的...
数据结构之顺序表概念篇
qq_30235073的博客
05-27 429
我们如何用Python中的类型来保存一个公司的客户信息？ 如果想要快速的通过客户姓名获取其信息呢？ 实际上当我们在思考这个问题的时候，我们已经用到了数据结构。列表和字典都可以存储一个班的客户信息，但是想要在列表中获取一名user的信息时，就要遍历这个列表，其时间复杂度为O(n)，而使用字典存储时，可将客户姓名作为字典的键，客户信息作为值，进而查询时不需要遍历便可快速获取到客户信息，其时间复杂...
数据结构顺序表概念
CoderMateng的博客
03-22 506
顺序表： 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 顺序表又可分为： 静态顺...
PTA—C语言数据结构：顺序表.ppt
10-11
PTA平台数据结构课程顺序表参考答案
数据结构：顺序表（链式存储）
12-07
使用c实现数据结构中的顺序表（链式存储）： 功能： 1、头节点的创建 2、判断链表是否是 空\满 3、计算链表节点个数 4、插入节点（按 下标\元素） 5、删除节点（按 下标\元素） 6、按元素查询下标 7、打印链表 8、...
头歌数据结构顺序表的基本操作1-6关
05-18
头歌数据结构顺序表的基本操作1-6关 第1关：顺序表的插入操作 第2关：顺序表的删除操作 第3关：顺序表的按照序号查找值操作 第4关：顺序表的按照值查找序号操作 第5关：顺序表的逆置操作 第6关：两个有序顺序表的...
实验一：顺序表基本操作
03-03
在该实验中，学生需要完成并实现顺序表的基本操作，包括初始化顺序表、在顺序表前端和后端插入元素、显示顺序表中的数据、求顺序表的长度、删除顺序表中的元素等。 一、实验目的 掌握线性表中元素的前驱、后继的...
数据结构实验 顺序表和链表
最新发布
10-08
1. 创建顺序表：CreateList 函数用于创建顺序表，需要传入元素数组和数组长度。 2. 初始化顺序表：InitList 函数用于初始化顺序表，分配存放线性表的空间并将长度设置为 0。 3. 销毁顺序表：DestroyList 函数用于...
数据结构之基础概念,顺序表,链表
Charlson_S的博客
09-18 422
数据概念 数据：对于客观事物的符号表示 数据对象：性质相同的数据元素的集合 （数组，链表） 数据元素：数据的基本单位 数据项：一个数据元素由若干个数据项组成 数据结构：研究一个个数据元素之间的关系（数组/链表/树/图） 数据的物理结构亦称为存储结构，可分为顺序，链式，索引，散列。 判断一个算法的效率，往往只需要关注操作数量的最高次项，其它次要和常数项可忽略 大O表示法： 常见时间复杂度： 时间换空间的案例： 找出数组中一个数字出现次数最多的数字。 思路1：两层for循环找出出现最多的数字和次数，时间
数据结构---顺序表
blue_jun_的博客
04-22 907
1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 1. 静态顺序表：使用定长数组存储元素 2. 动态顺序表：使用动态开辟的数组存储。 由于静态顺序表数组定长，所以存在数组过小不够用，数组过大空间浪费等问题。 所以我们一般使用动态顺序表，接下来我们就讲解一个动态顺序表的实现。 2.动态顺序表的实现 首先，创建一个项目，定义一个头文件“seqlist....
数据结构之顺序表
qq_53822523的博客
05-27 2315
数据结构顺序表之增删查改的最全攻略
数据结构和顺序表的基本概念
q23445676的博客
07-21 200
顺序表(数组)可以实现随机访问(有了顺序表中数组的下标，就可以随机访问)structnode_t*next;structstudentdata[100];a顺序表的长度是固定（因为顺序表的本质是操作的数组）(1)逻辑结构是线性结构，存储结构是顺序存储结构，在内存当中是连续存储的。(2)顺序表优点查找方便，因为可以通过数组的下标，直接访问元素。顺序存储结构内存当中是连续存储的。1.逻辑结构数据之间的联系和规律(关系)网状关系多对多图状结构。一.数据结构数据的逻辑结构存储结构及操作。...
【数据结构】——顺序表介绍（独家介绍，小白必看！！）
yakiyakiya的博客
09-04 8894
数据结构入门级别的线性表——顺序表，内含独家理解，讲解详细，满满干货，放心食用！
数据结构（一）：顺序表详解
taduanlangan的博客
08-12 1915
/ 顺序表数据类型// 指向动态开辟的数组int size;// 有效数据个数// 容量}SL;
【数据结构——表】
weixin_64993156的博客
03-02 578
顺序表和链表的逻辑结构都是线性结构，都属于线性表，但是二者的存储结构不同，顺序表采用顺序存储，顺序存储的优点就是可以随机存放，存储密度高，缺点就是需要大片连续空间的分配不方便，改变容量不方便，然而链表采用的是链式存储，链式存储的优点就是离散的小空间分配方便，改变容量方便，缺点就是不可以随机存放，并且由于分配的空间不仅需要存放数据元素，还需要有一定的空间来存放指针，所以存储密度低。由于采用不同的存储方式来实现，因此基本操作的实现也不同
【数据结构】顺序表详解
胡坚涛的博客
11-11 1561
数据结构之顺序表详解
数据结构之顺序表详尽教程
qq_55411982的博客
09-17 494
这篇文章介绍了顺序表（Sequential List）这一经典的线性数据结构。顺序表以连续的方式存储元素，允许高效的随机访问，适用于各种应用场景。文章包括了顺序表的定义、初始化、插入、删除、访问、遍历等操作示例，以及一些常见的应用场景。虽然顺序表具有高效的随机访问能力，但插入和删除操作的复杂度较高，需要权衡使用场景。总而言之，这篇文章为初学者提供了有关顺序表的基本理解和实际操作的入门指南。
数据结构实验指导书C语言版
05-11
"数据结构实验指导书C语言版主要涵盖了线性表的顺序存储结构——顺序表的操作，包括建立、插入、删除和查找等基本操作。实验旨在通过C语言编程实现，让学生掌握顺序表的表示和实现方法，熟悉相关算法，并进行实际...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

stackY、

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

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

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

打赏作者

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

抵扣说明：

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

余额充值