首页 > 资讯 > 后端开发 > 其他教程 >C语言超详细讲解顺序表的各种操作

879

分享到

C语言超详细讲解顺序表的各种操作

2024-04-02 19:04:59 879人浏览独家记忆

摘要

目录顺序表是什么顺序表的结构体顺序表的接口函数顺序表相关操作的菜单顺序表的初始化添加元素陈列元素往最后加元素往前面加元素任意位置加元素删除最后元素删除前面元素删除任意元素

顺序表是什么
顺序表的结构体
顺序表的接口函数
顺序表相关操作的菜单
顺序表的初始化
添加元素
陈列元素
往最后加元素
往前面加元素
任意位置加元素
删除最后元素
删除前面元素
删除任意元素
整体代码(fun.h部分)
整体代码(fun.cpp部分)
整体代码(主函数部分)
结果展示

顺序表是什么

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

总的来说，顺序表类似于数组，下标对应的是相应的元素（如图所示）

顺序表的结构体

typedef struct
{
	SLDataType *a;
	int size;//表示数组中存储了多少个数据
	int capacity;//数组实际存储数据的空间容量是多大
}SL;

其中的SLDataType*a的意思是可以动态开辟空间--相当于数组，因为数组表示的是首元素的地址，这里是直接换成了指针，也指的是地址和数组的意思一样！

typedef int SLDataType;//重命名，到时候方便更改类型

顺序表的接口函数

void menu();//菜单
void SeqListInit(SL*ps);//初始化
void SeqListPushBack(SL*ps, SLDataType x);//往后加元素
void SeqListPush(SL*ps, SLDataType n);//在顺序表中添加元素
void SeqListPopBack(SL*ps);//删除最后一个元素
void SeqListPushFront(SL*ps, SLDataType x);//往前面加元素
void SeqListPopFront(SL*ps);//删除第一个元素
void SepListdisplay(SL*ps);//陈列
void SeqListPushMid(SL*ps, SLDataType x,SLDataType z);//往中间加元素
void SeqListPopMid(SL*ps,SLDataType x);//删除中间某一个元素

这里只是先对一些函数进行声名，还没有进行创建函数！

顺序表相关操作的菜单

void menu()
{
	cout << "\t\t\t******************************************************************" << endl;
	cout << "\t\t\t****************   注意！每次都要先进行初始化  *******************" << endl;
	cout << "\t\t\t****************    1.输入-1  退出程序         *******************" << endl;
	cout << "\t\t\t****************    2.输入1   初始化           *******************" << endl;
	cout << "\t\t\t****************    3.输入2   添加元素         *******************" << endl;
	cout << "\t\t\t****************    4.输入3   陈列元素         *******************" << endl;
	cout << "\t\t\t****************    5.输入4   往最后加元素     *******************" << endl;
	cout << "\t\t\t****************    6.输入5   往前面加元素     *******************" << endl;
	cout << "\t\t\t****************    7.输入6   任意位置加元素   *******************" << endl;
	cout << "\t\t\t****************    8.输入7   删除最后元素     *******************" << endl;
	cout << "\t\t\t****************    8.输入8   删除前面元素     *******************" << endl;
	cout << "\t\t\t****************    8.输入9   删除任意元素     *******************" << endl;
	cout << "\t\t\t******************************************************************" << endl;
}

可以在控制台输入相关的数字进行相关的操作

顺序表的初始化

void SeqListInit(SL*ps)//初始化
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;
	cout << "初始化完成" << endl;
}

顺序表初始化，首先使顺序表的指针置为空，先让顺序表的长度和容量都先置为空

添加元素

void SeqListPush(SL*ps, SLDataType n)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 100 : ps->capacity * 2;
		SLDataType*tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));//SLDataType类型（强制类型转换）的有newcapacity大小的空间
		if (tmp == NULL)
		{
			cout << "分配失败" << endl;
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	int k = 0;
	cout << "请进行赋值" << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> k;
		ps->a[i] = k;
		ps->size++;
	}
	cout << "赋值完成" << endl;
}

此时先进行判断，如果没有空间或者空间不足，就要把把一个新的容量赋值为原来容量的二倍，如果是0就赋值为100 。relloc是扩容函数，是在ps->a后面扩容一个SLDataType类型（强制类型转换）的有newcapacity大小的空间，申请成功的话，就让指针a的地址存放新的地址tmp,此时新的地址tmp里面有扩容后的空间，再让capacity为新的容量，让ps的第一个位置放传进来函数的x，最后再让它的大小++。

陈列元素

void SepListdisplay(SL*ps)//陈列
{
	cout << "下面是您赋值的元素" << endl;
	for (int i = 0; i < ps->size; i++)
	{
		cout << ps->a[i] << " ";
	}
	cout << endl;
}

陈列元素这块很简单，直接可以通过它的下标找到它所代表的值，跟数组一样

往最后加元素

void SeqListPushBack(SL*ps, SLDataType x)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 100 : ps->capacity * 2;
		SLDataType*tmp = (SLDataType*)realloc(ps->a, newcapacity*sizeof(SLDataType));
		if (tmp == NULL)//如果分配失败
		{
			cout << "分配失败" << endl;
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->size] = x;
	ps->size++;//再让它的大小++
	cout << "添加完成" << endl;
}

此时还是要先进行判断顺序表的空间够不够，要是空间不够的话，再运用realloc函数进行重新分配空间，再直接让最后一个位置里面放上传过来的元素就可以了。

往前面加元素

void SeqListPushFront(SL*ps, SLDataType x)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 100 : ps->capacity * 2;
		SLDataType*tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			cout << "分配失败" << endl;
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->size++;
	int i = 0;
	int j = ps->size;
	for (i = j; i > 0; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	cout << "添加完成" << endl;
}

往前面加元素的话，首先还是需要进行判断空间够不够，要是不够还是要运用realloc函数重新分配空间，此时要是想要在最前面添加元素的话，就需要先让它的大小++，再让从下标为0的第一个元素开始，把每一个元素都往后移动一个位置。移动完成之后，再让新的元素加入的顺序表的表头就可以了。

任意位置加元素

void SeqListPushMid(SL*ps, SLDataType x,SLDataType z)
{
	ps->size++;
	int i = 0;
	int j = ps->size - 1;
	for (i=j; i >= x; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[x] = z;
	cout << "添加完成" << endl;
}

要是想在任意位置加元素的话，我们首先应该知道我们需要进行加元素的下标，以及我们需要添加的元素，此时刚好我们的函数里面已经接收到了这两个元素，此时我们就从这个下标开始，让下标对应的元素以及下标之后的元素都往后加一个位置，此时就可以为新的元素腾出一个位置，等全部移动完成后，我们就可以把元素加进来就可以了。

删除最后元素

void SeqListPopBack(SL*ps)//删除最后一个元素
{
	if (ps->size > 0)
	{
		ps->size--;
	}
	cout << "删除完毕" << endl;
}

这一块是最简单的了，直接让顺序表的大小--就可以了。

删除前面元素

void SeqListPopFront(SL*ps)//删除第一个元素
{
	int i = 0;
	int j = ps->size;
	for (i = 1; i < j ; i++)
	{
		ps->a[i-1] = ps->a[i];
	}
	ps->size--;
	cout << "删除完毕" << endl;
}

我们这里可以直接让从下标为1以及后面的元素的位置往前面加一个位置，把第一个元素覆盖住就可以了。

删除任意元素

void SeqListPopMid(SL*ps, SLDataType x)//删除中间某一元素
{
	int i = 0, j = 0;
	for (i = x; i < ps->size ; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
	cout << "删除完毕" << endl;
}

这里的话我们已经知道我们需要删除元素的下标了，于是我们就可以从这个下标开始不包括这个下标对应的元素，把它们的位置往前推一个，把该元素覆盖住就可以了，最后再让大小减一。

整体代码(fun.h部分)

#pragma once
#define N 10000
typedef int SLDataType;
typedef struct
{
	SLDataType *a;
	int size;
	int capacity;
}SL;
//接口函数
void menu();//菜单
void SeqListInit(SL*ps);//初始化
void SeqListPushBack(SL*ps, SLDataType x);//往后加元素
void SeqListPush(SL*ps, SLDataType n);//在顺序表中添加元素
void SeqListPopBack(SL*ps);//删除最后一个元素
void SeqListPushFront(SL*ps, SLDataType x);//往前面加元素
void SeqListPopFront(SL*ps);//删除第一个元素
void SepListdisplay(SL*ps);//陈列
void SeqListPushMid(SL*ps, SLDataType x,SLDataType z);//往中间加元素
void SeqListPopMid(SL*ps,SLDataType x);//删除中间某一个元素

整体代码(fun.cpp部分)

#include<iOStream>//顺序表的实现
#include<stdlib.h>
#include"fun.h"
using namespace std;
void menu()
{
	cout << "\t\t\t******************************************************************" << endl;
	cout << "\t\t\t****************   注意！每次都要先进行初始化  *******************" << endl;
	cout << "\t\t\t****************    1.输入-1  退出程序         *******************" << endl;
	cout << "\t\t\t****************    2.输入1   初始化           *******************" << endl;
	cout << "\t\t\t****************    3.输入2   添加元素         *******************" << endl;
	cout << "\t\t\t****************    4.输入3   陈列元素         *******************" << endl;
	cout << "\t\t\t****************    5.输入4   往最后加元素     *******************" << endl;
	cout << "\t\t\t****************    6.输入5   往前面加元素     *******************" << endl;
	cout << "\t\t\t****************    7.输入6   任意位置加元素   *******************" << endl;
	cout << "\t\t\t****************    8.输入7   删除最后元素     *******************" << endl;
	cout << "\t\t\t****************    8.输入8   删除前面元素     *******************" << endl;
	cout << "\t\t\t****************    8.输入9   删除任意元素     *******************" << endl;
	cout << "\t\t\t******************************************************************" << endl;
}
void SeqListInit(SL*ps)//初始化
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;
	cout << "初始化完成" << endl;
}
void SeqListPush(SL*ps, SLDataType n)//在顺序表中加元素
{
	if (ps->size == ps->capacity)//如果没有空间或者空间不足
	{
		int newcapacity = ps->capacity == 0 ? 100 : ps->capacity * 2;//把一个新的容量赋值为原来容量的二倍，如果是0就赋值为100
		SLDataType*tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));//relloc是扩容函数，是在ps->a后面扩容一个
		//SLDataType类型（强制类型转换）的有newcapacity大小的空间
		if (tmp == NULL)//如果分配失败
		{
			cout << "分配失败" << endl;
			exit(-1);
		}
		ps->a = tmp;//申请成功的话，就让指针a的地址存放新的地址tmp,此时新的地址tmp里面有扩容后的空间
		ps->capacity = newcapacity;//再让capacity为新的容量
	}
	int k = 0;
	cout << "请进行赋值" << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> k;
		ps->a[i] = k;
		ps->size++;
	}
	cout << "赋值完成" << endl;
}
void SeqListPushBack(SL*ps, SLDataType x)//往后加元素,或者也可以叫做为顺序表赋值
{
	if (ps->size == ps->capacity)//如果没有空间或者空间不足
	{
		int newcapacity = ps->capacity == 0 ? 100 : ps->capacity * 2;//把一个新的容量赋值为原来容量的二倍，如果是0就赋值为100
		SLDataType*tmp = (SLDataType*)realloc(ps->a, newcapacity*sizeof(SLDataType));//relloc是扩容函数，是在ps->a后面扩容一个
		//SLDataType类型（强制类型转换）的有newcapacity大小的空间
		if (tmp == NULL)//如果分配失败
		{
			cout << "分配失败" << endl;
			exit(-1);
		}
		ps->a = tmp;//申请成功的话，就让指针a的地址存放新的地址tmp,此时新的地址tmp里面有扩容后的空间
		ps->capacity = newcapacity;//再让capacity为新的容量
	}
	ps->a[ps->size] = x;//让ps的第一个位置放传进来函数的x
	ps->size++;//再让它的大小++
	cout << "添加完成" << endl;
}
void SeqListPopBack(SL*ps)//删除最后一个元素
{
	if (ps->size > 0)
	{
		ps->size--;
	}
	cout << "删除完毕" << endl;
}
void SeqListPushFront(SL*ps, SLDataType x)//往前面加元素
{
	//进来先判断一下里面的空间满没有
	if (ps->size == ps->capacity)//如果没有空间或者空间不足
	{
		int newcapacity = ps->capacity == 0 ? 100 : ps->capacity * 2;//把一个新的容量赋值为原来容量的二倍，如果是0就赋值为100
		SLDataType*tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));//relloc是扩容函数，是在ps->a后面扩容一个
		//SLDataType类型的有newcapacity大小的空间
		if (tmp == NULL)//如果分配失败
		{
			cout << "分配失败" << endl;
			exit(-1);
		}
		ps->a = tmp;//申请成功的话，就让指针a的地址存放新的地址tmp,此时新的地址tmp里面有扩容后的空间
		ps->capacity = newcapacity;//再让capacity为新的容量
	}
	ps->size++;
	int i = 0;
	int j = ps->size;
	for (i = j; i > 0; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	cout << "添加完成" << endl;
}
void SeqListPopFront(SL*ps)//删除第一个元素
{
	int i = 0;
	int j = ps->size;
	for (i = 1; i < j ; i++)
	{
		ps->a[i-1] = ps->a[i];
	}
	ps->size--;
	cout << "删除完毕" << endl;
}
void SepListdisplay(SL*ps)//陈列
{
	cout << "下面是您赋值的元素" << endl;
	for (int i = 0; i < ps->size; i++)
	{
		cout << ps->a[i] << " ";
	}
	cout << endl;
}
void SeqListPushMid(SL*ps, SLDataType x,SLDataType z)//往中间加元素
{
	ps->size++;
	int i = 0;
	int j = ps->size - 1;
	for (i=j; i >= x; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[x] = z;
	cout << "添加完成" << endl;
}
void SeqListPopMid(SL*ps, SLDataType x)//删除中间某一元素
{
	int i = 0, j = 0;
	for (i = x; i < ps->size ; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
	cout << "删除完毕" << endl;
}

整体代码(主函数部分)

#include<iostream>//顺序表的实现
#include<stdlib.h>
#include"fun.h"
using namespace std;
int main()
{
	SL ps;
	int n = 0, m = 0;
	int x = 0;
	menu();
	while (cin >> x)
	{
		if (x < 0)
		{
			break;
		}
		switch (x)
		{
		case 1:
			SeqListInit(&ps);
			break;
		case 2:
			cout << "请输入您要添加几个元素" << endl;
			cin >> n;
			SeqListPush(&ps, n);
			break;
		case 3:
			SepListdisplay(&ps);
			break;
		case 4:
			cout << "请输入您要在最后添加什么元素" << endl;
			cin >> n;
			SeqListPushBack(&ps, n);
			break;
		case 5:
			cout << "请输入您要在最前面添加什么元素" << endl;
			cin >> n;
			SeqListPushFront(&ps, n);
			break;
		case 6:
			cout << "请输入您要添加位置的下标以及添加的元素" << endl;
			cin >> n >> m;
			SeqListPushMid(&ps, 1, 6);
			break;
		case 7:
			SeqListPopBack(&ps);
			break;
		case 8:
			SeqListPopFront(&ps);
			break;
		case 9:
			cout << "请输入您要进行删除元素的下标" << endl;
			cin >> n;
			SeqListPopMid(&ps, n);
		default:
			cout << "您的输入有误，请重新输入" << endl;
		}
	}
	return 0;
}

结果展示

到此这篇关于C语言超详细讲解顺序表的各种操作的文章就介绍到这了,更多相关C语言顺序表内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: C语言超详细讲解顺序表的各种操作

本文链接: https://www.lsjlt.com/news/148050.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

C语言超详细讲解顺序表的各种操作

目录顺序表是什么顺序表的结构体顺序表的接口函数顺序表相关操作的菜单顺序表的初始化添加元素陈列元素往最后加元素往前面加元素任意位置加元素删除最后元素删除前面元素删除任意元素...

99+

2022-11-13
C语言线性表中顺序表超详细理解

目录一、本章重点二、线性表三、顺序表四、静态顺序表接口实现4.1顺序表初始化4.2顺序表打印4.3顺序表尾插4.4顺序表尾删4.5顺序表头插4.6顺序表头删4.7顺序表任意位置插入4...

99+

2022-11-13
C语言超详细讲解文件的操作

目录一、为什么使用文件二、什么是文件1.程序文件2.数据文件3.文件名三、文件指针四、文件的打开和关闭五、文件的顺序读写六、文件的随机读写fseekftellrewind七、文件结束...

99+

2022-11-13
C++ 数据结构超详细讲解顺序表

目录前言一、顺序表是什么概念及结构二、顺序表的实现顺序表的缺点几道练手题总结(●’◡’●) 前言线性表是n个具有相同特性的数据元素的有限序列。线性表是一种...

99+

2022-11-13
C语言操作符超详细讲解下篇

目录前言赋值操作符单目操作符单目操作符介绍sizeof 和数组关系操作符逻辑操作符条件操作符逗号表达式下标引用与函数调用和结构成员[ ] 下标引用操作符( ) 函数调用操作符访问一...

99+

2022-11-13
C语言操作符超详细讲解上篇

目录前言1、操作符的分类2、算术操作符3、移位操作符3.1 左移操作符3.1.1 正数左移1位3.1.2 负数左移1位3.2 右移操作符3.2.1 正数右移1位3.2.2 负数右移1...

99+

2022-11-13
C语言超详细讲解线性表

目录1. 顺序表1.1 管理结点1.2 顺序表的插入1.3 顺序表的删除1.4 顺序表的扩容2. 链表2.1 定义2.2 头部插入2.3 尾部插入2.4 任意位置插入2.5 任意位置...

99+

2022-11-13
C语言全面讲解顺序表使用操作

目录一、顺序表的结构定义二、顺序表的结构操作1.初始化2.插入操作3.删除操作4.扩容操作5.释放操作6.输出三、示例编程环境为 ubuntu 18.04。顺序表需要连续一片存储空...

99+

2022-11-13
C语言实现顺序表的全操作详解

目录线性表顺序表顺序表接口实现1.顺序表初始化2.顺序表空间增容3.顺序表打印4.尾插数据5.尾删数据6.头插数据7.头删数据8.在pos下标处插入数据9.删除pos下标处数据10....

99+

2022-11-13
C语言超详细i讲解双向链表

目录一、双向链表的概念二、双向链表的实现三、链表与顺序表的差别四、链表oj总结一、双向链表的概念 1、概念：概念：双向链表是每个结点除后继指针外还有⼀个前驱指针。双向链表也有带头结点...

99+

2022-11-13
C语言哈希表概念超详细讲解

目录1. 哈希概念2. 哈希冲突3. 哈希实现3.1 闭散列(哈希表)3.1.1 闭散列的细节3.1.2 优化后的闭散列3.2 扩散列(哈希桶)3.2.1 扩散列的细节4. 哈希表和...

99+

2023-02-09

C语言哈希表 C语言哈希概念 C语言哈希实现
新手向超详细的C语言实现动态顺序表

目录一、各个函数接口的实现 1.1 不太好‘'李姐‘'的“容量检测函数” 1.2 在任意位置插入的函数"坑！" 1.3 在任意位置删除数据的函数 1.4 其余简单的接口函数二、顺序...

99+

2022-11-12
C语言超详细讲解排序算法上篇

目录1、直接插入排序2、希尔排序（缩小增量排序）3、直接选择排序4、堆排序进入正式内容之前，我们先了解下初阶常见的排序分类：我们今天讲前四个！ 1、直接插入排序基本思...

99+

2022-11-13
C语言超详细讲解排序算法下篇

目录1、冒泡排序2、快速排序 ( 三种方法 )3、归并排序4、排序算法复杂度及稳定性分析上期学习完了前四个排序，这期我们来学习剩下的三个排序 1、冒泡排序 &n...

99+

2022-11-13
Java超详细讲解ArrayList与顺序表的用法

目录简要介绍Arraylist容器类的使用Arraylist容器类的构造ArrayList的常见方法ArrayList的遍历ArrayList中的扩容机制简要介绍顺序表是一段物理地...

99+

2022-11-13
C语言超详细讲解指针的使用

目录指针概述自身类型指向类型代码例子数值型指针字符型指针单字符字符数组字符串型指针字符数组总结指针概述 C语言中指针也可以认为是一种类型，不同于数值型和字符型的类型。推演过去指针变量...

99+

2022-11-13
C语言超详细讲解双向带头循环链表

目录一、双向带头循环链表的结构二、双向带头循环链表的函数接口1. 申请结点2. 初识化3. 打印4. 尾插尾删5. 头插头删6. 查找7. 中间插入和删除8. 判空及求链表长度9. ...

99+

2023-02-14

C语言双向带头循环链表 C语言带头循环链表 C语言循环链表
C语言数据结构超详细讲解单向链表

目录1.链表概况1.1 链表的概念及结构1.2 链表的分类2. 单向链表的实现2.1 SList.h（头文件的汇总，函数的声明）2.2 SList.c（函数的具体实现逻辑）2.2.1...

99+

2022-11-13
C语言超详细讲解数据结构中的线性表

目录前言一、分文件编写1、分文件编写概念2、代码展示二、动态分布内存malloc1、初识malloc2、使用方法三、创建链表并进行增删操作1、初始化链表2、在链表中增加数据3、删除链...

99+

2022-11-13
C++超详细讲解操作符的重载

目录一、需要解决的问题二、操作符重载三、小结一、需要解决的问题下面的复数解决方案是否可行？下面看一下复数的加法操作： #include <stdio.h> clas...

99+

2022-11-13