线性表·顺序表

已于 2022-12-15 16:28:09 修改
阅读量821 收藏 10
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构
于 2021-06-01 16:48:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54502707/article/details/117442714
版权

  大家好，我是Koko~ 

  数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。 数据结构往往同高效的检索算法和索引技术有关。

   本专栏将针对数据结构相关知识进行梳理及总结。建议搭配C语言版（严蔚敏版）数据结构教材使用更佳。

   线性表是最常用且最简单的一种数据结构。一个线性表是n个数据元素的有限序列。在稍复杂的线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称文件。

   同一线性表中的元素必定具有相同特性，即属同一数据对象，相邻数据元素之间存在着序偶关系。

1、线性结构的基本特征：

   线性逻辑结构的非形式化描述          一个数据元素的有序（次序）集

（1）集合中必存在唯一的一个“第一元素”

（2）集合中必存在唯一的一个 “最后元素”

（3）除最后元素在外，均有 唯一的后继

（4）除第一元素之外，均有 唯一的前驱

2、线性表类型的存储结构----顺序映射

   线性表具有两种结构——顺序结构和链式结构。本节主要讲解顺序结构所对应的顺序表。

顺序映象

           以 x 的存储位置和 y 的存储位置之间某种关系表示逻辑关系<x,y>

通常情况顺序映象方法是

           令y的存储位置和x的存储位置相邻。

一、顺序表的定义

    顺序表，用一组地址连续的存储单元依次存储线性表的数据元素，它的逻辑地址相邻，物理地址也相邻（参照一维数组）。

  顺序表的优点：简单、支持随机访问、查找方便、尾插和尾删效率高。

  顺序表的缺点：数据的插入和删除慢（需要挪动后面的数据）。

  顺序表的结构如下图所示，它有两个区域，一个是数据区域类似于数组，存放用户存储的数据，另一个是一个整形变量区，存放已经使用了的区域个数。

定义顺序表类型

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 20

//数据元素的类型
typedef int ElemType;   

//定义顺序表类型
typedef struct
{
	ElemType a[MAXSIZE];
	int length;    //顺序表的实际长度
}SqList, *SqList;

二、顺序表的基本操作函数

  对顺序表，有初始化、打印、插入、删除、查找的基本操作。

1、初始化顺序表函数

Status Init_List(SqList &L)
{
	memset(L.data, 0, sizeof(L));//初始化数据为0
	L.length = 0;                //初始化长度为0
	return 0;
}

2、创建顺序表函数

//建立线性表
void Creat_List(SqList *L)
{
	int i;
	printf("请输入线性表的长度: ");
	scanf("%d",&L->length);
	for(i=0;i<L->length;i++)
	{
		printf("数据 %d =",i);
	        scanf("%d",&(L->a[i]));
        }
}

3、输出函数

//输出线性表
void Out_List(SqList L)
{
	int i;
	for(i=0;i<=L.length-1;i++)
		printf("%10d",L.a[i]);
}

4、插入函数（插入一个元素）

//在线性表的第i个位置插入元素e
void Insert_Sq(SqList *L,int i,ElemType e)
{
	int j;
	if(L->length==MAXSIZE)
		printf("线性表已满!\n");
	else 
        {
		if(i<1||i>L->length+1)
	            printf("输入位置错!\n");
		else 
        {
		for(j=L->length-1;j>=i-1;j--)
	            L->a[j+1]=L->a[j];
                L->a[i-1]=e;   
		L->length++;
		}
	}
}

5、删除函数（删除一个元素）

//删除第i个元素，返回其值
ElemType Delete_Sq(SqList *L,int i)
{
	ElemType x;
	int j;
	if(L->length==0)
		printf("空表!\n");
	else if(i<1||i>L->length)
	{
		printf("输入位置错！\n");
		x=-1;
	}
	else
	{
		x=L->a[i-1];
		for(j=i;j<=L->length-1;j++)
                    L->a[j-1]=L->a[j];
                L->length--;
	}
	return(x);
}

6、查找函数（查找一个值为e的元素，返回它的位置）

//查找值为e的元素，返回它的位置
int Locate_Elem(SqList L,ElemType e)
{
	int i=0;
	while(L.a[i]!=e) 
              i++;
	if(i<=L.length-1)
		return(i+1);
}

三、顺序表的功能操作函数

1、倒置函数（将原顺序表直接倒置）

//倒置函数 将原顺序表直接倒置
void Reverse(SqList &L)
{
	if (L.length)
		for (int i = 0; i<L.length - 1 - i; i++)
		{
			int t = L.data[i];
			L.data[i] = L.data[L.length - 1 - i];
			L.data[L.length - 1 - i] = t;
		}
}

2、奇偶分开并排序

//奇偶分开并排序
void SplitSort(SqList &L)
{
	int Even = 0;
	int Odd = L.length - 1;
	int i = 0;
	int j = L.length - 1;
	bool flag = false;
	if (L.length)
		for (; i < j; i++, j--)
		{
			while (L.data[i] % 2 != 0)i++;
			while (L.data[j] % 2 == 0)j--;
			if (L.data[i] % 2 == 0 && L.data[j] % 2 != 0&&i<j)
			{
				int temp = L.data[i];
				L.data[i] = L.data[j];
				L.data[j] = temp;
				flag = true;
			}
			if(!flag) //没有交换
			{
				Even = L.length - 1;//全奇数
				Odd = 0; //全偶数
			}
		}
	if (flag)
	{
		for(int i=0;i<L.length;i++)
			if (L.data[i] % 2 == 0) 
			{
				Odd = i;
				Even = i - 1;
				break;
			}
	}
	sort(L.data, L.data + Even + 1);
	sort(L.data + Odd, L.data + L.length);
}

四、顺序表操作总览

/*
Project: sequence_list(数据结构-顺序表)
*/

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
#define MaxSize 100
#define ElemType int
#define Status int
using namespace std;

//顺序表数据结构
typedef struct
{
	ElemType a[MAXSIZE];
	int length;    //顺序表的实际长度
}SqList, *SqList;  

//***************************基本操作函数*******************************//

//初始化顺序表函数，构造一个空的顺序表 
Status Init_List(SqList &L)
{
	memset(L.data, 0, sizeof(L));//初始化数据为0
	L.length = 0;                //初始化长度为0
	return 0;
}

//创建顺序表函数 初始化前n个数据
void Creat_List(SqList *L)
{
	int i;
	printf("请输入线性表的长度: ");
	scanf("%d",&L->length);
	for(i=0;i<L->length;i++)
	{
		printf("数据 %d =",i);
	        scanf("%d",&(L->a[i]));
        }
}

//插入函数 位置i插入数据 i及之后元素后移  1=<i<=length+1 
void Insert_Sq(SqList *L,int i,ElemType e)
{
	int j;
	if(L->length==MAXSIZE)
		printf("线性表已满!\n");
	else 
        {
		if(i<1||i>L->length+1)
	            printf("输入位置错!\n");
		else 
        {
		for(j=L->length-1;j>=i-1;j--)
	            L->a[j+1]=L->a[j];
                L->a[i-1]=e;   
		L->length++;
		}
	}
}

//删除函数 删除位置i的元素 i之后的元素依次前移
ElemType Delete_Sq(SqList *L,int i)
{
	ElemType x;
	int j;
	if(L->length==0)
		printf("空表!\n");
	else if(i<1||i>L->length)
	{
		printf("输入位置错！\n");
		x=-1;
	}
	else
	{
		x=L->a[i-1];
		for(j=i;j<=L->length-1;j++)
                    L->a[j-1]=L->a[j];
                L->length--;
	}
	return(x);
}

//查找函数 按位置从小到大查找第一个值等于e的元素 并返回位置
int Locate_Elem(SqList L,ElemType e)
{
	int i=0;
	while(L.a[i]!=e) 
              i++;
	if(i<=L.length-1)
		return(i+1);
}

//倒置函数 将原顺序表直接倒置
void Reverse(SqList &L)
{
	if (L.length)
		for (int i = 0; i<L.length - 1 - i; i++)
		{
			int t = L.data[i];
			L.data[i] = L.data[L.length - 1 - i];
			L.data[L.length - 1 - i] = t;
		}
}

//奇偶分开并排序
void SplitSort(SqList &L)
{
	int Even = 0;
	int Odd = L.length - 1;
	int i = 0;
	int j = L.length - 1;
	bool flag = false;
	if (L.length)
		for (; i < j; i++, j--)
		{
			while (L.data[i] % 2 != 0)i++;
			while (L.data[j] % 2 == 0)j--;
			if (L.data[i] % 2 == 0 && L.data[j] % 2 != 0&&i<j)
			{
				int temp = L.data[i];
				L.data[i] = L.data[j];
				L.data[j] = temp;
				flag = true;
			}
			if(!flag) //没有交换
			{
				Even = L.length - 1;//全奇数
				Odd = 0; //全偶数
			}
		}
	if (flag)
	{
		for(int i=0;i<L.length;i++)
			if (L.data[i] % 2 == 0) 
			{
				Odd = i;
				Even = i - 1;
				break;
			}
	}
	sort(L.data, L.data + Even + 1);
	sort(L.data + Odd, L.data + L.length);
}

//清空顺序表
void ClearList(SqList &L) {
	L.length = 0;
}

//********************************功能函数*****************************************//

//输出功能函数 按位置从小到大输出顺序表所有元素
void Out_List(SqList L)
{
	int i;
	for(i=0;i<=L.length-1;i++)
		printf("%10d",L.a[i]);
}

//创建顺序表函数
void Create(SqList &L)
{
	int n; bool flag;
	L.length = 0;
	printf("请输入要创建的顺序表长度(>1):");
	scanf("%d", &n);
	printf("请输入%d个数（空格隔开）:", n);
	flag = CreateList(L, n);
	if (flag) {
		printf("创建成功！\n");
		PrintList(L);
	}
	else printf("输入长度非法！\n");
 
}

//插入功能函数 调用Insert_Sq完成顺序表元素插入 调用Out_List函数显示插入成功后的结果
void Insert(SqList &L,int place, ElemType e)
{
	bool flag;
	printf("请输入要插入的位置(从1开始)及元素:\n");
	scanf("%d%d", &place, &e);
	flag = Insert_Sq(L, place, e);
 	if (flag)
	{
		printf("插入成功！！！\n");
		PrintList(L);
	}
}

//删除功能函数 调用Delete_Sq函数完成顺序表的删除 调用Out_List函数显示插入成功后的结果
void Delete(SqList &L,int place;)
{
        bool flag;
	printf("请输入要删除的位置(从1开始):\n");
	scanf("%d", &place);
	flag = Delete_Sq(L, place);
	if (flag)
	{
		printf("删除成功！！！\n");
		PrintList(L);
	}
}

//查找功能函数 调用LocateElem查找元素
void Locate_Elem(SqList L)
{
	ElemType e; int flag;
	printf("请输入要查找的值:\n");
	scanf("%d", &e);
	flag = Locate_Elem(L, e);
	if (flag)
	{
		printf("该元素位置为:%d\n", flag);
	}
	else
		printf("未找到该元素！\n");
}

//菜单
void menu()
{
	printf("********1.创建                        2.插入*********\n");
	printf("********3.删除                        4.查找*********\n");
  	printf("********5.倒置                        6.分奇偶排序***\n");
	printf("********7.输出                        8.清空*********\n");
	printf("********9.退出                              *********\n");
}
int main()
{
	SqList L; int choice;
	InitList(L);
	while (1)
	{
		menu();
		printf("请输入菜单序号：\n");
		scanf("%d", &choice);
 		if (9 == choice) break;
		 switch (choice)
		{
 		case 1:Create(L); break;
		case 2:Insert(L); break;
		case 3:Delete(L); break;
		case 4:Search(L); break;
		case 5:Reverse(L); break;
		case 6:SplitSort(L); break;
		case 7:PrintList(L); break;
		case 8:ClearList(L); break;
		default:printf("输入错误！！！\n");
		}
	}
	return 0;
}

—————————————————————————————————————————————————————————————————————————————————

以上部分代码和图片转自以下两篇文章，如有侵权，请告知删除!

「lady_killer9」  《数据结构-顺序表基本操作的实现（含全部代码）》
原文链接：https://blog.csdn.net/lady_killer9/article/details/82695770


「饭_团」           《顺序表（一）》
原文链接：https://blog.csdn.net/f__yuan/article/details/97000573

Koko～
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构线性表快速排序
01-09
数据结构线性表快速排。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。序
线性表顺序表插入 删除 查找
05-03
顺序表的实现和应用。 （1）完成顺序表的结构定义，建立含有10个元素的顺序表，并把建成的顺序表顺序输出。 （2）在指定位置插入一个元素。例如，设当前顺序表的顺序为：“2 3 8 7 6 2 8 9 4 2” ，则按提示输入要插...
数据结构线性表之顺序表
qq_43652113的博客
06-11 393
数据结构（java实现） 线性表 最简单常用的一种数据结构，就是n个数据元素的有限序列。可以理解为一个中间没有空元素的数组（数组元素不一定只有数） 顺序表 那么我们现在来用java实现一个最简单的顺序表，先写个接口确定一下功能，主要是增删和查 zhpackage xianxingbiao1;//这个是包，不用管 public interface IList {//设定接口 public void clean();//将线性表置空 public boolean isEmpty();//判
数据结构--线性表之顺序表
m0_59052131的博客
11-19 795
线性表（List）：零个或多个数据元素的有限序列。线性表的数据集合为{a1,a2,…,an}，假设每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。在较复杂的线性表中，。在这种情况下，常把数据元素称为记录，
线性表的顺序存储
weixin_33857230的博客
03-13 106
特点：在内存中用一块地址连续的存储空间按顺序存储线性表的各个数据元素，逻辑上相邻的两个元素在物理结构上也是相邻的。存储密度高，且能随机的存储数据元素，但进行插入，删除时需要移动大量的数据元素，而且顺序表需要预先分配存储空间，若表长n的值变化较大，则存储规模事先难以预料。 1.线性表的顺序存储结构描述 1 #define MAXSIZE 10 //线性表的最大长度 2 ty...
数据结构-线性表及顺序结构
wooovi的博客
01-15 314
线性表的定义 由n(n⩾\geqslant⩾ 0)个数据元素(结点)a1,a2,…an,组成的有限序列 其中数据元素的个数n定义为表的长度 当n=0时称为空表 将非空的线性表记作：(a1,a2,...an) 这里的数据元素ai(1⩽i⩽n )只是一个抽象的符号，其具体含义在不同的情况下可以不同 线性表的逻辑特征 在非空的线性表，有且仅有一个开始的节点a1,它没有直接前趋，而仅有一个直接后继a2; 有且仅有一个终端节点an,它没有直接后继，而仅有一个直接前趋an-1; 其余内部节点ai(2⩽\leqsla
数据结构线性表顺序表.ppt
01-06
数据结构线性表顺序表 本节我们将讲解数据结构中的线性表顺序表，包括线性表的定义和运算、顺序表的定义、类型描述、顺序表的特点等。 一、线性表的定义和运算 线性表是由n个元素a1,a2,…,an组成的有限序列，记作...
线性表之顺序表
03-28
在数据结构的领域里，线性表有多种实现方式，其中顺序表是最简单也是最直观的一种。顺序表是指表中的元素在内存中是连续存放的，就像数组一样，可以通过下标直接访问任意位置的元素。 顺序表的优点在于其访问速度快...
数据结构 线性表 顺序表基本操作
12-28
线性表的顺序表的建立、插入、删除、输出等操作。
C++数据结构-线性表及相关查找排序算法
01-03
C++模板类实现的动态数组、双向循环链表、队列、栈等数据结构，以及基于迭代器的静态查找和排序算法，包括顺序查找、折半查找、简单选择排序（用于单向迭代器）、快速排序（双向迭代器）、堆排序（随机迭代器）。程序编码风格良好，注释详细。
顺序表类定义
学习，记录，总结 的专栏
11-05 2101
// abstract data type for List template class List {     void clear();                   // 置空线性表     bool isEmpty();                 // 线性表为空时，返回True     bool append(T value);           // 在表尾加
数据结构线性表的顺序实现
爱书不爱输的程序猿
11-05 763
数据结构线性表的顺序实现 #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAXSIZE 100 //定义线性表的最大长度 typedef struct sq_list { int ListData[MAXSIZE + 1]; //保存顺序表的数组 int len; ...
数据结构与算法第(2)讲-线性表和排序
匆匆哪年的博客
12-24 262
线性表是很常见数据结构表的一种，一般又细分为顺序存储和链式存储，前者是以一个连续空间来存储数据，而后者则是用节点来存储数据。 顺序表是有前驱和后驱，我们可以这样描述，a1是a2的前驱，ai+1 是ai的后继，a1没有前驱，an没有后继 n为线性表的长度 ，若n==0时，线性表为空表。优点：尾插效率高，支持随机访问。缺点：中间插入或者删除效率低。 比如常用的数组和ArrayList。 链表是由一...
数据结构--线性表的顺序实现
qq_41645695的博客
07-26 449
1、线性结构的特点 1）存在唯一一个”第一个“数据元素； 2）存在唯一一个“最后一个”数据元素； 3）除第一个外，集合中的每一个数据元素均只有一个前驱； 4）除最后一个外，集合中的每一个数据元素均只有一个后继； 2、线性表的定义 一个线性表是n个元素组成的有限序列，一个数据元素由若干数据项组成，由若干个数据项组成的数据元素又称为记录（数据库中的行）。同一线性表中的元素必定具有相同特性，...
数据结构【3】【高级排序】线性表—顺序表、链表
foolish的博客
11-01 507
顺序表和链表的实现
c语言线性表之顺序表实现
Xiaoweidumpb
11-23 166
头文件 //避免重复编译 #ifndef __SEQLIST_H__ #define __SEQLIST_H__ #include<stdio.h> #include<malloc.h> #include<assert.h> #define SEQLIST_INIT_SIZE 8 #define INC_SIZE 3 typedef int ElmeType; typedef struct SeqList { ElmeType *base; int cap
线性表之顺序表（C/C++）
JangKeo
10-11 408
线性表之顺序表（C/C++） 1.表的基本操作 引入： #include<stdio.h> #include<stdlib.h> #define InitSize 10 #define ElemType int 线性表的创建内容：创 销 增 删 改 查 表的结构体说明： typedef struct { ElemType *data; int MaxSize; int length; }SeqList; //表的初始化 vo...
JAVA从零开始之数据结构与算法线性表基本排序方法（1）
辶走之
03-13 466
/* * 快速排序 左边作参考值 挖坑填坑法 * 快速排序中间作参考值 * 冒泡排序法 * 双向冒泡排序法 * 堆排序 * 插入排序 * 希尔排序 * 折半排序 */
线性表顺序表的插入删除的C++主函数
最新发布
05-16
以下是线性表顺序表的插入和删除操作的C++主函数示例： ```c++ #include <iostream> using namespace std; const int MAXSIZE = 100; // 线性表最大长度 typedef struct { int data[MAXSIZE]; // 存储元素的数组 int length; // 线性表的当前长度 } SqList; // 定义顺序表类型 // 初始化线性表 void InitList(SqList &L) { L.length = 0; } // 在指定位置插入元素 bool ListInsert(SqList &L, int i, int e) { if (i < 1 || i > L.length + 1 || L.length == MAXSIZE) // 插入位置不合法或线性表已满 return false; for (int j = L.length; j >= i; j--) // 将 i 及以后的元素后移 L.data[j] = L.data[j - 1]; L.data[i - 1] = e; // 插入元素 L.length++; // 线性表长度加 1 return true; } // 删除指定位置的元素 bool ListDelete(SqList &L, int i) { if (i < 1 || i > L.length) // 删除位置不合法 return false; for (int j = i; j < L.length; j++) // 将 i 及以后的元素前移 L.data[j - 1] = L.data[j]; L.length--; // 线性表长度减 1 return true; } int main() { SqList L; InitList(L); ListInsert(L, 1, 10); ListInsert(L, 2, 20); ListInsert(L, 3, 30); cout << "插入元素后的线性表："; for (int i = 0; i < L.length; i++) cout << L.data[i] << " "; cout << endl; ListDelete(L, 2); cout << "删除元素后的线性表："; for (int i = 0; i < L.length; i++) cout << L.data[i] << " "; cout << endl; return 0; } ``` 代码中使用了结构体定义顺序表类型，分别实现了初始化线性表、在指定位置插入元素、删除指定位置元素的操作。主函数中演示了插入和删除操作的使用。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值