【数据结构】二、顺序表的定义和基本操作的实现

已于 2022-12-15 12:17:49 修改
阅读量820 收藏 2
点赞数 3
分类专栏： 数据结构与算法 文章标签： 数据结构 链表
于 2022-12-15 11:52:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45770232/article/details/128326005
版权

目录

数据结构 DATA STRUCTURE

二、线性表

2.1 线性表的定义和基本操作概述

线性表的定义和基本操作

2.2 线性表的顺序表示

顺序表：线性表的顺序存储。（顺序存储≠顺序存取）

用一组地址连续的存储单元依次存储线性表中的数据元素，使得逻辑上相邻的两个元素在物理位置上也相邻。

特点：

  1. 逻辑相邻，物理也相邻。
  2. 任一数据元素可 随机存取。

通常用数组来描述线性表的顺序存储结构。
注意：线性表中元素的位序是从1开始的，而数组中元素的下标是从0开始的。


2.2.1 顺序表存储结构描述和特点
1. 静态存储方式
#define MaxSize 50				// 定义线性表的最大长度的值
// 静态分配数组顺序表的类型定义
typedef struct{
    ElemType data[MaxSize];		// 顺序表的元素类型、长度
    int length;					// 顺序表当前长度
}SqList;
2. 动态存储方式
#define InitSize 100
// 动态分配数组顺序表的类型定义
typedef struct{
    ElemType *data;				// 指示动态分配数组的指针
    int MaxSize, length;		// 数组的最大容量和当前个数
}SeqList;						

// C 的初始动态分配语句
L.data = (ElemType*)malloc(sizeof(ElemType) * InitSize);

// C++的初始动态分配语句
L.data = new ElemType[InitSize];

一维数组是可以静态分配，也可以是动态分配的。（不管是哪种分配方式，都属于顺序存储结构，物理结构没有变化，依然是随机存取方式，只是分配的空间大小可以在运行时动态决定。）

  • 静态分配当空间占满的时候，容易产生溢出；
  • 动态分配中存储数组的空间是在程序执行过程中通过动态存储分配语句分配的，空间占满，还可以开辟一块更大的存储空间替换原来的存储空间，不需要一次性划分所有空间。

静态动态的区别也就是用不用指针，指针就是为了间接访问，方便动态操作而设计的。用指针来指向数据域并且用指针进行动态分配即可实现“动态存储”。

关于malloc、free函数：
malloc、free
malloc会在内存中申请一整片连续的存储空间，并且返回指针。

动态分配基本操作实现：

初始化：

// 动态分配顺序表的初始化
void InitList(SqList &L) {
    L.data = (int *)malloc(InitSize * sizeof(int));
    L.length = 0;
    L.MaxSize = InitSize;
}

对 L 的三个成员变量进行赋值。

增加动态数组的长度：

void IncreaseSize(SqList &L, int len) {
    int *p = L.data;
    L.data = (int *)malloc((L.MaxSize+len)*sizeof(int));
    for (int i=0; i<L.length; i++) {
        L.data[i] = p[i];  // 将数据复制到新区域
    }
    L.MaxSize = L.MaxSize+len;  // 顺序表最大长度增加len
    free(p);  // 释放原来的内存空间
}

重新找到另外一块更大的区域，并且把之前的空间拿来，而且删除原来的空间。

  1. 时间开销大❗❗
  2. realloc 函数也可实现，malloc和free更底层。
3. 顺序表的优缺点

总是和表长length以及数组打交道（毕竟人家存储结构就是这俩🤦‍♂️）

优点：

  • 随机存取：通过 首地址 和 元素序号 可在时间 O(1) 内找到指定的元素。
  • 存储密度高：每个结点只存储数据元素。

缺点：

  • 静态分配数组拓展容量不方便，动态分配数组方式时间复杂度高。
  • 插入和删除操作需要移动大量元素。
  • 需要使用一整块地址连续的存储单元。（逻辑相邻的物理也相邻）

2.2.2 顺序表基本操作实现

基于静态分配数组的顺序表。

1. 插入操作

在表 L 的第 i 个位置插入 e。

Steps：

  1. 判断i的范围和空间是否已满

  2. 将 i 元素及之后的元素后移

  3. 在 i 插入 e

  4. 表长 +1

  5. 返回 true

从后往前，先挪开后插入

bool ListInsert(SqList &L, int i, ElemType e) {
    if (i<1 || i>L.length+1)  // 判断i的范围是否有效（此处判断理论上位置 i 是否和法，不是数组下标是否合法，所以是和1比较而不是和0; L.length+1表示最后一个元素的后一个位置）
        return false;
    if (L.length >= MaxSize)  // 判断当前存储空间是否已满（这就是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;  // 在位置i放入e（位置i对应L.data[i-1]）
    L.length++;	 // 表长+1
    return true;
}

不对 i 和 length 进行合法性检查的话，其他人用的时候，可能插到不合法位置，比如隔了n个插入到后面的位置，这样是不好的。（所以添加了if进行合法性判断，并且将返回数据类型改为bool，提高代码的健壮性。也因此注意关注代码的时候要关注最核心语句！！）

函数代码一般包括：

  1. 合法性判断
  2. 核心逻辑算法
  3. 良好的return

Question：for 循环为什么从L.length开始，不应该像 if 的条件表达式一样是L.length+1吗？

因为数组是从0开始，data[L.length]就是线性表的L.length+1的位置。

线性表插入平均时间复杂度：O(n)

计算过程：（Avg = 在每个位置 i 插入的概率 * 其对应的主语句执行次数）

∑ i = 1 n + 1 p i ( n − i + 1 ) = ∑ i = 1 n + 1 1 n + 1 ( n − i + 1 ) = 1 n + 1 ∑ i = 1 n + 1 ( n − i + 1 ) = 1 n + 1 n ( n + 1 ) 2 = n 2 \sum\limits_{i=1}^{n+1} p_i(n-i+1) = \sum\limits_{i=1}^{n+1}\frac{1}{n+1}(n-i+1) = \frac{1}{n+1} \sum\limits_{i=1}^{n+1}(n-i+1) = \frac{1}{n+1}\frac{n(n+1)}{2} = \frac{n}{2} i=1∑n+1​pi​(n−i+1)=i=1∑n+1​n+11​(n−i+1)=n+11​i=1∑n+1​(n−i+1)=n+11​2n(n+1)​=2n​

最好情况：在表尾插入（i=n+1），不需要后移，O(1)。

最坏情况：在表头插入（i=1），元素后移语句执行 n 次，O(n)。

2. 删除操作

删除 L 第 i 个位置的元素，并用 e 返回删除元素的值。

Steps：

  1. 判断 i 的范围
  2. 将被删的元素赋值给 e
  3. 将第 i 个位置后的元素前移（删除其实就是复制给 e，然后重新赋值为后继元素）
  4. 线性表长度-1

先拿出然后让后面的向前覆盖上

bool ListDelete(SqList &L, int i, ElemType &e){
    if (i<1 || i>L.length)  // （此处判断理论上位置 i 是否和法，不是数组下标是否合法，所以是和1比较）
        return false;
    e = L.data[i-1];  // 数组下标=真实位序-1
    for (int j = i; j < L.length; j++)  // 从i开始是没错的，因为下面是L.data[j-1] = L.data[j]，对应着数组的正确位置（=位序-1） 
        L.data[j-1] = L.data[j];
    L.length--;
    return true;
}

线性表删除平均时间复杂度：O(n)

和插入相同，表头删除是O(n)，表尾删除是O(1)，平均的话O(n)。

计算过程略。

3. 按位查找

在 L 中找第 i 个元素并返回。

Steps：

注意数组下标和位序 i 的区别，返回 data[i-1]。

// 按位查找
ElemType GetElem(SqList L, int i) {
	if (i<1 || i>L.length)    				
        return false;
	return L.data[i-1];  // 注意数组下标和位序i的区别；动态分配数组顺序表也可以这样写，只不过含义变为：指针+[]用法，相当于指针的运算。 
}
4. 按值查找（顺序查找）

在 L 中找第一个元素值等于 e 的元素，返回位置。

Steps：

  1. 循环比较并返回 i+1
  2. 循环外返回 0
// 查找（按值查找）
int LocateElem(SqList L, ElemType e) {
    int i;
    for (i = 0; i < L.length; i++)  // 顺序查找（数组从0开始）
        if (L.data[i] == e)  // int\char\double\float等可以直接用运算符== 进行比较；结构体不可以用==直接比较，可以用C++的运算符重载，或者成员变量一一比较 
            return i+1;  // 返回和e相等的元素的逻辑位序 i+1（数组下标为i，那位置就是i+1）
	return 0;  // 退出循环说明查找失败，返回0
}

线性表按值查找平均时间复杂度：O(n)

查找的元素在表头O(1)，查找的元素在表尾O(n)，平均的话O(n)。

计算过程略。

5. 初始化
// 初始化为空表
bool ListInit(SqList &L) {
	for (int i = 0; i < MaxSize; i++)  // 清除脏数据，不清除的话防君子不防小人（可以不写） 
		L.data[i] = 0;
	L.length = 0;  // 初始长度为0 
	return true;
} 
/*
 * 防君子不防小人：
 * 君子都是用基本操作来访问顺序表的，小人可能直接去printf数据。 
 */


// 初始化(赋值为数组的值)
void ListAssign(SqList &L, ElemType Arr[], int len) {  // 由于形参数组只是个指针，无法传送求数组长度信息，所以只能额外添加数组长度参数 
	int i;
	for (i = 0; i < len; i++)
		L.data[i] = Arr[i];
	L.length = len;
}
6. 判空

判断是不是为空

// 判空
bool Empty(SqList L) {
	if (L.length == 0)
		return true;
	else
		return false;
}


// 或者这样写
bool Empty(SqList L) {
	return (L.length == 0);
}
7. 打印
  1. 合法性判断
  2. 循环遍历输出data[i]
// 打印
void ListPrint(SqList L) {
	if (L.length > 0) {
		int i;
		for (i = 0; i < L.length; i++) 
			printf("%d ", L.data[i]);
		printf("\n");
	}	
	else
		printf("List is empty.\n"); 
}

2.2.3 顺序表总结

一、顺序表

  • 可根据序号随机存取；（按位置查找 O(1)）
  • 表尾插入删除不用移动任何元素，很快 O(1)；表头/除表尾外其他位置插入删除需要移动大量元素，很慢 O(n)。
  • 按值查找 O(n)

二、为什么顺序表的插入、删除函数设计的时候都要有位置 i 这个参数呢？

考虑到基础操作的话，插入，肯定是插入到某个位置；删除，也是删除某个位置的元素；

像“删除表中某元素”这样的操作，可以规划到“不常用/非基础操作”。

而且顺序表的优势，就是“顺序”，可根据位置 i 随机存取。

三、算法设计注意：

  1. 数组下标i 和 位序i 的区别
  2. 注意参数是否引用
  3. 算法要有健壮性，要有 i 的合法性判断
  4. 核心逻辑算法
  5. 良好的return

全部代码（复制可直接运行）

/*
 * 顺序表存储结构及基本操作实现 
 * 纯享版
 * 可直接运行
 */

#include <stdio.h>

#define MaxSize 50				
typedef int ElemType; 		


// 顺序表的类型定义(静态分配数组方式)
typedef struct{
    ElemType data[MaxSize];		
    int length;					
}SqList;


// 初始化为空表
bool ListInit(SqList &L) {
	for (int i = 0; i < MaxSize; i++)
		L.data[i] = 0;
	L.length = 0;
	return true;
} 


// 判空
bool Empty(SqList L) {
	if (L.length == 0)
		return true;
	else
		return false;
} 


// 赋值（将数据域赋值为数组） 
bool ListAssign(SqList &L, ElemType Arr[], int len) {  // 由于形参数组只是个指针，无法传送求数组长度信息，所以只能添加数组长度参数 
	if (len<1 || len>MaxSize)
        return false;
	for (int i = 0; i < len; i++)
		L.data[i] = Arr[i];
	L.length = len;
	return true;
} 


// 插入 
bool ListInsert(SqList &L, int i, ElemType e) {
    if (i<1 || i>L.length+1)
        return false;
    if (L.length >= MaxSize)
        return false;
    for (int j = L.length; j >= i; j--)
        L.data[j] = L.data[j-1];
	L.data[i-1] = e;
    L.length++;	
    return true;
}


// 删除
bool ListDelete(SqList &L, int i, ElemType &e) {
    if (i<1 || i>L.length)
        return false;
    e = L.data[i-1];
    for (int j = i; j < L.length; j++) 
        L.data[j-1] = L.data[j];
    L.length--;
    return true;
}    


// 按位查找
ElemType GetElem(SqList L, int i) {
	if (i<1 || i>L.length)    				
        return false;
	return L.data[i-1];
}
 

// 查找（按值查找）
int LocateElem(SqList L, ElemType e) {
    for (int i = 0; i < L.length; i++)	
        if (L.data[i] == e)
            return i+1;	
	return 0;
}


// 打印
void ListPrint(SqList L) {
	if (L.length > 0) {
		for (int i = 0; i < L.length; i++)
			printf("%d ", L.data[i]);
		printf("\n");
	}	
	else
		printf("List is empty.\n"); 
}


/* 测试——主函数 */
int main()
{
	SqList list1;
	int a[10] = {1,2,3,4,5,6,7,8,9,10};
	int e = 11;
	int temp;
	ListInit(list1);
	if (Empty(list1))
		printf("list1 is empty.\n");
	else
		printf("list1 is not empty.\n");
	ListAssign(list1, a, 10);
	ListPrint(list1);
	ListInsert(list1, 2, e);
	ListPrint(list1);
	ListDelete(list1, 2, e);
	ListPrint(list1);
	printf("list1 第二个位置上的元素是：%d\n", GetElem(list1, 2));
	temp = LocateElem(list1, 2);
	if(temp)
		printf("2 在list1中的位置是：%d\n");
	else	
		printf("2 不在list1中。\n");
	printf("测试结束。");
	return 0;
}

运行结果：
Result

不难看出，其实顺序表就是数组，外加一个表示当前表长的length，没错，就是这么简单。😎

线性表的定义和基本操作

LiYikou
关注
专栏目录
数据结构 顺序表的基本操作实现 c语言
cdwzl的博客
03-13 1398
复习过程中的回顾（纯C语言版），如有不足，请批评指正。 /*顺序表*/ #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define ElemType int #define INITSIZE 80 #define INCRESEMENT 10 typedef struct{ ElemType *elem; //动态申请空间 in...
数据结构 - 顺序表基本操作
qq_61386381的博客
05-07 2763
前言： 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。 顺序表一般可以分为：..
《数据结构》顺序表基本操作实现
weixin_40473591的博客
12-03 264
# include "stdio.h" # include "stdlib.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -1 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 typedef int Status; typ...
【数据结构】顺序表的基本操作的实现
Y0704__00的博客
10-31 358
用静态分配的一维数组和动态分配的一维数组来完成实验题目
顺序表的实现与基本操作
qq_50330658的博客
09-06 1080
顺序表的实现与基本操作（c/c++）
数据结构 - 顺序表及其基本操作的实现
Nonpc的博客
03-31 2402
线性表的顺序存储结构 顺序表定义 线性表的顺序存储结构, 指的是用一段地址连续的存储单元依次存储线性表的数据元素. 线性表的(a1,a2,…,an)的顺序存储示意图如下: 顺序表的存储方式         线性表的顺序存储结构,就是在内存中找一块地方,通过占位的形式,把一定的空间占用,然后把相同数据类型的数据元素依次...
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
【C数据结构】顺序表的基本操作
winkxw的博客
03-18 1832
【数据结构】顺序表的基本操作（C语言实现）
数据结构——顺序表（定义详解及建立顺序表与实现其操作）
Three__Curry的博客
01-26 8343
数据结构——顺序表（定义详解及创立顺序表并操作） 顺序表定义：顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 简单来说，顺序表存储有两个特点： 1.逻辑顺序和物理顺序一致。 2.数据元素之间的关系
顺序表上的基本操作实现
07-22
在顺序存储结构实现基本操作：初始化、创建、插入、删除、查找、遍历、逆置、合并运算。
【数据结构】——顺序表基本操作的实现详解
qq_46994783的博客
09-06 570
引言 线性表是最基本、最简单、也是最常用的一种数据结构。 线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。 线性表是一种在实际中广泛使用的数据结构，常见的线性表： 顺序表、链表、栈、队列、字符串。… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通
数据结构之顺序表基本操作实现C语言
qq_44084209的博客
12-04 515
数据结构之顺序表基本功能实现 本篇文章实现了数据结构严蔚敏版上顺序表的基本操作，以及简单应用比如说实现两个有序顺序表的合并（归并）。 文章目录数据结构之顺序表基本功能实现前言一、顺序表的定义2.顺序表的特点二、顺序表上基本操作的实现1.程序代码2.重点代码解析总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、顺序表的定义
顺序表的基本操作及实现（三）
金啊豆嘞的博客
09-09 352
这篇中，线性表的长度是可变的，且最大存储空间随问题的不同而不同，值C语言中可用动态分配的一维数组。 （由于引用传参数，所以源文件需要.cpp后缀，即c++文件存储。） 即使是动态分配内存，分配的内存也必然是一段连续的地址空间，因为这是顺序表，这是由其性质即可知道的。 注意此时的 ElemType *data;,指针变量data指向的是线性表连续存储空间的首地址，即通过此指针可以顺序的找到所有存储空...
数据结构中顺序表的基本操作实现C语言代码
黑锤的博客
01-08 5824
#include <iostream> #include <stdio.h> #include <string.h> #include <stdlib.h> #define MAXSIZE 100 typedef struct//创建结构体 { int *elem; int length; }Sqlist; int chushihu...
【数据结构】C语言实现顺序表的基本操作
最新发布
蒙奇D索大的博客
12-25 2226
【数据结构】线性表（3） 详细介绍了通过C语言实现顺序表基本操作——增删改查
数据结构-顺序表基本功能的实现
qq_61167424的博客
03-23 2991
详细的基本功能实现（顺序表其实一点也不难）
顺序表的实现及其基本操作
Bit_Dong的博客
06-06 1531
线性表的顺序存储又称顺序表。它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。
顺序表的基本操作与实现
Vagrant_pursue的博客
10-19 905
前言 顺序表存储结构容易实现随机存取线性表的第i个数据元素的操作，但在插入或删除操作时要移动大量的数据元素，适合数据相对稳定的线性表。 提示：以下是顺序表的基本操作和实现代码，下面案例可供参考 1.头文件 代码如下（示例）： #include<stdio.h> #include<stdlib.h> #include<math.h> #define FALSE 0 #define TRUE 1 #define ERROR 0 #define OK 1 //线性表的存储
数据结构实现：顺序表与链表操作源码解析
本资源是一份关于数据结构中顺序表和链表的实验报告，旨在帮助学生掌握线性表的基本概念、顺序存储和链式存储的实现，以及相关操作算法。实验涵盖了创建、显示、查找、插入、删除等基本操作，并通过C++语言编写了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

LiYikou

您的支持是我最大的动力~♥

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

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

打赏作者

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

抵扣说明：

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

余额充值