数据结构——顺序表

最新推荐文章于 2023-03-28 19:52:37 发布
最新推荐文章于 2023-03-28 19:52:37 发布
阅读量1.3k 收藏 5
点赞数 2
分类专栏： C语言 数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TTTSEP9TH2244/article/details/122521846
版权

一、实验目的

  1. 理解和掌握线性表的类型定义方法。
  2. 掌握顺序表中的基本运算，包括顺序表的创建、元素的添加、删除，判空及判满等基本操作。

二、实验要求

【项目1 – 验证性实验：顺序表的基本运算】

建立顺序表运算的算法库
算法库包括两个文件：
头文件：list.h，包含定义顺序表数据结构的代码、宏定义、要实现算法的函数的声明；
源文件：list.cpp，包含实现各种算法的函数的定义；
请采用程序的多文件组织形式，建立如上的两个文件，另外再建立一个源文件，编写main函数，完成相关的测试工作：
为了简单，ElemType为int型
1.初始化一个顺序表；
2.依次插入多个元素；
3.输出顺序表；
4.输出顺序表的长度；
5.判断顺序表是否为空；
6.输出顺序表第4个元素；
7.输出一个指定元素的位置；
8.在指定的位置插入一个元素；
9.输出顺序表；
10.释放顺序表。

程序代码：
List.h:

#ifndef LIST_H_INCLUDED
#define LIST_H_INCLUDED

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100
typedef int ElemType;
typedef struct
{
    ElemType data[MaxSize];
    int length;
} SqList;
void CreateList(SqList *&L, ElemType a[], int n);//用数组创建线性表
void InitList(SqList *&L);//初始化线性表InitList(L)
void DestroyList(SqList *&L);//销毁线性表DestroyList(L)
bool ListEmpty(SqList *L);//判定是否为空表ListEmpty(L)
int ListLength(SqList *L);//求线性表的长度ListLength(L)
void DispList(SqList *L);//输出线性表DispList(L)
bool GetElem(SqList *L,int i,ElemType &e);//求某个数据元素值GetElem(L,i,e)
int LocateElem(SqList *L, ElemType e);//按元素值查找LocateElem(L,e)
bool ListInsert(SqList *&L,int i,ElemType e);//插入数据元素ListInsert(L,i,e)
bool ListDelete(SqList *&L,int i,ElemType &e);//删除数据元素ListDelete(L,i,e)#endif // LIST_H_INCLUDED

//void myInsert(SqList *&L, ElemType x);
//void myDelete(SqList *&L, ElemType x);
//void mySwap(SqList *&L);
#endif

List.cpp:

#include <stdio.h>
#include <malloc.h>
#include "list.h"

//用数组创建线性表
void CreateList(SqList *&L, ElemType a[], int n)
{
    int i;
    L=(SqList *)malloc(sizeof(SqList));
    for (i=0; i<n; i++)
        L->data[i]=a[i];
    L->length=n;
}

//初始化线性表InitList(L)
void InitList(SqList *&L)   //引用型指针
{
    L=(SqList *)malloc(sizeof(SqList));
    //分配存放线性表的空间
    L->length=0;
}

//销毁线性表DestroyList(L)
void DestroyList(SqList *&L)
{
    free(L);
}

//判定是否为空表ListEmpty(L)
bool ListEmpty(SqList *L)
{
    return(L->length==0);
}

//求线性表的长度ListLength(L)
int ListLength(SqList *L)
{
    return(L->length);
}

//输出线性表DispList(L)
void DispList(SqList *L)
{
    int i;
    if (ListEmpty(L)) return;
    for (i=0; i<L->length; i++)
        printf("%d ",L->data[i]);
    printf("\n");
}

//求某个数据元素值GetElem(L,i,e)
bool GetElem(SqList *L,int i,ElemType &e)
{
    if (i<1 || i>L->length)  return false;
    e=L->data[i-1];
    return true;
}

//按元素值查找LocateElem(L,e)
int LocateElem(SqList *L, ElemType e)
{
    int i=0;
    while (i<L->length && L->data[i]!=e) i++;
    if (i>=L->length)  return 0;
    else  return i+1;
}

//插入数据元素ListInsert(L,i,e)
bool ListInsert(SqList *&L,int i,ElemType e)
{
    int j;
    if (i<1 || i>L->length+1)
        return false;   //参数错误时返回false
    i--;            //将顺序表逻辑序号转化为物理序号
    for (j=L->length; j>i; j--) //将data[i..n]元素后移一个位置
        L->data[j]=L->data[j-1];
    L->data[i]=e;           //插入元素e
    L->length++;            //顺序表长度增1
    return true;            //成功插入返回true
}

//删除数据元素ListDelete(L,i,e)
bool ListDelete(SqList *&L,int i,ElemType &e)
{
    int j;
    if (i<1 || i>L->length)  //参数错误时返回false
        return false;
    i--;        //将顺序表逻辑序号转化为物理序号
    e=L->data[i];
    for (j=i; j<L->length-1; j++) //将data[i..n-1]元素前移
        L->data[j]=L->data[j+1];
    L->length--;              //顺序表长度减1
    return true;              //成功删除返回true
}

Main.cpp:

#include <iostream>
#include <stdio.h>
#include "list.h"
using namespace std;

int main()
{
    SqList *L;
    InitList(L);
    int a[]={1,2,3,4,5,6,7,8,9,10};
    int n=10;
    printf("初始化顺序表后：\n");
    CreateList (L, a, n);
    DispList(L);
    printf("依次插入多个元素后：\n");
    ListInsert(L,11,11);
    ListInsert(L,12,12);
    ListInsert(L,13,13);
    ListInsert(L,14,14);
    DispList(L);
    printf("线性表长度为：%d\n",ListLength(L));
    if(ListEmpty(L))
        printf("该表为空表\n");
    else printf("该表不为空表\n");
    ElemType m;
    if(GetElem(L,4,m))
        printf("第4个元素值为：%d\n",m);
    printf("元素值为10的位置为：%d\n",LocateElem(L,10));
    printf("在指定位置插入一个元素后：\n");
    ListInsert(L,15,15);
    DispList(L);
    printf("输出顺序表\n");
    printf("释放顺序表\n");
    DestroyList(L);
    return 0;
}

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

【项目2 – 顺序表应用】

定义一个采用顺序结构存储的线性表，设计算法完成下面的工作：

  1. 设计一个算法，将元素x插入到一个有序(从小到大排序)顺序表的适当位置，并保存有序性。
  2. 删除线性表中值为x的元素，要求算法时间复杂度为为O(n)，空间复杂度为O(1)。
  3. 将所有奇数移到所有偶数的前面，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。

【提示】：
（1）充分利用前面建立的算法库解决建立顺序表、输出线性表的问题；
（2）为保证复杂度的要求，设计算法并用专门的函数实现算法；
（3）每项工作写一个程序.

程序代码：
List.h:

#ifndef LIST_H_INCLUDED
#define LIST_H_INCLUDED

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100
typedef int ElemType;
typedef struct
{
    ElemType data[MaxSize];
    int length;
} SqList;
void CreateList(SqList *&L, ElemType a[], int n);//用数组创建线性表
void InitList(SqList *&L);//初始化线性表InitList(L)
void DestroyList(SqList *&L);//销毁线性表DestroyList(L)
bool ListEmpty(SqList *L);//判定是否为空表ListEmpty(L)
int ListLength(SqList *L);//求线性表的长度ListLength(L)
void DispList(SqList *L);//输出线性表DispList(L)
bool GetElem(SqList *L,int i,ElemType &e);//求某个数据元素值GetElem(L,i,e)
int LocateElem(SqList *L, ElemType e);//按元素值查找LocateElem(L,e)
bool ListInsert(SqList *&L,int i,ElemType e);//插入数据元素ListInsert(L,i,e)
bool ListDelete(SqList *&L,int i,ElemType &e);//删除数据元素ListDelete(L,i,e)#endif // LIST_H_INCLUDED

void myInsert(SqList *&L, ElemType x);
void myDelete(SqList *&L, ElemType x);
void mySwap(SqList *&L);
#endif

List.cpp:

#include <stdio.h>
#include <malloc.h>
#include "list.h"

//用数组创建线性表
void CreateList(SqList *&L, ElemType a[], int n)
{
    int i;
    L=(SqList *)malloc(sizeof(SqList));
    for (i=0; i<n; i++)
        L->data[i]=a[i];
    L->length=n;
}

//初始化线性表InitList(L)
void InitList(SqList *&L)   //引用型指针
{
    L=(SqList *)malloc(sizeof(SqList));
    //分配存放线性表的空间
    L->length=0;
}

//销毁线性表DestroyList(L)
void DestroyList(SqList *&L)
{
    free(L);
}

//判定是否为空表ListEmpty(L)
bool ListEmpty(SqList *L)
{
    return(L->length==0);
}

//求线性表的长度ListLength(L)
int ListLength(SqList *L)
{
    return(L->length);
}

//输出线性表DispList(L)
void DispList(SqList *L)
{
    int i;
    if (ListEmpty(L)) return;
    for (i=0; i<L->length; i++)
        printf("%d ",L->data[i]);
    printf("\n");
}

//求某个数据元素值GetElem(L,i,e)
bool GetElem(SqList *L,int i,ElemType &e)
{
    if (i<1 || i>L->length)  return false;
    e=L->data[i-1];
    return true;
}

//按元素值查找LocateElem(L,e)
int LocateElem(SqList *L, ElemType e)
{
    int i=0;
    while (i<L->length && L->data[i]!=e) i++;
    if (i>=L->length)  return 0;
    else  return i+1;
}

//插入数据元素ListInsert(L,i,e)
bool ListInsert(SqList *&L,int i,ElemType e)
{
    int j;
    if (i<1 || i>L->length+1)
        return false;   //参数错误时返回false
    i--;            //将顺序表逻辑序号转化为物理序号
    for (j=L->length; j>i; j--) //将data[i..n]元素后移一个位置
        L->data[j]=L->data[j-1];
    L->data[i]=e;           //插入元素e
    L->length++;            //顺序表长度增1
    return true;            //成功插入返回true
}

//删除数据元素ListDelete(L,i,e)
bool ListDelete(SqList *&L,int i,ElemType &e)
{
    int j;
    if (i<1 || i>L->length)  //参数错误时返回false
        return false;
    i--;        //将顺序表逻辑序号转化为物理序号
    e=L->data[i];
    for (j=i; j<L->length-1; j++) //将data[i..n-1]元素前移
        L->data[j]=L->data[j+1];
    L->length--;              //顺序表长度减1
    return true;              //成功删除返回true
}
void myInsert(SqList *&L, ElemType x)
{
    int i =0;
    while (i<L->length && L->data[i]) i++;
    i++;
    ListInsert(L,i,x);
}
void myDelete(SqList *&L, ElemType x)
{
    int k=0;
    for(int i=0;i<L->length;i++)
    {
        if(L->data[i]==x)
            k++;
        else
            L->data[i-k]=L->data[i];
    }
    L->length = L->length-k;
}
void mySwap(SqList *&L)
{
    int i=0;
    int j=L->length - i;
    while(i<j)
    {
        while(i<j && L->data[i]%2 == 1) i++;
        while(i<j && L->data[j]%2 == 0) j--;
        int temp = L->data[i];
        L->data[i] = L->data[j];
        L->data[j] = temp;
    }
}

Main.cpp:

#include <iostream>
#include <stdio.h>
#include "list.h"
using namespace std;

int main()
{
    SqList *L;
    InitList(L);
    int a[]={1,2,3,4,5,6,7,8,9,10};
    int n=10;
    printf("初始化顺序表后：\n");
    CreateList (L, a, n);
    DispList(L);
    printf("依次插入多个元素后：\n");
    ListInsert(L,11,11);
    ListInsert(L,12,12);
    ListInsert(L,13,13);
    ListInsert(L,14,14);
    DispList(L);
    printf("线性表长度为：%d\n",ListLength(L));
    if(ListEmpty(L))
        printf("该表为空表\n");
    else printf("该表不为空表\n");
    ElemType m;
    if(GetElem(L,4,m))
        printf("第4个元素值为：%d\n",m);
    printf("元素值为10的位置为：%d\n",LocateElem(L,10));
    printf("在指定位置插入一个元素后：\n");
    ListInsert(L,15,15);
    DispList(L);
    //2.1
    printf("将x插入到顺序表：\n");
    myInsert(L,15);
    DispList(L);
    printf("删除值为x的元素：\n");
    myDelete(L,10);
    myDelete(L,5);
    DispList(L);
    printf("奇数前移，偶数后移：\n");
    mySwap(L);
    DispList(L);
    printf("释放顺序表：\n");
    DestroyList(L);
    return 0;
}

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

爱吃苹果的派大星
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验——顺序表
12-22
数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表
线性表之顺序表插入元素
dande__lion的专栏
09-15 2080
问：设计一个算法，将X插入到一个有序的线性表的适当位置上，并保持线性表的有序性。 答：通过比较在顺序表L中找到插入X的位置i，将该位置以及后面的元素后移一个位置，将X插入到位置i中，最后将L的长度增1。 #include     //包含头文件   #include using namespace std; typedef struct         //定义顺序表   {
C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
07-03
C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
折半查找算法在顺序表中插入一个元素讲解.pdf
11-07
折半查找算法在顺序表中插入一个元素讲解.pdf
数据结构与算法c++实现 两个顺序表的元素严格单调递增，将其共同元素保存到新顺序表中，且为递增排序
06-04
数据结构与算法 c++实现 改变顺序表的元素次序，两个顺序表的元素严格单调递增，将其共同元素保存到新顺序表中，且为递增排序可直接运行 代码有批注 适合大二初学数据结构与算法
关于顺序表的算法题(C语言实现)
weixin_46390041的博客
04-19 5775
1、在顺序表L中查找第一个值最大的元素，并删除该元素。 void fun(SqList *&L){ int i,j=0; for (i=1;i<L->length;i++) if (L->data[i]>L->data[j]) j=i; for (i=j;i<L->length-1;i++) L->data[i]=L->data[i+1]; L->length--; } 2、在顺序表L中查找
C 语言非数值计算常用经典算法
hhappy0123456789的博客
12-04 401
C 语言非数值计算常用经典算法
顺序表如何插入元素？ 看这里！！
qq_63179750的博客
09-21 3474
顺序表的插入
排序：直接插入排序（由大到小排序）
weixin_63381305的博客
03-28 1084
直接插入排序是一种最简单的排序方法，其基本操作是将需要排序的元素插入到已排好的有序表序列中，从而得到一个完整的有序序列。最坏情况全部反序，内层每次遍历已排序部分，最坏时间复杂度为O ( n 2 ) O(n^2)O(n。最好情况就是全部有序，此时只需遍历一次，最好的时间复杂度为O ( n ) O(n)O(n)综上，因此直接插入排序的平均时间复杂度为O ( n 2 ) O(n^2)O(n。注意：初始的侯有序区中的元素为第一个元素，其他元素为无序区中的元素。平均的空间复杂度为：O ( 1 ) O(1)O(1)
排序算法——插入排序
qq_46127735的博客
09-12 117
介绍 插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。 插入排序法思想 插入排序（Insertion Sorting）的基本思想是：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有 序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排 序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表 插入排序思路图 例子： 有一群小牛, 考试成绩分别是 101, 34, 11
shunxubiao.rar_shunxubiao_输入一组整型元素序列，建立顺序表
09-19
(1)．输入一组整型元素序列，建立顺序表。 (2)．实现该顺序表的遍历。 (3)．在该顺序表中顺序查找某一元素,查找成功返回1,否则返回0。 (4)．判断该顺序表中元素是否对称,对称返回1,否则返回0。 (5)．实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。 (6)．输入整型元素序列利用有序表插入算法建立一个有序表。 (7)．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。 (8)．编写一个主函数,调试上述算法。
小白算法积累——顺序表6#有序顺序表 +删除重复元素
01-07
题目：从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。 关键字：有序顺序表 删除重复元素 思路 关注：因为是有序表，所以值相同的元素一定在连续的位置上， 用类似于直接插入排序的思想 1.初始时将第一个元素 视为 非重复的有序表的首元素 需要变量：收入元素下标 i,从0开始 2.利用循环遍历，依次判断后面的元素是否与 前面非重复有序表（已整理好的表）的最后一个元素相同： a.相同则跳过 b.不相同则收入 需要变量：扫描原表所有元素下标 j，从1开始，因为已经默认把第一个元素a[0]收入了,不需要扫描了 #提前考虑特殊情况（出错情况）： 空表 bool Delete_Same(
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
注：分为三个内容：顺序表、单链表、运行结果。代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-...
数据结构习题（记录顺序表）
LPAODEKUAIDE的博客
01-05 6153
1.设计一个算法，将元素x插入到一个有序（从小到大排序）顺序表的适当位置，并保持有序性。 bool ListInsert(Sqlist *&L,int i,ElemType x) { int i=0,j; while(ilength&&L->data[i]<x) i++; for(j=L->length-1;j>=i;j--) L->data[j+1]=L->data[j]
【数据结构】顺序表的应用（3）（C语言）
( :3 )
09-23 2740
问题： 已知一个顺序表中的各节点值是从大到小有序的，设计一个算法，插入一个值为x的节点，使顺序表中的节点仍然是从小到大有序的。 头文件与该头文件一样：【数据结构】顺序表的实现（C语言） #include "stdio.h" #include "sequlist.h" int main () { sequence_list slt; int length,aa,i; ...
已知顺序表中元素值递增有序。 用算法实现将元素x查到表中适当的位置上，以保持顺序表的有序性。
weixin_45609725的博客
07-28 3760
已知顺序表中元素值递增有序。用算法实现将元素x查到表中适当的位置上，以保持顺序表的有序性。 第一种写法： //已知顺序表中元素值递增有序。用算法实现将元素x查到表中适当位置上，以保持顺序表的有序性 #include"stdio.h" #define DATATYPE1 int #define MAXSIZE 100 typedef struct { DATATYPE1 datas[MAXSIZE]; int last; }SEQUENLIST; void insert_x_seqlist(SEQUEN
C语言利用直接插入排序算法，将顺序表L中的元素从小到大进行排序
weixin_35755188的博客
01-01 1186
直接插入排序的原理是每次将待排序的数据插入到已经排好序的序列中，从而得到一个新的、个数加一的有序序列。具体实现方法如下： 首先，将第一个元素看作是已经排好序的序列，然后从第二个元素开始，依次将每个元素插入到已经排好序的序列中，直到最后一个元素。 C语言代码如下： void direct_insert_sort(int L[], int n) { int i, j; for (i =...
Java数据结构——用顺序表编写一个简易通讯录
最新发布
05-15
好的，下面是用Java顺序表实现简易通讯录的代码： 首先，在Java中需要定义一个类来表示通讯录中的每一个联系人，这个类包含联系人的姓名和电话号码两个属性： ```java public class Contact { private String ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值