1. Toy模板网首页
  2. > Toy博客

【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表

7月前 作者：君落华 分类：Toy博客 阅读(38) 违法举报

这篇具有很好参考价值的文章主要介绍了【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

线性表

线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…。线性表在逻辑上是线性结构，也就是说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式的结构的形式存储。

线性表的概念：

  • 是n个具有相同元素特性的数据元素的有限序列。
  • 有穷性：一个线性表中的元素是有限的。
  • 一致性：一个线性表中所有的元素的性质相同。
  • 有序性：一个线性表中所有的元素之间的相对位置是线性的，即存在唯一的开始元素和终端元素，除此之外，每个元素都只有唯一的前驱元素和后继元素。各元素在线性表中的位置只取决于它们的序号，所以一个线性表中可以存在两个及以上的相同元素。

线性表的作用：

线性表一般用于存储有顺序关系的数列。最典型的例子就是为队列（先进先出）、栈（先进后出）。

线性表支持的操作：

  • **插入元素：**在线性表的指定位置插入一个元素，（insert、pushBack、pushFront等函数）。
  • **删除元素：**在线性表的指定位置删除一个元素，（pop、、popBack、popFront等函数）。
  • **访问元素：**访问线性表中指定位置的一个元素，（下标操作符[]等）。

线性表的逻辑结构图

【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构

顺序表

顺序表的概念：

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

顺序表的结构：

静态结构：使用定长数组存储

//静态顺序表
#define n 10

typedef int SLDataType;
typedef struct SeqList
{
	//定长数组
	SLDataType arr[n];
	//有效数据的个数
	int size;
}SeqList;

静态顺序表最大的缺陷就是，当数据存放满的时候就需要手动去增加，如果程序写成这样那会被骂死的，所以顺序有引入了动态顺序表。

动态结构：使用动态开辟的数组存储

//动态顺序表
typedef int SLDataType;

typedef struct SeqList
{
	//指向动态开辟的数组
	SLDataType* arr;
	//有效数据的个数
	int size;
	//容量空间的大小
	int capacity;
}SeqList;

当数组的空间满了，程序就会自动的扩容，这样相较与静态顺序表来说就灵活了很多，但是还是会造成空间浪费，后面我会讲一个更好的结构。

接口实现：

下面我们来用动态顺序表来实现对数据的增删查改。因为静态顺序表实用性不怎么强我这里就不演示了，直接开干动态顺序表：

首先就是初始化顺序表：
//顺序表的初始化
void SeqListInit(SeqList* ps)
{
	//断言传过来的指针是否为空
	assert(ps);
	//首先把指向数组的指针置空
	ps->arr = NULL;
	//在把有效数据个数置空
	ps->size = 0;
	//给容量付个初始值
	ps->capacity = 0;
}
对空间进行扩容：
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* ps)
{
	//对指针进行断言
	assert(ps);
	//判断空间是否为空或者数据满了
	if (ps->size==ps->capacity)
	{
		//定义一个变量来接收容量的值
		//当容量的值为0的时候直接赋值为4，不为空的时候直接*2
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		//创建一个指针来接收开辟的空间的地址
		SLDataType* pf = NULL;
		//使用realloc来开辟空间
		pf = (SLDataType*)realloc(ps->arr, newcapacity*sizeof(SLDataType));
		//检查是否开辟成功
		if (pf==NULL)
		{
			perror("realloc");
			//退出程序
			exit(-1);
		}
		//把开辟的空间的地址赋值个arr指针
		ps->arr = pf;
		//同时把新空间容量的大小赋值给结构中用来记录容量的值
		ps->capacity =newcapacity;
	}
}
打印顺序表：
// 顺序表打印
void SeqListPrint(SeqList* ps)
{
	//断言
	assert(ps);
	//通过循环打印
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	//换行
	printf("\n");
}
顺序表销毁：
// 顺序表销毁
void SeqListDestory(SeqList* ps)
{
	//断言
	assert(ps);
	//释放空间
	free(ps->arr);
	//然后把指针置空
	ps->arr = NULL;
	//把有效数据个数和容量空间的大小都置为0
	ps->capacity = 0;
	ps->size = 0;
}
顺序表尾插：

在尾插的时候要考虑两种情况：

  1. 当顺序表为空或者顺序表满的时候（调用空间扩容的接口）
  2. 正常的尾插
// 顺序表尾插
void SeqListPushBack(SeqList* ps, SLDataType x)
{
	//断言
	assert(ps);
	//对空间进行扩容
	CheckCapacity(ps);
	//把要插入的值插入顺序表
	ps->arr[ps->size] = x;
	//把记录有效数据个数的变量加1
	ps->size++;
	
}

在主函数中的代码：

#include"List.h"

void List1()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2); 
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	SeqListDestory(&sl);
}

int main()
{	
	List1();
	return 0;
}

以下是测试结果：
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构

顺序表尾删：
  • 只有顺序表中有数据的时候才能删除
  • 只有最后一个数据的时候就不删除了
// 顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	//断言指针是否为空
	assert(ps);
	//当只有size大于0的时候才能尾删
	assert(ps->size > 0);
	//尾删
	ps->size--;
}

测试运行结果：
测试的代码

void List1()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2); 
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	SeqListDestory(&sl);
}

运行结果：
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构
这就是断言起到的作用，当删除的数据太多的时候就会中止程序。
下面是正常删除的演示
测试代码：

void List1()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2); 
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	
	SeqListDestory(&sl);
}

运行结果：
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构

顺序表头插：
  1. 首先对顺序表进行扩容
  2. 把数据向后移动空出头的位置
  3. 把数据插入进去同时有效数据个数要加1

代码如下：

// 顺序表头插
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	//断言指针是否为空
	assert(ps);
	//扩容
	CheckCapacity(ps);
	//定义一个变量来接收顺序表中的有效个数
	int i = ps->size;
	//把数据向后移动空出头的位置
	while (i)
	{
		ps->arr[i] = ps->arr[i- 1];
		i--;
	}
	//给头的位置赋值
	ps->arr[0] = x;
	//然后有效数据个数加1
	ps->size++;
}

测试代码和运行结果：
测试代码：

void List2()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	SeqListPushFront(&sl, 0);
	SeqListPrint(&sl);
	SeqListDestory(&sl);
}

运行结果：
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构

顺序表头删：
  1. 控制顺序表中的数据个数大于0
  2. 把后面的数据向前移动

接口代码如下：

//顺序表头删
void  SeqListPopFront(SeqList* ps)
{
	//断言
	assert(ps);
	//控制size的值大于0
	assert(ps->size > 0);
	//定义一个变量来接收顺序表中的有效个数
	int i = 1;
	//把后面的数据向前移动
	while (i<ps->size)
	{
		ps->arr[i - 1] = ps->arr[i];
		i++;
	}
	//把有效数据减1
	ps->size--;
}

测试代码和运行结果：
测试代码：

void List3()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	SeqListPopFront(&sl);
	SeqListPrint(&sl);
	SeqListPopFront(&sl);
	SeqListPrint(&sl);	
	SeqListDestory(&sl);
}

运行结果：
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构

顺序表查找：
  1. 遍历所有的数据
  2. 找到相同的数据
  3. 返回下标
int SeqListFind(SeqList* ps, SLDataType x)
{
	//断言
	assert(ps);
	//遍历数据
	for (int i = 0; i < ps->size; i++)
	{
		//找到数据
		if (ps->arr[i]==x)
		{
			//返回下标
			return i;
		}
	}
	//没有找到返回-1
	return -1;
}
顺序表在pos位置插入x：
  1. 扩容
  2. 把pos位置之后的位置向后移动
  3. 然后再pos位置把数据插入顺序表中
  4. 有效数据个数加1
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDataType x)
{
	assert(ps);
	//扩容
	CheckCapacity(ps);
	assert(0 <= pos && pos <= ps->size);
	int begin = ps->size;
	//把pos之后的数据向后移动
	while (begin>pos)
	{
		
		ps->arr[begin] = ps->arr[begin-1];
		begin--;
	}
	ps->arr[pos] = x;
	ps->size++;

}

测试代码和运行结果：
测试代码：

void List4()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	printf("请输入插入的位置和数据：");
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int pos = SeqListFind(&sl, a);
	if (pos!=-1)
	{
		SeqListInsert(&sl, pos, b);
	}
	SeqListPrint(&sl);
	SeqListDestory(&sl);
}

运行结果：
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构

顺序表在pos位置删除：
  1. 控制顺序表中的数据个数
  2. 把pos位置之后的数据向前移动
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	//断言
	assert(ps);

	//控制数据个数
	assert(ps->size > 0);
	assert(0 <= pos && ps->size > pos);
	int begin = pos;
	//把pos之后的数据向前移动
	while (begin<ps->size)
	{
		ps->arr[begin] = ps->arr[begin + 1];
		begin++;
	}
	ps->size--;
}

测试代码和运行结果：
测试代码：

void List5()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	printf("请输入删除的数据：");
	int a = 0;
	scanf("%d", &a);
	int pos = SeqListFind(&sl, a);
	if (pos != -1)
	{
		SeqListErase(&sl, pos);
	}
	SeqListPrint(&sl);
	SeqListDestory(&sl);
}

运行结果：
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构

完整代码：

List.c文件代码：

#define _CRT_SECURE_NO_WARNINGS 1

#include"List.h"
//顺序表的初始化
void SeqListInit(SeqList* ps)
{
	//断言传过来的指针是否为空
	assert(ps);
	//首先把指向数组的指针置空
	ps->arr = NULL;
	//在把有效数据个数置空
	ps->size = 0;
	//给容量付个初始值
	ps->capacity = 0;
}

// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* ps)
{
	//对指针进行断言
	assert(ps);
	//判断空间是否为空或者数据满了
	if (ps->size==ps->capacity)
	{
		//定义一个变量来接收容量的值
		//当容量的值为0的时候直接赋值为4，不为空的时候直接*2
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		//创建一个指针来接收开辟的空间的地址
		SLDataType* pf = NULL;
		//使用realloc来开辟空间
		pf = (SLDataType*)realloc(ps->arr, newcapacity*sizeof(SLDataType));
		//检查是否开辟成功
		if (pf==NULL)
		{
			perror("realloc");
			//退出程序
			exit(-1);
		}
		//把开辟的空间的地址赋值个arr指针
		ps->arr = pf;
		//同时把新空间容量的大小赋值给结构中用来记录容量的值
		ps->capacity =newcapacity;
	}
}

// 顺序表打印
void SeqListPrint(SeqList* ps)
{
	//断言
	assert(ps);
	//通过循环打印
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	//换行
	printf("\n");
}

// 顺序表销毁
void SeqListDestory(SeqList* ps)
{
	//断言
	assert(ps);
	//释放空间
	free(ps->arr);
	//然后把指针置空
	ps->arr = NULL;
	//把有效数据个数和容量空间的大小都置为0
	ps->capacity = 0;
	ps->size = 0;
}

// 顺序表尾插
void SeqListPushBack(SeqList* ps, SLDataType x)
{
	//断言
	assert(ps);
	//对空间进行扩容
	CheckCapacity(ps);
	//把要插入的值插入顺序表
	ps->arr[ps->size] = x;
	//把记录有效数据个数的变量加1
	ps->size++;
	
}

// 顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	//断言指针是否为空
	assert(ps);
	//当只有size大于0的时候才能尾删
	assert(ps->size > 0);
	//尾删
	ps->size--;
}

// 顺序表头插
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	//断言指针是否为空
	assert(ps);
	//扩容
	CheckCapacity(ps);
	//定义一个变量来接收顺序表中的有效个数
	int i = ps->size;
	//把数据向后移动空出头的位置
	while (i)
	{
		ps->arr[i] = ps->arr[i- 1];
		i--;
	}
	//给头的位置赋值
	ps->arr[0] = x;
	//然后有效数据个数加1
	ps->size++;
}

//顺序表头删
void  SeqListPopFront(SeqList* ps)
{
	//断言
	assert(ps);
	//控制size的值大于0
	assert(ps->size > 0);
	//定义一个变量来接收顺序表中的有效个数
	int i = 1;
	//把后面的数据向前移动
	while (i<ps->size)
	{
		ps->arr[i - 1] = ps->arr[i];
		i++;
	}
	//把有效数据减1
	ps->size--;
}

// 顺序表查找
int SeqListFind(SeqList* ps, SLDataType x)
{
	//断言
	assert(ps);
	//遍历数据
	for (int i = 0; i < ps->size; i++)
	{
		//找到数据
		if (ps->arr[i]==x)
		{
			//返回下标
			return i;
		}
	}
	//没有找到返回-1
	return -1;
}

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDataType x)
{
	assert(ps);
	//扩容
	CheckCapacity(ps);
	assert(0 <= pos && pos <= ps->size);
	int begin = ps->size;
	//把pos之后的数据向后移动
	while (begin>pos)
	{
		
		ps->arr[begin] = ps->arr[begin-1];
		begin--;
	}
	ps->arr[pos] = x;
	ps->size++;

}

// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	//断言
	assert(ps);

	//控制数据个数
	assert(ps->size > 0);
	assert(0 <= pos && ps->size > pos);
	int begin = pos;
	//把pos之后的数据向前移动
	while (begin<ps->size)
	{
		ps->arr[begin] = ps->arr[begin + 1];
		begin++;
	}
	ps->size--;
}

List.h代码：

#pragma once

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

//静态顺序表
//#define n 10
//
//typedef int SLDataType;
//typedef struct SeqList
//{
//	//定长数组
//	SLDataType arr[n];
//	//有效数据的个数
//	int size;
//}SeqList;


//动态顺序表
typedef int SLDataType;

typedef struct SeqList
{
	//指向动态开辟的数组
	SLDataType* arr;
	//有效数据的个数
	int size;
	//容量空间的大小
	int capacity; 
}SeqList;

//顺序表的初始化
void SeqListInit(SeqList* ps);
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* ps);
// 顺序表打印
void SeqListPrint(SeqList* ps);
// 顺序表销毁
void SeqListDestory(SeqList* ps);
// 顺序表尾插
void SeqListPushBack(SeqList* ps, SLDataType x);
// 顺序表尾删
void SeqListPopBack(SeqList* ps);
// 顺序表头插
void SeqListPushFront(SeqList* ps, SLDataType x);
//顺序表头删
void  SeqListPopFront(SeqList* ps);
// 顺序表查找
int SeqListFind(SeqList* ps, SLDataType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

test.c文件代码：

#define _CRT_SECURE_NO_WARNINGS 1

#include"List.h"

void List1()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2); 
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);

	SeqListDestory(&sl);
}

void List2()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	SeqListPushFront(&sl, 0);
	SeqListPrint(&sl);
	SeqListDestory(&sl);
}

void List3()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	SeqListPopFront(&sl);
	SeqListPrint(&sl);
	SeqListPopFront(&sl);
	SeqListPrint(&sl);	
	SeqListDestory(&sl);
}

void List4()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	printf("请输入插入的位置和数据：");
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int pos = SeqListFind(&sl, a);
	if (pos!=-1)
	{
		SeqListInsert(&sl, pos, b);
	}
	SeqListPrint(&sl);
	SeqListDestory(&sl);
}
void List5()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	printf("请输入删除的数据：");
	int a = 0;
	scanf("%d", &a);
	int pos = SeqListFind(&sl, a);
	if (pos != -1)
	{
		SeqListErase(&sl, pos);
	}
	SeqListPrint(&sl);
	SeqListDestory(&sl);
}
int main()
{	
	List5();
	return 0;
}

力扣真题

移除元素：

题目如下：移除元素
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构
解题思路：

  1. 首先定义两个变量（用来当作下标）赋初始值为0；
  2. 然后要是不等于val
  3. 那么就把赋值给另一个下标的空间
  4. 否则就是直接把下标加1
  5. 返回的是另一个下标

代码如下：

int removeElement(int* nums, int numsSize, int val){
    //定义两个变量
    int src=0;
    int dest=0;
    //控制src的值不能越界
    while(src<numsSize)
    {
        //要是不等于就直接赋值
        if(nums[src]!=val)
        {
            nums[dest]=nums[src];
            dest++;
            src++;
        }
        else
        {
            src++;
        }
    }
    return dest;
}

题目如下：
删除有序数组中的重复项
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构
解题思路：
【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表,数据结构

  1. 首先创建两个变量来充当下标
  2. 然后把其中一个下标的初始值赋值为1，另一个为0
  3. 当两个下标指向的值不相等的时候就先把为0的下标加1，然后再把初始值为1的下标的值赋值个另一个下标
  4. 反之直接就第一个下标加1
  5. 返回的是第一个下标加1

代码如下：

int removeDuplicates(int* nums, int numsSize){
    int n=numsSize;
    int dst=0;
    int src=1;
    while(src<n)
    {
        if(nums[dst]!=nums[src])
        {
            nums[dst+1]=nums[src];
            dst++;
            src++;
        }
        else
        {
            src++;
        }
    }
    return dst+1;

}

以上就是我关于线性表中的顺序表的总结主要从顺序表的结构、顺序表的接口实现和力扣真题这3个方面进行总结，在线性表中不止有顺序表还有链表，下篇主要就是围绕顺序表来总结，希望这篇博客对大家有用。文章来源地址https://www.toymoban.com/news/detail-724314.html

到了这里，关于【数据结构——顺序表】线性表很难嘛？这篇文章能让你轻松掌握顺序表的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 数据结构 · 线性表 | 顺序表

    数据结构 · 线性表 | 顺序表

    啊我摔倒了..有没有人扶我起来学习.... 👱 个人主页： 《 C G o d 的 个 人 主 页 》 color{Darkorange}{《CGod的个人主页》} 《 C G o d 的 个 人 主 页 》 交个朋友叭~ 💒 个人社区： 《 编 程 成 神 技 术 交 流 社 区 》 color{Darkorange}{《编程成神技术交流社区》} 《 编 程 成 神 技 术

    2024年02月02日
    浏览(36)
  • 数据结构——线性表①（顺序表）

    数据结构——线性表①（顺序表）

    线性表是一种数据结构，它是由n个具有 相同数据类型 的数据元素a1,a2,…,an组成的 有限序列 。 其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。 线性表可以用 顺序存储结构 或 链式存储结构

    2024年02月06日
    浏览(40)
  • 数据结构：线性表之-顺序表

    数据结构：线性表之-顺序表

    目录 1.线性表概念 1.1 什么是顺序列表 1.2 线性表 2.顺序表实现 将有以下功能： 详细过程 顺序表的动态存储 顺序表初始化 尾插 扩容 头插 更改后的尾插 尾删 头删 打印 释放内存 优化顺序表 (任意位置插入删除) 优化后的头插尾插 优化后的头删尾删 查找和删除 进行装饰(菜单

    2024年02月10日
    浏览(33)

  • 数据结构---顺序表示的线性表

             数据结构(data structure)是带有结构特性的数据元素的集合，它研究的是数据的逻辑结构和数据的物理结构以及它们之间的相互关系，并对这种结构定义相适应的运算，设计出相应的算法，并确保经过这些运算以后所得到的新结构仍保持原来的结构类型。简言之，数据

    2024年02月16日
    浏览(41)
  • 数据结构: 线性表(顺序表实现)

    数据结构: 线性表(顺序表实现)

    线性表(linear list)是 n 个具有相同特性的数据元素的有序序列. 线性表是一种在实际中广泛使用的数据结构,常见的线性表: 顺序表,链表,栈,队列,字符串… 顺序表是用一段 物理地址连续 的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储.在数组上完成数据的增删

    2024年02月14日
    浏览(34)
  • C/C++数据结构---顺序表---线性存储结构

    C/C++数据结构---顺序表---线性存储结构

    个人主页： 仍有未知等待探索_小项目,洛谷刷题,数据结构-CSDN博客 专题分栏---数据结构： 数据结构_仍有未知等待探索的博客-CSDN博客 目录 一、知识储备 二、引例  三、顺序表 第一步，先创建一个顺序表类型 第二步，定义和初始化顺序表    第三步，顺序表的基本操作

    2024年02月08日
    浏览(28)
  • 数据结构——线性表之顺序表

    数据结构——线性表之顺序表

    目录 一.线性表 二.顺序表实现  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 修改函数 三.完整代码 四.力扣

    2024年02月07日
    浏览(27)
  • 数据结构（二）----线性表（顺序表，链表）

    数据结构（二）----线性表（顺序表，链表）

    目录 1.线性表的概念 2.线性表的基本操作 3.存储线性表的方式 （1）顺序表 •顺序表的概念 •顺序表的实现 静态分配： 动态分配： 顺序表的插入： 顺序表的删除： 顺序表的按位查找： 顺序表的按值查找： 顺序表的特点： （2）单链表 •单链表的实现 不带头结点的单链表

    2024年04月16日
    浏览(38)
  • 【数据结构】线性表之顺序表

    【数据结构】线性表之顺序表

    线性表是 n (n = 0) 个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表:顺序表、链表、栈、队列… 线性表在 逻辑上是线性结构 ，也就说是连续的一条直线。但是在 物理结构 上并 不一定 是连续的线性表在物理上存储时，通常以

    2024年02月04日
    浏览(39)
  • 【数据结构】线性表与顺序表

    【数据结构】线性表与顺序表

    ⭐ 作者：小胡_不糊涂 🌱 作者主页：小胡_不糊涂的个人主页 📀 收录专栏：浅谈数据结构 💖 持续更文，关注博主少走弯路，谢谢大家支持 💖 线性表（linear list） 是n个具有相同特性的数据元素的有限序列。 它是一种在实际中广泛使用的数据结构，常见的线性表：顺序表

    2024年02月07日
    浏览(32)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包