王道数据结构精简笔记——顺序表(附完整工程)

于 2023-07-09 14:53:28 发布
阅读量290 收藏 4
点赞数 1
分类专栏： 王道数据结构精简笔记 文章标签： 数据结构 笔记 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53830825/article/details/131622754
版权

一、顺序表的定义

顺序表——用顺序存储的方式实现线性表。（逻辑相邻——>物理相邻）

1. 顺序表的实现——静态分配

#define MaxSize 10				//定义最大长度
typedef struct{
    ElemType data[MaxSize];		// 用静态的“数组”存放数据元素
    int length;					// 顺序表的当前长度
}SqList;						// 顺序表的类型定义（静态分配方式）

完整例子：

#include <stdio.h>
#define MaxSize 10				// 定义最大长度
typdef struct{
    int data[MaxSize];			// 用静态的“数组”存放数据元素
    int length;					// 顺序表的当前长度
}SqList;						// 顺序表的类型定义

/* 基本操作——初始化表 */
void InitList(SqList &L){
    for(int i = 0; i < MaxSize; i++)
        L.data[i] = 0;			// 将所有数据元素设置为默认初始值(可省略)
    L.length = 0;				// 顺序表初始长度为0
}

int main(){
    SqList L;					// 声明一个顺序表
    InitList(L);				// 初始化顺序表
    
    /* 后续操作 */
    
    return 0;
}

2. 顺序表的实现——动态分配

#define InitSize 10				// 顺序表的初始长度
typedef struct{
    ElemType *data;				// 指示动态分配数组的指针
    int MaxSize;				// 顺序表的最大容量
    int length;					// 顺序表的当前长度
}SeqList;						// 顺序表的类型定义（动态分配方式）

完整例子：

#include <stdio.h>
#include <stdlib.h>
#define InitSize 10				// 顺序表的初始长度
typedef struct{
    ElemType *data;				// 指示动态分配数组的指针
    int MaxSize;				// 顺序表的最大容量
    int length;					// 顺序表的当前长度
}SeqList;						// 顺序表的类型定义（动态分配方式）

/* 初始化表 */
void InitList(SeqList &L){
    L.data = (int *)malloc(InitSize * sizeof(int));		// 用malloc函数申请一片连续的存储空间
    L.length = 0;
    L.MaxSize = InitSize;
}

/* 增加动态数组的长度 */
void IncreaseSize(SeqList &L, int len){
    // 指针p指向原本的L表
    int *p = L.data;			
    // L表重新申请了增加长度后的相应大小内存空间
    L.data = (int *)malloc((L.MaxSize + len) * sizeof(int));
    // 此时p指向旧内存空间，L指向新内存空间，数据仍在旧内存空间中
    for(int i = 0; i < L.length; i++){							
        L.data[i] = p[i];			// 将旧内存空间中的数据复制到新空间中
    }
    L.MaxSize = L.MaxSize + len;	// 更新顺序表的最大容量
    free(p);						// 释放旧的内存空间
}

int main(){
    SeqList L;
    InitList(L);
    
    /* ...... */
    
    IncreaseSize(L, 5);
    return 0;
}

顺序表特点：

  1. 随机访问
  2. 存储密度高
  3. 拓展容量不方便
  4. 插入、删除操作不方便

请添加图片描述

二、顺序表的插入删除（静态分配为例）

请添加图片描述

1. ListInsert(&L, i, e)

插入操作，在表L中的第i个位置上插入制定元素e。

#include <stdio.h>
#define MaxSize 10				// 定义最大长度
typdef struct{
    int data[MaxSize];			// 用静态的“数组”存放数据元素
    int length;					// 顺序表的当前长度
}SqList;						// 顺序表的类型定义

/* 基本操作——初始化表 */
void InitList(SqList &L){
    for(int i = 0; i < MaxSize; i++)
        L.data[i] = 0;			// 将所有数据元素设置为默认初始值(可省略)
    L.length = 0;				// 顺序表初始长度为0
}

void ListInsert(SqList &L, int i, int e){
    for(int j = L.length; j >= i; j--)		// 将第i个元素及之后的元素后移
        L.data[j] = L.data[j - 1];
    L.data[i - 1] = e;						// 在i位置放入e
    L.length ++;							// 长度+1
}

int main(){
    SqList L;					// 声明一个顺序表
    InitList(L);				// 初始化顺序表
    
    /* 后续操作 */
    
    return 0;
}

算法强壮性：

  1. 插入位序i应该在1到length+1之间
  2. 当前长度是否会超过最大长度

用bool函数实现(bool的返回值要么是true要么是false)

bool ListInsert(SqList &L, int i, int e){
    if (i < 1 || i > L.length + 1)		// 判断i的范围是否有效
        return false;
    if (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
    L.length++;							// 长度+1
    return true;
}

时间复杂度分析：

  1. 最好情况：新元素插入到表尾，i=n+1，循环0次；最好时间复杂度=O(1)
  2. 最坏情况：新元素插入到表头，i=1，循环n次；最坏时间复杂度=O(n)
  3. 平均情况：假设新元素插入到任何一个位置的概率相同，则平均循环次数=

n p + ( n − 1 ) p + ( n − 2 ) p + . . . . . . + 1 ⋅ p = [ n ( n + 1 ) / 2 ] ⋅ [ 1 / n + 1 ] = n / 2 np+(n-1)p+(n-2)p+......+1·p=[n(n+1)/2]·[1/n+1]=n/2 np+(n−1)p+(n−2)p+......+1⋅p=[n(n+1)/2]⋅[1/n+1]=n/2

​ 平均时间复杂度=O(n/2)=O(n)

2. ListDelete(&L, i, &e)

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

代码实现：

bool ListDelete(SqList &L, int i, int &e){
    if(i < 1 || i > L.length)				// 判断i的范围是否有效
        return false;
    e = L.data[i - 1];						// 将被删除的元素复制给e
    for(int j = i; j < L.length; j++)		// 将第i个位置后的元素前移
        L.data[j - 1] = L.data[j];
    L.length--;								// 线性表长度-1
    return true;
}

时间复杂度分析：

  1. 最好情况：删除表位元素，i=n，循环0次；最好时间复杂度=O(1)
  2. 最坏情况：删除表头元素，i=1，循环n-1次；最坏时间复杂度=O(n)
  3. 平均情况：假设删除任何一个元素的概率相同，平均循环次数为(n-1)/2，平均时间复杂度=O(n)

请添加图片描述

三、顺序表查找

请添加图片描述

1. GetElem(L, i)

按位查找操作。获取表L中第i个位置的元素的值。

ElemType GetElem(SqList L, int i){
    return L.data[i - 1];
}

时间复杂度：O(1)

2. LocateElem(L, e)

按值查找操作。在表L中查找具有给定关键字值的元素。

int LocateElem(SeqList L, ElemType e){
    for(int i = 0; i < L.length; i++)
        if(L.data[i] == e)
            return i + 1;
    return 0;
}

时间复杂度：

  1. 最好情况：目标元素在表头，循环1次；最好时间复杂度=O(1)
  2. 最坏情况：目标元素在表尾，循环n次；最坏时间复杂度=O(n)
  3. 平均情况：假设目标元素出现在任何一个位置的概率都相同，平均循环次数为(n+1)/2；平均时间复杂度=O(n)

请添加图片描述

整合代码示例

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10                                          // 定义表最大长度
#define InitSize 10                                         // 定义表初始长度

/* 静态分配方式定义 */
typedef struct{
    int data[MaxSize];                                      // 存放数据元素
    int length;                                             // 当前表长
}SqList;

/* 动态分配方式定义 */
typedef struct{
    int *data;                                              // 指针指向动态分配数组
    int DMaxSize;                                           // 表的最大容量
    int length;                                             // 当前表长
}SeqList;

/* 初始化表——静态 */
void InitJList(SqList &L)
{
    for(int i = 0; i < MaxSize; i++)
        L.data[i] = 0;                                      // 表中所有元素默认为0
    L.length = 0;                                           // 表长为0
}

/* 初始化表——动态 */
void InitDList(SeqList &L)
{
    L.data = (int *)malloc(InitSize * sizeof(int));		// 用malloc函数申请一片连续的存储空间
    L.length = 0;
    L.DMaxSize = InitSize;
}

/* L1顺序表插入 */
bool SListInsert(SqList &L, int i, int e)
{
    if (i < 1 || i > L.length + 1)		// 判断i的范围是否有效
        return false;
    if (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
    L.length++;							// 长度+1
    return true;
}

/* L1插入实现 */
void SteListInsert(SqList &L)
{
    int i, e;
    printf("在第几个位置插入几？\n");
    scanf("%d %d",&i, &e);
    if(SListInsert(L, i, e))
    {
        printf("插入成功\n");
        printf("L1表的第%d个位置的值为%d\n", i, L.data[i-1]);
    }
    else
        printf("插入错误\n");
    printf("\n");
}

/* L2顺序表插入 */
bool LListInsert(SeqList &L, int i, int e)
{
    if (i < 1 || i > L.length + 1)		// 判断i的范围是否有效
        return false;
    if (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
    L.length++;							// 长度+1
    return true;
}

/* L2插入实现 */
void LivListInsert(SeqList &L)
{
    int i, e;
    printf("在第几个位置插入几？\n");
    scanf("%d %d",&i, &e);
    if(LListInsert(L, i, e))
    {
        printf("插入成功\n");
        printf("L2表的第%d个位置的值为%d\n", i, L.data[i-1]);
    }
    else
        printf("插入错误\n");
    printf("\n");
}

/* L1顺序表删除 */
bool SListDelete(SqList &L, int i, int &e)
{
    if(i < 1 || i > L.length)				// 判断i的范围是否有效
        return false;
    e = L.data[i - 1];						// 将被删除的元素复制给e
    for(int j = i; j < L.length; j++)		// 将第i个位置后的元素前移
        L.data[j - 1] = L.data[j];
    L.length--;								// 线性表长度-1
    return true;
}

/* L1删除实现 */
void SteListDelete(SqList &L)
{
    int i, e;
    printf("要删除第几个元素？\n");
    scanf("%d", &i);
    if(SListDelete(L, i, e))
    {
        printf("删除成功！\n");
        printf("删除的元素为%d\n", e);
    }
    else
        printf("删除失败\n");
    printf("\n");
}

/* L2顺序表删除 */
bool LListDelete(SeqList &L, int i, int &e)
{
    if(i < 1 || i > L.length)				// 判断i的范围是否有效
        return false;
    e = L.data[i - 1];						// 将被删除的元素复制给e
    for(int j = i; j < L.length; j++)		// 将第i个位置后的元素前移
        L.data[j - 1] = L.data[j];
    L.length--;								// 线性表长度-1
    return true;
}

/* L2删除实现 */
void LivListDelete(SeqList &L)
{
    int i, e;
    printf("要删除第几个元素？\n");
    scanf("%d", &i);
    if(LListDelete(L, i, e))
    {
        printf("删除成功！\n");
        printf("删除的元素为%d\n", e);
    }
    else
        printf("删除失败\n");
    printf("\n");
}

/* L1按位查找 */
int SGetElem(SqList L, int i)
{
    if(i < 1 || i > L.length)
        return 0;
    else
        return L.data[i - 1];
}

/* L1按位查找实现 */
void SteGetElem(SqList L)
{
    int i;
    printf("要查找第几个元素？\n");
    scanf("%d", &i);
    if(SGetElem(L, i) != 0)
        printf("第%d个元素为%d\n", i, SGetElem(L, i));
    else
        printf("超出查询范围\n");
    printf("\n");
}

/* L2按位查找 */
int LGetElem(SeqList L, int i)
{
    if(i < 1 || i > L.length)
        return 0;
    else
        return L.data[i - 1];
}

/* L2按位查找实现 */
void LivGetElem(SeqList L)
{
    int i;
    printf("要查找第几个元素？\n");
    scanf("%d", &i);
    if(LGetElem(L, i) != 0)
        printf("第%d个元素为%d\n", i, LGetElem(L, i));
    else
        printf("超出查询范围\n");
    printf("\n");
}

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

/* L1按值查找实现 */
void SteLocateElem(SqList L)
{
    int e;
    printf("请输入需要查找的数值\n");
    scanf("%d", &e);
    if(SLocateElem(L, e) == 0)
        printf("未查询到此值\n");
    else
        printf("此值在第%d个位置\n",SLocateElem(L, e));
    printf("\n");
}

/* L2按值查找 */
int LLocateElem(SeqList L, int e)
{
    for(int i = 0; i < L.length; i++)
        if(L.data[i] == e)
            return i + 1;
    return 0;
}

/* L2按值查找实现 */
void LivLocateElem(SeqList L)
{
    int e;
    printf("请输入需要查找的数值\n");
    scanf("%d", &e);
    if(LLocateElem(L, e) == 0)
        printf("未查询到此值\n");
    else
        printf("此值在第%d个位置\n",LLocateElem(L, e));
    printf("\n");
}

/* L1打印整表 */
void PrintSListElem(SqList L)
{
    if(L.length == 0)
        printf("此表为空，请先插入数值\n");
    else
        for(int i = 0; i < L.length; i++)
            printf("第%d个值：%d\n", i+1, L.data[i]);
    printf("\n");
}

/* L2打印整表 */
void PrintLListElem(SeqList L)
{
    if(L.length == 0)
        printf("此表为空，请先插入数值\n");
    else
        for(int i = 0; i < L.length; i++)
            printf("第%d个值：%d\n", i+1, L.data[i]);
    printf("\n");
}

int main()
{
    int i;
    SqList L1;                                              // 声明顺序表（静态分配）
    SeqList L2;                                             // 声明顺序表（动态分配）
    InitJList(L1);                                          // 初始化静态分配顺序表
    InitDList(L2);                                          // 初始化动态分配顺序表

    while(1)
    {
        printf("请输入操作：\n");
        printf("1.L1表插入数值;\n");
        printf("2.L2表插入数值;\n");
        printf("3.L1表删除数值;\n");
        printf("4.L2表删除数值;\n");
        printf("5.L1表按位查找;\n");
        printf("6.L2表按位查找;\n");
        printf("7.L1表按值查找;\n");
        printf("8.L2表按值查找;\n");
        printf("9.打印L1表;\n");
        printf("10.打印L2表;\n");
        printf("11.退出;\n");
        scanf("%d", &i);
        switch(i)
        {
            case 1: SteListInsert(L1);      break;
            case 2: LivListInsert(L2);      break;
            case 3: SteListDelete(L1);      break;
            case 4: LivListDelete(L2);      break;
            case 5: SteGetElem(L1);         break;
            case 6: LivGetElem(L2);         break;
            case 7: SteLocateElem(L1);      break;
            case 8: LivLocateElem(L2);      break;
            case 9: PrintSListElem(L1);     break;
            case 10: PrintLListElem(L2);    break;
        }
        if(i == 11)
            break;
    }

    return 0;
}
这谁会？
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
王道考研数据结构顺序表代码
05-15
自己写的王道考研数据结构顺序表例题和习题代码，所有函数运行都没问题。
王道数据结构-线性表中顺序表的一些综合应用题 王道操作系统-PV操作综合大题总结
12-31
顺序表是一种基本的数据结构，它在线性表中存储元素的方式是连续的内存空间。这里我们主要关注如何在顺序表中进行高效地删除操作。 首先，我们来看第一个问题：删除顺序表中所有值为x的元素。题目要求时间复杂度为O...
王道数据结构(顺序表)
Admnbl的博客
10-02 1031
顺序表定义 #define MAX 100 typedef int Position; typdef struct{ ElemType data[MAX]; Position last; }List; 1.删除顺序表中最小的元素(值唯一),空出的元素由最后一个补 bool del_Min(List &amp;L,ElemType e){ if(L.length=...
王道考研数据结构--1.顺序表
最新发布
我是个好人呀，????
06-20 712
日期：2023.6.20书籍：2024年数据结构考研复习指导（王道考研系列）内容：静态存储实现顺序表，及其基本操作，初始化，增加，删除，查找，判空和遍历输出。
408王道数据结构（顺序表）1.9
今天敲代码了嘛？
05-18 575
线性表(a1,a2,a3,…,an)中的元素递增有序且按顺序存储于计算机内。 要求设计一算法，完成用最少时间在表中查找数值为x的元素，若找到则将其与后继元素位置相交换，若找不到则将其插入表中并使表中元素仍然递增有序 核心代码： //线性表(a1,a2,a3,...,an)中的元素递增有序且按顺序存储于计算机内。 //要求设计一算法，完成用最少时间在表中查找数值为x的元素，若找到则将其与后继元素位置相交换 //若找不到则将其插入表中并使表中元素仍然递增有序 #include <iostream&g
408王道数据结构（顺序表）1.12
今天敲代码了嘛？
05-20 2044
已知一个整数序列A=(a0，a1，…，an-1)，其中0≤ai<n(0≤i<n)。若存在ap1=ap2=…=apm=x且m>n/2（0≤pk<n，1≤k≤m），则称x为A的主元素。 例如A=(0，5，5，3，5，7，5，5)，则5为主元素；又如A=(0，5，5，3，5，1，5，7)，则A中没有主元素。 假设A中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出A的主元素。若存在主元素，则输出该元素；否则输出-1。要求： （1）给出算法的基本设计思想。 （2）根据.
王道考研——数据结构PPT.zip
08-21
1. **基本概念**：首先，PPT可能会介绍数据结构的基本概念，如数据、数据元素、数据对象、数据结构的定义，以及数据结构的分类，包括线性结构、非线性结构（如树形结构和图结构）等。 2. **线性结构**：线性结构...
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
王道数据结构与算法（笔记）
02-10
王道数据结构考研视频笔记，结合视频整理，详细整理了个章节知识点，便于学习，祝大家早日上岸！！！
王道数据结构课后题编程（顺序表）
任萌新的小生活
05-22 2044
以下问题都简述! 1.搜索顺序表，查找最小值元素，用最后的元素代替它。 思想：初始为第一个元素为最小值，遍历第2-n个元素，寻找最小值，并记录位置，遍历完成后替换。（为空则退出） bool delete_min(SqList &L) { int i; int Min,pos; if(L.length==0) return false; ...
数据结构c语言版 顺序表部分代码
03-01
源文件 博文链接：https://thebigforest.iteye.com/blog/43206
2019王道专业课：数据结构-计算机网络-操作系统-计算机组成原理（全四本，高清无水印）
04-09
2019王道专业课：数据结构-计算机网络-操作系统-计算机组成原理（全四本，高清无水印）
王道数据结构
08-28
最新版王道数据结构，高清PDF，可以下载打印，来的同学都有了解，不多解释，只求好评
王道数据结构.zip
05-13
王道考研数据结构2019、2020pdf，无水印
19王道数据结构
04-07
王道考研系列书籍--2019年数据结构考研复习指导 第1章 绪论 第2章 线性表 ...
408王道数据结构（顺序表）1.7
今天敲代码了嘛？
05-17 285
将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表 核心算法 //将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表 #include <iostream> #define ElemType int #define InitSize 50 using namespace std; typedef struct { ElemType *data; int MaxSize,length; }SeqList; void printList(SeqList L) {
王道数据结构代码——顺序表
计科小学生的博客
10-10 399
#include<stdio.h> #include<stdlib.h> #define max 100 typedef struct{ int *data; int maxsize,length; } sql; bool sqlinsert(sql &s,int i,int data)//线性表插入 ，时间复杂度O（n） { if(i<1||i>s.length+1) return false; if(s.length>=s.maxsize)
王道数据结构【顺序表】部分代码实现（C语言）
年少的勇气已经用完，剩下的就是三思而后行
07-31 1341
王道数据结构【顺序表】部分代码实现（C语言）
王道数据结构--顺序表代码实现整理
我叫鱿鱼须的博客
07-18 705
#include<stdio.h> #define MAXSIZE 50 #define ElemType int typedef struct{ ElemType data[MAXSIZE]; int length; }sqList; sqList S; // 声明全局变量 // 初始化 void InitSqList(sqList &S){ S.length = 0; } // 判断顺序表是否为空 bool isEmpty(sqList &S){ if(S.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值