数据结构-线性表

已于 2024-04-01 20:20:58 修改
阅读量457 收藏 2
点赞数 10
文章标签： 数据结构 顺序表 C++ C语言
于 2024-04-01 19:35:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45146479/article/details/137242824
版权

大家好：
衷心希望各位点赞。
您的问题请留在评论区，我会及时回答。

目录

顺序表的算法实现

#include <iostream>
#include <Windows.h>

#define MAX_SIZE 100

typedef int ElemType;

using namespace std;

// 顺序表
typedef struct _SqList
{
	ElemType* elem;
	int length;
	int size;
} SqList;

// 构造一个空的顺序表
bool initList(SqList& sqList);

// 打印线性表
void printList(const SqList& L);

int main(void)
{
	SqList sqList;

	cout << "顺序表的初始化：" << endl;

	if (initList(sqList))
	{
		cout << "初始化线性表成功" << endl;
		printList(sqList);
	}
	else
	{
		cout << "初始化线性表失败" << endl;
	}

	system("pause");
	return 0;
}

bool initList(SqList& sqList)
{
		sqList.elem = new ElemType[MAX_SIZE];

		if (sqList.elem != NULL)
		{
			// 分配成功
			sqList.length = 0;
			sqList.size = MAX_SIZE;
			return true;
		}
		else
		{
			// 分配失败
			return false;
		}
}

void printList(const SqList& L)
{
	cout << "线性表的存储空间 size = " << L.size
		 << "，元素个数 length = " << L.length;

	for (int i = 0; i < L.length; i++)
	{
		cout << L.elem[i] << "  ";
	}
	cout << endl;
}

运行截图：
在这里插入图片描述

顺序表添加元素

#include <iostream>
#include <Windows.h>

#define MAX_SIZE 100

typedef int ElemType;

using namespace std;

// 顺序表
typedef struct _SqList
{
	ElemType* elem;
	int length;
	int size;
} SqList;

// 构造一个空的顺序表
bool initList(SqList& sqList);

// 打印线性表
void printList(const SqList& L);

// 顺序表添加元素
bool listAppend(SqList& L, int elem);

int main(void)
{
	SqList sqList;

	cout << "顺序表的初始化：" << endl;

	if (initList(sqList))
	{
		cout << "初始化线性表成功" << endl;
		cout << "此时，" ;
		printList(sqList);
	}
	else
	{
		cout << "初始化线性表失败" << endl;
	}

	// 插入元素
	listAppend(sqList, 10);
	listAppend(sqList, 30);
	listAppend(sqList, 40);
	listAppend(sqList, 20);
	listAppend(sqList, 50);

	cout << "----------" << endl;

	cout << "插入元素后：";
	printList(sqList);

	system("pause");
	return 0;
}

bool initList(SqList& sqList)
{
		sqList.elem = new ElemType[MAX_SIZE];

		if (sqList.elem != NULL)
		{
			// 分配成功
			sqList.length = 0;
			sqList.size = MAX_SIZE;
			return true;
		}
		else
		{
			// 分配失败
			return false;
		}
}

void printList(const SqList& L)
{
	cout << "线性表的存储空间 size = " << L.size
		 << "，元素个数 length = " << L.length << endl;

	if (L.length == 0) return;

	cout << "线性表的元素：";

	for (int i = 0; i < L.length; i++)
	{
		cout << L.elem[i] << "  ";
	}
	cout << endl;
}

bool listAppend(SqList& L, int elem)
{
	if (L.length == L.size)
	{
		// 顺序表已满
		cout << "顺序表已满，添加失败" << endl;
		return false;
	}
	
	// 顺序表还有空间，插入元素
	L.elem[L.length] = elem;
	L.length++;
	return true;
}

运行截图：

顺序表插入元素

#include <iostream>
#include <Windows.h>

#define MAX_SIZE 100

typedef int ElemType;

using namespace std;

// 顺序表
typedef struct _SqList
{
	ElemType* elem;
	int length;
	int size;
} SqList;

// 构造一个空的顺序表
bool initList(SqList& sqList);

// 打印线性表
void printList(const SqList& L);

// 顺序表添加元素
bool listAppend(SqList& L, ElemType elem);

// 顺序表插入元素
// pos：插入元素的位置
// elem：插入的元素
bool listInsert(SqList& L, int pos, ElemType elem);

int main(void)
{
	SqList sqList;
	initList(sqList);

	// 插入元素
	listAppend(sqList, 10);
	listAppend(sqList, 30);
	listAppend(sqList, 40);
	listAppend(sqList, 20);
	listAppend(sqList, 50);

	cout << "添加元素后：" << endl;
	printList(sqList);

	cout << "----------" << endl;

	listInsert(sqList, 0, 60); // 在0号位置插入值为60的元素

	cout << "插入元素后：" << endl;
	printList(sqList);

	system("pause");
	return 0;
}

bool listInsert(SqList& L, int pos, ElemType elem)
{
	if (pos < 0 || pos > L.size) return false; // 插入的位置不合法
	if (L.length == L.size) return false; // 空间已满

	// 移动元素
	for (int i = L.length; i > pos; i--)
	{
		L.elem[i] = L.elem[i - 1];
	}

	L.elem[pos] = elem;
	L.length++;
	return true;
}

bool initList(SqList& sqList)
{
		sqList.elem = new ElemType[MAX_SIZE];

		if (sqList.elem != NULL)
		{
			// 分配成功
			sqList.length = 0;
			sqList.size = MAX_SIZE;
			return true;
		}
		else
		{
			// 分配失败
			return false;
		}
}

void printList(const SqList& L)
{
	cout << "线性表的存储空间 size = " << L.size
		 << "，元素个数 length = " << L.length << endl;

	if (L.length == 0) return;

	cout << "线性表的元素：";

	for (int i = 0; i < L.length; i++)
	{
		cout << L.elem[i] << "  ";
	}
	cout << endl;
}

bool listAppend(SqList& L, int elem)
{
	if (L.length == L.size)
	{
		// 顺序表已满
		cout << "顺序表已满，添加失败" << endl;
		return false;
	}
	
	// 顺序表还有空间，插入元素
	L.elem[L.length] = elem;
	L.length++;
	return true;
}

运行截图：

顺序表删除元素

#include <iostream>
#include <Windows.h>

#define MAX_SIZE 100

typedef int ElemType;

using namespace std;

// 顺序表
typedef struct _SqList
{
	ElemType* elem;
	int length;
	int size;
} SqList;

// 构造一个空的顺序表
bool initList(SqList& sqList);

// 打印线性表
void printList(const SqList& L);

// 顺序表添加元素
bool listAppend(SqList& L, ElemType elem);

// 顺序表插入元素
// pos：插入元素的位置
// elem：插入的元素
bool listInsert(SqList& L, int pos, ElemType elem);

// 删除元素
// L：要执行删除操作的顺序表
// pos：删除元素的位置
bool listDelete(SqList& L, int pos);

int main(void)
{
	SqList sqList;
	initList(sqList);

	// 插入元素
	listAppend(sqList, 10);
	listAppend(sqList, 30);
	listAppend(sqList, 40);
	listAppend(sqList, 20);
	listAppend(sqList, 50);

	cout << "添加元素后：" << endl;
	printList(sqList);

	cout << "----------" << endl;

	listDelete(sqList, 0); // 删除在0号位置的元素

	cout << "删除元素后：" << endl;
	printList(sqList);

	system("pause");
	return 0;
}

bool listDelete(SqList& L, int pos)
{
	if (pos < 0 || pos >= L.length) return false; // 要删除的元素位置不合法
	if (L.length == 0) return false; // 顺序表为空，没有元素可被删除

	// 向pos位置移动元素
	for (int i = pos; i < L.length - 1; i++)
	{
		L.elem[i] = L.elem[i + 1];
	}

	L.length--;
	return true;
}

bool initList(SqList& sqList)
{
		sqList.elem = new ElemType[MAX_SIZE];

		if (sqList.elem != NULL)
		{
			// 分配成功
			sqList.length = 0;
			sqList.size = MAX_SIZE;
			return true;
		}
		else
		{
			// 分配失败
			return false;
		}
}

void printList(const SqList& L)
{
	cout << "线性表的存储空间 size = " << L.size
		 << "，元素个数 length = " << L.length << endl;

	if (L.length == 0) return;

	cout << "线性表的元素：";

	for (int i = 0; i < L.length; i++)
	{
		cout << L.elem[i] << "  ";
	}
	cout << endl;
}

bool listAppend(SqList& L, int elem)
{
	if (L.length == L.size)
	{
		// 顺序表已满
		cout << "顺序表已满，添加失败" << endl;
		return false;
	}
	
	// 顺序表还有空间，插入元素
	L.elem[L.length] = elem;
	L.length++;
	return true;
}

bool listInsert(SqList& L, int pos, ElemType elem)
{
	if (pos < 0 || pos > L.size) return false; // 插入的位置不合法
	if (L.length == L.size) return false; // 空间已满

	// 移动元素
	for (int i = L.length; i > pos; i--)
	{
		L.elem[i] = L.elem[i - 1];
	}

	L.elem[pos] = elem;
	L.length++;
	return true;
}

运行截图：

顺序表的销毁

#include <iostream>
#include <Windows.h>

#define MAX_SIZE 100

typedef int ElemType;

using namespace std;

// 顺序表
typedef struct _SqList
{
	ElemType* elem;
	int length;
	int size;
} SqList;

// 构造一个空的顺序表
bool initList(SqList& sqList);

// 打印线性表
void printList(const SqList& L);

// 顺序表添加元素
bool listAppend(SqList& L, ElemType elem);

// 顺序表插入元素
// pos：插入元素的位置
// elem：插入的元素
bool listInsert(SqList& L, int pos, ElemType elem);

// 删除元素
// L：要执行删除操作的顺序表
// pos：删除元素的位置
bool listDelete(SqList& L, int pos);

// 销毁顺序表
void listDestory(SqList& L);

int main(void)
{
	SqList sqList;
	initList(sqList);

	// 插入元素
	listAppend(sqList, 10);
	listAppend(sqList, 30);
	listAppend(sqList, 40);
	listAppend(sqList, 20);
	listAppend(sqList, 50);

	cout << "添加元素后：" << endl;
	printList(sqList);

	cout << "----------" << endl;

	listDestory(sqList);

	cout << "销毁顺序表后：" << endl;

	printList(sqList);

	system("pause");
	return 0;
}

void listDestory(SqList& L)
{
	if (L.elem != NULL)
	{
		delete[] L.elem; // 释放堆区数据
		L.elem = NULL; // 线性表的指针置为空
	}
		
	L.length = 0;
	L.size = 0;
}

bool listDelete(SqList& L, int pos)
{
	if (pos < 0 || pos >= L.length) return false; // 要删除的元素位置不合法
	if (L.length == 0) return false; // 顺序表为空，没有元素可被删除

	// 向pos位置移动元素
	for (int i = pos; i < L.length - 1; i++)
	{
		L.elem[i] = L.elem[i + 1];
	}

	L.length--;
	return true;
}

bool initList(SqList& sqList)
{
		sqList.elem = new ElemType[MAX_SIZE];

		if (sqList.elem != NULL)
		{
			// 分配成功
			sqList.length = 0;
			sqList.size = MAX_SIZE;
			return true;
		}
		else
		{
			// 分配失败
			return false;
		}
}

void printList(const SqList& L)
{
	cout << "线性表的存储空间 size = " << L.size
		 << "，元素个数 length = " << L.length << endl;

	if (L.length == 0) return;

	cout << "线性表的元素：";

	for (int i = 0; i < L.length; i++)
	{
		cout << L.elem[i] << "  ";
	}
	cout << endl;
}

bool listAppend(SqList& L, int elem)
{
	if (L.length == L.size)
	{
		// 顺序表已满
		cout << "顺序表已满，添加失败" << endl;
		return false;
	}
	
	// 顺序表还有空间，插入元素
	L.elem[L.length] = elem;
	L.length++;
	return true;
}

bool listInsert(SqList& L, int pos, ElemType elem)
{
	if (pos < 0 || pos > L.size) return false; // 插入的位置不合法
	if (L.length == L.size) return false; // 空间已满

	// 移动元素
	for (int i = L.length; i > pos; i--)
	{
		L.elem[i] = L.elem[i - 1];
	}

	L.elem[pos] = elem;
	L.length++;
	return true;
}

运行截图：

Austin_1024
关注
  • 10
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构-线性表-思维导图+小结
学习记录
11-12 2127
数据结构-线性表-思维导图+习题小结
数据结构 -线性表
weixin_59725429的博客
11-06 994
线性表 定义：线性表（linear list）是具有相同特性的数据元素的一个有限序列。线性表的逻辑表示为：( a1，a2，…，ai，ai+1，…，an ) ai（1≤i≤n）表示第i（i表示逻辑位序）个元素。前驱与后继：线性表中相邻的数据元素ai-1和ai之间存在序偶关系(ai-1, ai)，即ai-1是ai的前驱， ai是ai-1的后继；a1 无前驱，an无后继，其它每个元素有且仅有一个前驱和一个后继。线性表长度：线性表中元素的个数。线性表L=（a1,a2,a3……
数据结构-线性表-PPT
02-04
"数据结构-线性表-PPT" 数据结构是一门研究非数值计算的程序设计问题的学科，它研究的是计算机存储、表示、操作和保护非数值信息的方法和技术。线性表是数据结构的一种基本结构，它是一种线性结构，只有一个首结点...
数据结构-线性表的链式存储
09-17
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素组成，按照线性顺序排列。在实际应用中，线性表的数据元素可以是数字、字符串、对象等各种类型。线性表的链式存储是数据结构课程中的核心概念...
数据结构-线性表的基本使用
10-26
线性表是数据结构中的基础概念，它是一种最简单但非常重要的数据组织形式。线性表是由n（n>=0）个相同类型元素构成的有限序列，这些元素在逻辑上是顺序排列的，可以通过索引访问。在计算机科学中，理解和掌握线性表...
数据结构-线性表-xmind思维导图
05-13
串、栈、队列的区分度在于数据的运算和逻辑结构，而他们的存储结构常用的都是顺序表和链表。 广义表和数组都是更抽象的线性表，数组对数据元素要求更严苛，广义表则是放开了数据元素的限定。他们都可以是递归定义，...
数据结构-线性表09
01-20
线性表是数据结构中的基础概念，它是一个包含零个或多个数据元素的有限序列，这些元素遵循特定的顺序规则。在线性表中，每个元素要么是序列的开头（无直接前驱），要么位于中间（有一个直接前驱和一个直接后继），...
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 305
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
数据结构day3
qq_55245263的博客
07-18 271
顺序表实现学生管理系统
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1050
可以参考以下视频。
数据结构初阶·排序算法(内排序)
2301_79697943的博客
07-18 885
目前常见的排序算法有9种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，计数排序，基数排序，桶排序。实际生活中排序的应用也是有限的，今天我们介绍其中7个，基数排序和桶排序不介绍。介绍常用的即可。顺带一嘴，本文里面所有的排序都是内排序，也就是在内存里面进行排序的，还有一种排序叫做外排序，即是在磁盘里面进行排序的，这种排序具有记忆性，外排序用到的就是归并排序，因为归并排序有一个特点就是空间复杂度为O(N)。好了正文开始。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 236
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构第32节 无锁编程
hummhumm的专栏
07-17 867
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
数据结构——栈
weixin_45942515的博客
07-19 388
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
数据结构之细说链表
m0_73634434的博客
07-17 1069
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1096
24暑假刷题day15打卡 二叉树进阶
数据结构 - 线性表
09-13
线性表是一种常见的数据结构，它表示具有相同数据类型的一组元素的有序序列。线性表中的元素之间存在一种顺序关系，每个元素都有一个前驱和一个后继（除了第一个元素没有前驱，最后一个元素没有后继）。线性表可以用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值