数据结构入门----顺序表的基本操作

最新推荐文章于 2023-08-22 08:57:45 发布
最新推荐文章于 2023-08-22 08:57:45 发布
阅读量2.9k 收藏 27
点赞数 11
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1457346557/article/details/107122736
版权

一、实验目的
通过该实验，深入理解顺序表的逻辑结构、物理结构等概念，掌握顺序表基本操作的编程实现，注意顺序表插入、删除等操作过程中数据元素的移动现象，培养学生编写程序时，要考虑程序的强壮性，熟练掌握通过函数参数返回函数结果的办法。
二、实验内容
编程实现顺序表的基本操作，最好用菜单形式对应各个操作，使其编成一个完整的小软件。
三、主要源代码


#include <iostream>
#include <stdlib.h>

using namespace std;
#define list_insize 100
#define listincrase 10

typedef struct{
    int *p;//存储空间基址
    int len;//当前长度
    int lstsize;//当前分配的存储容量
}_list;

void xianshi(int i,string text);//界面格式化输出函数
int creatlist(_list &l);//初始化线性表
int destroylist(_list &l);//销毁线性表
int clearlist(_list &l);//清空线性表
int panduan(_list &l);//判断线性表是否为空
int get_list_length(_list &l);//获取线性表的长度
int get_list_select_value(_list &l,int q);//获取指定位置的值
int get_list_select_posization(_list &l,int q);//获取输入值的位置
int get_list_top(_list &l,int q);//前驱
int get_list_next(_list &l,int q);//后继
int insert_list_select_posization(_list &l,int i,int q);//在指定位置插入
int delete_lis_select_value(_list &l,int i);//删除指定位置元素
int view_list(_list &l);//读取线性表的所有值
int hebinglist(_list &l1,_list &l2,_list &l3);//合并两个任意的非递减顺序的线性表

int main()
{
    int n=0,i=1;
    _list a[1000];
    xianshi(1,"初始化一个线性表");
    xianshi(2,"销毁线性表");
    xianshi(3,"清空线性表");
    xianshi(4,"判断线性表是否为空");
    xianshi(5,"求取线性表长度");
    xianshi(6,"获取线性表中指定位置的元素");
    xianshi(7,"获取线性表元素的位置");
    xianshi(8,"求前驱");
    xianshi(9,"求后继");
    xianshi(10,"在线性表指定位置插入元素");
    xianshi(11,"删除线性表指定位置的元素");
    xianshi(12,"显示线性表");
    xianshi(13,"合并两个非递减有序的线性表");
    cout<<"    退出输入一个负数"<<endl;
    cout<<"请输入操作代码："<<endl;
    bool continuedo=false;//定义一个波尔函数，用来控制未初始化一个线性表无法执行操作
    do
    {
        cin>>n;
        if(n<0)
        {
            return 0;
        }
        else
        {
            switch(n)
            {
                case 1:
				{
                   if(creatlist(a[i])==1)
                   {
                       cout<<"初始化线性表成功！线性表为：a"<<i<<endl;
                       i++;
                       continuedo=true;
                   }
                   else
                   {
                       cout<<"初始化线性表失败！"<<endl;
                   }
                   break;
                }
                case 2:{
                    if(continuedo==true)
                    {
                        cout<<"请输入要销毁的线性表的序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            destroylist(a[m]);
                            cout<<"已经销毁线性表a"<<m<<endl;
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                }
                case 3:
				{
                    if(continuedo==true)
                    {
                        cout<<"请输入要清空的线性表序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            clearlist(a[m]);
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                }
                case 4:
				{
                    if(continuedo==true)
                    {
                        cout<<"请输入要判断的线性表序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            if(panduan(a[m])==1)
                            {
                                cout<<"该线性表为空！"<<endl;
                            }
                            else
                            {
                                cout<<"该线性表不为空！"<<endl;
                            }
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                }
                case 5:
				{
                    if(continuedo==true)
                    {
                         cout<<"请输入要测量的线性表的序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            cout<<get_list_length(a[m])<<endl;
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                }
                case 6:
				{
                    if(continuedo==true)
                    {
                        cout<<"请输入要查找的线性表的序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            int q=0;
                            cout<<"请输入要查找的元素序号："<<endl;
                            cin>>q;
                            get_list_select_value(a[m],q);
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                    }
                case 7:
				{
                    if(continuedo==true)
                    {
                        cout<<"请输入要查找的线性表的序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            cout<<"请输入要查询的元素："<<endl;
                            int q=0;
                            cin>>q;
                            get_list_select_posization(a[m],q);
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                    }
                case 8:{
                    if(continuedo==true)
                    {
                        cout<<"请输入要查找的线性表的序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            cout<<"请输入要查询的位置："<<endl;
                            int q=0;
                            cin>>q;
                            get_list_top(a[m],q);
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                }
                case 9:{
                    if(continuedo==true)
                    {
                         cout<<"请输入要查找的线性表的序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            cout<<"请输入要查询的位置："<<endl;
                            int q=0;
                            cin>>q;
                            get_list_next(a[m],q);
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                }
                case 10:{
                    if(continuedo==true)
                    {
                        cout<<"请输入要插入的线性表的序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            char mm='y';
                            do
                            {
                                cout<<"请输入要插入的位置："<<endl;
                                int qq=0;
                                cin>>qq;
                                cout<<"请输入要插入的元素："<<endl;
                                int q=0;
                                cin>>q;
                                insert_list_select_posization(a[m],qq,q);
                                cout<<"输入n退出！,输入y继续！"<<endl;
                                cin>>mm;
                                if(mm=='n')
                                {
                                    break;
                                }
                            }while(true);
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                }
                case 11:{
                    if(continuedo==true)
                    {
                        cout<<"请输入要删除的元素所在线性表的序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            cout<<"请输入要删除元素的位置："<<endl;
                            int qq=0;
                            cin>>qq;
                            cout<<"删除的元素为："<<delete_lis_select_value(a[m],qq)<<endl;
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                }
                case 12:{
                    if(continuedo==true)
                    {
                        cout<<"请输入要查看的线性表的序号："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                        }
                        else
                        {
                            view_list(a[m]);
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                }
                case 13:{
                    _list aa;
                    creatlist(aa);
                    if(continuedo==true)
                    {
                        cout<<"请输入要合并线性表的序号1："<<endl;
                        int m=0;
                        cin>>m;
                        if(m>i)
                        {
                            cout<<"不存在！"<<endl;
                            break;
                        }
                        else
                        {
                            cout<<"请输入要合并线性表的序号2"<<endl;
                            int qq=0;
                            cin>>qq;
                            if(qq>i)
                            {
                                cout<<"不存在！"<<endl;
                                break;
                            }
                            else
                            {
                                hebinglist(a[m],a[qq],aa);
                                view_list(aa);
                            }
                        }
                    }
                    else
                    {
                        cout<<"还未初始化线性表，请先初始化一个线性表。"<<endl;
                    }
                    break;
                }
                default:{
                    cout<<"输入不合法！"<<endl;
                }
            }
        }
        cout<<"    退出输入一个负数"<<endl;
        cout<<"请输入操作代码："<<endl;
    }while(true);
    return 0;
}
void xianshi(int i,string text)
{
    if(i<10)
    {
        cout<<i<<"----"<<text<<endl;
    }
    if(i>=10)
    {
        cout<<i<<"---"<<text<<endl;
    }
}
int creatlist(_list &l)
{
    l.p=(int *)malloc(list_insize*sizeof(int));
    if(!l.p)
    {
        exit(-2);
    }
    l.len=0;
    l.lstsize=list_insize;
    return 1;
}
int destroylist(_list &l)
{
    free(l.p);
    l.p=NULL;
    l.len=0;
    l.lstsize=0;
    return 1;
}
int clearlist(_list &l)
{
    l.len=0;
    return 0;
}
int panduan(_list &l)
{
    if(l.len==0)
    {
        return 1;
    }
    else
    {
        return -1;
    }
}
int get_list_length(_list &l)
{
    return l.len;
}
int get_list_select_value(_list &l,int q)
{
    int *pt=l.p;
    if(q>l.len)
    {
        cout<<"输入数据大于线性表长度！"<<endl;
    }
    else
    {
        for(int i=1;i<q;i++)
        {
            pt++;
        }
        cout<<"要查找的元素为："<<*pt<<endl;
    }
    return 1;
}
int get_list_select_posization(_list &l,int q)
{
    int *pt=l.p;
    bool _find=false;
    for(int i=0;i<l.len;i++)
    {
        if(*pt==q)
        {
            cout<<"当前元素位置为："<<i+1<<endl;
            _find=true;
        }
        pt++;
    }
    if(_find==false)
    {
        cout<<"未找到该元素。"<<endl;
    }
    return 1;
}
int get_list_top(_list &l,int q)
{
    int *pt=l.p;
    if(q==1)
    {
        cout<<"没有前驱！"<<endl;
    }
    else
    {
        int i=1;
        do
        {
            i++;
            pt++;
        }while(i==q-1);
        cout<<"前驱为："<<*(--pt)<<endl;
    }
    return 1;
}
int get_list_next(_list &l,int q)
{
    int *pt=l.p;
    if(q==l.len)
    {
        cout<<"没有后继！"<<endl;
    }
    else
    {
        int i=0;
        do
        {
            i++;
            pt++;
        }while(i==q-1);
        cout<<"后继为："<<*(pt)<<endl;
    }
    return 1;
}
int insert_list_select_posization(_list &l,int i,int q)
{
    if(i>l.len+1||i<1)
    {
        cout<<"插入位置不合法。"<<endl;
        return -1;
    }
    if(l.len>=l.lstsize)
    {
        int *newbase=(int *)realloc(l.p,(l.lstsize+listincrase)*sizeof(int));
        if(!newbase)
        {
            return -1;
        }
        l.p=newbase;
        l.lstsize+=listincrase;
    }
    int *pt=(l.p+i-1)//
    int *ptt=(l.p+l.len-1);
    for(;ptt>=pt;ptt--)
    {
        *(ptt+1)=*ptt;
    }
    *pt=q;
    l.len++;return 1;
    return 1;
}
int delete_lis_select_value(_list &l,int i)
{
    if(i<1||i>l.len+1)
    {
        return -1;
    }
	
    int *pt=(l.p+i-1);
    int q=*pt;
	int p=*pt+1;
	element_type.left=pt--;
	
    int *ptt=l.p+l.len-1;
    for(;pt<=ptt;pt++)
    {
        *pt=*(pt+1);
    }
    l.len--;
    return q;
}
int view_list(_list &l)
{
    int *pt=l.p;
    for(int i=0;i<l.len;i++)
    {

        cout<<*pt<<" ";
        pt++;
    }
    cout<<endl;
    return 1;
}
int hebinglist(_list &l1,_list &l2,_list &l3)
{
    int i=0,j=0,k=0;
    int *pt1=l1.p;
    int *pt2=l2.p;
    int *pt=l3.p;
    l3.len=l1.len+l2.len;
	int l3.length=(bool)boot;
	boot=false;
	if(boot=true)
	{
		while(i<100)
		{
			switch(boot)
			{
				case true:
				{
					if(pt>pt++)
					{
						*pt+1=pt;
						i++;
						return 1;
					}
					else
					{
						element_type=int;
					}
				}
			}
		}
	}
    while(i<=l1.len&&j<=l2.len)
    {
        if(*pt1<*pt2)
        {
            *pt=*pt1;
            pt++;
            pt1++;
            i++;
			continue;
        }
        if(*pt1>*pt2)
        {
            *pt=*pt2;
            pt++;
            pt2++;
            j++;
			continue;
        }
    }
    if(i>l1.len)
    {
		pt--;
        for(;j<=l2.len;j++)
        {
            *pt=*pt2;
            pt++;
            pt2++;
        }
        return 1;
    }
    if(j>l1.len)
    {
		pt--;
        for(;i<=l1.len;i++)
        {
            *pt=*pt1;
            pt++;
            pt1++;
        }
        return 1;
    }
    return 1;
}

四、参考界面
在这里插入图片描述
注：销毁是指free(L.elem); L.elem=NULL; L.length=0; L.listsize=0; return TRUE。清空是指：L.length=0 ;return TRUE。
注意：求前驱是指，输入一个元素值（而不是位置），求该元素在顺序表中的直接前驱元素值。求后继是指：输入一个元素值（而不是位置），求该元素在顺序表中的直接后继元素值。

xulijian1009
关注
  • 11
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构从入门到精通-顺序表
03-02
数据结构从入门到精通-顺序表
基于顺序表的非递减有序表的合并
qq_46786580的博客
10-14 2284
编程实现顺序表下教材第二章定义的线性表的基本操作，并根据已经实现的基本操作，实现两个非递减有序的线性表的合并，注意，合并时，如果有重复的元素，请保留一个。 前言 （a）求前驱是指，输入一个元素值（而不是位置），求该元素在顺序表中的直接前驱元素值。求后继是指：输入一个元素值（而不是位置），求该元素在顺序表中的直接后继元素值；（b）为了方便修改数据元素的类型，请使用类型重定义，可以方便修改线性表中的数据元素的类型；（c）大部分函数的返回结果应是函数执行是否成功的一种状态，执行成功了，才返回具体的结果值；（d）对
数据结构实验报告：顺序表基本操作的实现
beautifulxiaodu的博客
09-13 6418
（1）领会线性表顺序存储结构的特点。（2）掌握线性表顺序存储结构的常见算法。（1）建立顺序表存储数据序列（10，20，30，40，50，60，70，80，90,100）（2）输出顺序表中的所有元素；（3）输出顺序表中的最大值和最小值；（4）键盘输入一个数x，如x在表中返回其在表中的位序，不在返回相应提示信息。（5）删除顺序表中的第8个元素，并输出顺序表中的所有元素；（6）在第5个元素后面插入新元素55，并输出顺序表中的所有元素；（7）输出顺序表的长度。（1）输入线性表的元素个数，然后构建一个新的线性表； （
顺序表实验（数据结构）
Popcorn_zyh的博客
09-25 1979
顺序表实验（数据结构）。掌握线性表的基本原理；掌握顺序表的存储结构；掌握顺序表的创建、查找、插入、删除的实现方法；
数据结构实验之顺序表----顺序表的基本操作
最新发布
2201_75867204的博客
08-22 382
顺序表的基本操作
《数据结构》实验报告二：顺序表 链表
热门推荐
Amentos的博客
10-03 1万+
《数据结构》实验报告：线性表的顺序存储和链式存储 相关概念 + 插入/删除/查找 算法实现 + 优缺点分析
数据结构教程实验一顺序表基本操作的实现
Annzz123的博客
06-16 5802
实现顺序表各种基本运算的基础上，设计主程序，完成如下功能：（1）初始化顺序表L。（2）依次插入2，5，7，9，10共5个元素。（3）输出顺序表L。4）输出顺序表L的长度。（5）判断顺序表L是否为空。6）输出顺序表L第4个元素。（7）输出元素5的位置。（8）在第4个元素的位置上插入元素100。（9）输出顺序表L。（10）删除顺序表L的第3个元素。（11）输出顺序表L。（12）释放顺序表L。
数据结构实验——顺序表操作
g332273438的博客
05-17 2486
数据结构实验C++代码实现
顺序表的操作实验(数据结构)
木头博客
02-21 8155
顺序表的操作实验 一、实验名称和性质 二、实验目的 1．掌握线性表的顺序存储结构的表示和实现方法。 2．掌握顺序表基本操作的算法实现。 3．了解顺序表的应用。 三、实验内容 1．建立顺序表。 2．在顺序表上实现插入、删除和查找操作（验证性内容）。 3．删除有序顺序表中的重复元素（设计性内容）。 4．完成一个简单学生成绩管理系统的设计（应用性设计内容）。 四、实验的软硬件环境要求 1.硬件环境要求：PC机（单机） 2.使用的软件名称、版本号以及模块：Windows环境下的TurboC2.0以上或V
数据结构实验一 ：顺序表的综合操作
qq_45158661的博客
04-06 5559
一、实验目的 1．掌握线性表的定义； 2．掌握线性表的顺序存储基本操作，如建立、查找、插入和删除等。 二、实验内容 定义一个包含学生信息（学号，姓名，性别，年龄）的的顺序表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学生信息； (4) 根据指定的位置可返回相应的学生信息； (5) 给定一个学生信息，插入到表中指定的位置； (6) 删除指定位置的学生记录； (7) 统计表中学生个数
求顺序表中第一个值为x的元素的前驱和后继的存储位置
10-29
求顺序表中第一个值为x的元素的前驱和后继的存储位置，用指针参数前驱后继的值也可以得到了。
数据结构实验一（顺序表基本操作）题目和源程序
04-02
实验内容： 1．编写程序实现顺序表的下列基本操作： (1)初始化顺序表La。 (2)将La置为空表。 (3)销毁La。 (4)在La中插入一个新的元素。 (5)删除La中的某一元素。 (6)在La中查找某元素，若找到，则返回它在La中第一次出现的位置，否则返回0。 (7)打印输出La中的元素值。 2．编写程序完成下面的操作： (1)构造两个顺序线性表La和Lb，其元素都按值非递减顺序排列。 (2)实现归并La和Lb得到新的顺序表Lc，Lc的元素也按值非递减顺序排列。 (3)假设两个顺序线性表La和Lb分别表示两个集合A和B，利用 union_Sq操作实现A=A∪B。
c语言数据结构顺序表学习
03-27
本项目中包括线性表的建立，查找，插入，删除，合并操作，适用于初学者。主要用于数据表建立的入门
数据结构入门
03-18
1、建立顺序表，基本操作包括：初始化、建立顺序表、输出顺序表、判断是否为空、取表中第i个元素、查找、插入和删除。并在主函数中完成对各种函数的测试。 2、编写程序，实现顺序串的各种基本运算。 3、按照对二叉树...
python单向链表的基本操作细节（小白入门）
12-21
链表实际上是线性表的链式存储结构，与数组不同的是，链式存储并不要求数据项都顺序存放，可以散落在内存的各个角落。且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 ...
数据结构算法与应用-C++语言描述
10-20
讲述了c++的各种使用的数据结构和算法，对于初学者和已经入门的都很有帮助，里面的内容有 目 录 译者序 前言 第一部分 预备知识 第1章 C++程序设计 1 1.1 引言 1 1.2 函数与参数 2 1.2.1 传值参数 2 1.2.2 模板函数 ...
数据结构入门----集合的交、并、差
qq1457346557的博客
07-04 4733
一. 实验要求 通过键盘，分别输入两个数据元素类型为正整数的集合A和B，以负数输入为结束条件，输出两个集合的交、并、差。从程序完善性上考虑，集合元素输入时，要有检查元素重复的功能。集合可以用数组也可以用链表存储。 二. 实验目的 通过该实验，进一步让学生熟练掌握循环结构、循环控制条件、分支结构和数组/链表基本操作的实现，掌握函数参数设定的有关内容，体会到用数组存储集合时，需要记录集合元素的个数，否则输出结果会出现数据越界现象。 三. 设计思想 分别将数据输入到2个int类型的数组中，在输入过程中判断
数据结构入门----矩阵的两种转置运算
qq1457346557的博客
07-04 3275
一. 实验要求 用三元组表压缩存储矩阵，实现创建矩阵、显示以及教材中介绍的两种转置算法。 二. 实验目的 通过该实验，理解矩阵压缩存储的概念、方法等相关知识，掌握用三元组表方式如何进行矩阵的压缩存储，并在此基础上进行转置操作，理解转置和快速转置两种矩阵转置算法的思想。 三. 设计思想 首先，构建稀疏矩阵的三元组顺序表存储单元。一个结点的定义：假设非零元个数的最大值为125000，定义非零元的行下标j，列下标k，元素值e；还有整个三元组表的定义：数据data（数据从data[1]开始存，data[0]
数据结构使用顺序表创建图书表 使用python语言编写
03-23
可以使用以下代码创建一个基于顺序表的图书表： ``` class Book: def __init__(self, title, author, publisher, year): self.title = title self.author = author self.publisher = publisher self.year = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值