精华内容
下载资源
问答
  • 数据结构实验一顺序表
    千次阅读
    2021-11-20 21:36:23

    实验一 顺序表的基本操作

    实验内容

    编写一个程序,实现顺序表的各种基本运算(假设顺序表的元素类型为char),并在此基础上设计一个主程序完成如下功能:

    (1)初始化顺序表L;
    (2)依次采用尾插法插入a、b、c、d、e元素;
    (3)输出顺序表L;
    (4)输出顺序表L的长度;
    (5)判断顺序表L是否为空;
    (6)输出顺序表L的第3个元素;
    (7)输出元素a的位置
    (8)在第4个元素位置上插入f元素
    (9)输出顺序表L;
    (10)删除L的第3个元素;
    (11)输出顺序表L;
    (12)释放顺序表L。
    四、实验要求
    1、用DEV C++、VS2010等工具创建文件或程序,输入代码后,进行编译运行或在控制台执行。
    2、观看程序运行结果,并根据结果进行思考,对程序进行修改和总结。

    头文件:

    #include <stdio.h>
    #include <stdlib.h>
    #define ERROR 0
    #define OK 1
    #define MAXSIZE 100
    typedef struct {
        int* elem;
        int length;
    }SqList;
    

    顺序表插入操作:

    int ListInsert(SqList* L, int i, int x)
    {
        if (i<1 || i>L->length + 1)
            return ERROR;
        if (L->length == MAXSIZE)
            return ERROR;
        for (int j = L->length - 1; j >= i - 1; j--)
            L->elem[j + 1] = L->elem[j];
        L->elem[i - 1] = x;
        L->length++;
        return OK;
    }
    

    顺序表删除操作:

    int ListDelete(SqList* L, int i)
    {
        if (i<1 || i>L->length)
            return ERROR;
        for (int j = i; j < L->length; j++)
            L->elem[j - 1] = L->elem[j];
        L->length--;
        return OK;
    }
    

    顺序表查找操作:

    int LocateElem(SqList* L, int e)  //e为待查找的元素
    {
        for (int i = 0; i < L->length; i++)
            if (L->elem[i] == e)
                return i + 1;
        return 0;
    }
    
    更多相关内容
  • 数据结构实验一顺序表的实现-实验报告
  • 数据结构实验一顺序表的实现.doc
  • 数据结构 实验一 顺序表的操作

    千次阅读 多人点赞 2020-07-05 11:31:41
    顺序表的操作 任务:初始化顺序表并输出。 相关知识: 需要掌握: 1.结构体变量初始化 2.如何遍历顺序表。 结构体变量初始化: 定义结构体变量的同时,给结构体变量的各个成员变量赋值。 示例如下: ...

    一、顺序表的操作

    任务一:初始化一个顺序表并输出。
    相关知识
    需要掌握:
    1.结构体变量初始化
    2.如何遍历顺序表。
    结构体变量初始化:
    定义结构体变量的同时,给结构体变量的各个成员变量赋值。
    示例如下:
    sequenlist sq={{1,3,6,7},3};
    {1,3,6,7}是给结构体中的数组赋值,
    3.给成员变量 last 赋值
    遍历顺序表
    给定一个顺序表L,从0~L->last,依次输出,就可以遍历完顺序表中的所有元素。
    其中L是指向顺序表的指针。
    示例如下:
    void listprint (sequenlist L) /输出线性表/
    {
    int i;
    for(i=0;i<=(L).last;i++)
    printf(“%d “,L->vec[i]);
    }
    输出:1 3 6 7
    示例代码如下:(温馨提示:本文全部代码只在 EduCoder 平台上通过测试,仅供参考,如有运行错误请自行改正)

    #define MAXSIZE 100    /*宏定义*/
    #define OK 1
    #define OVERFLOW -2
    #include "stdio.h"    /*包含输入输出文件*/
    
    typedef int elemtype;
    typedef struct          /*定义顺序表的结构*/
    {
        elemtype vec[MAXSIZE]; /*顺序表数据成员所占据的存储空间*/
        int last;              /*顺序表中最后一个元素在数组中的下标(或向量中的位置)从0开始*/
    }sequenlist;
    
     void listprint(sequenlist *L) /*输出线性表*/
     {
     /*请在下面补充代码,输出顺序表*/
     for(int i=0;i<=(*L).last;i++)
     printf("%d ",L->vec[i]);
     }
      int main()
     {
      sequenlist sl={{1,3,6,10,15,21,28,36,45},8};//直接给顺序表赋初值
      listprint(&sl);
      return 0;
    }
    

    任务二:顺序表上的查找操作
    相关知识
    需要掌握:
    1.如何写完整函数定义
    2.如何进行查找
    函数定义
    格式:
    函数类型 函数名(形参列表)
    {…}
    函数类型不为空时,函数要用return返回一个值。

    查找算法
    采用顺序查找算法,从顺序表的一端开始,按顺序比较当前数组元素与给定值K是不是相等,若相等,则表示查找成功,返回元素在数组中的下标;
    当比较完最后一个元素仍然不相等,则返回-1,表示查找失败。

    测试说明
    平台会对你编写的代码进行测试:

    测试输入:45
    预期输出:
    查找成功,该元素在数组中的下标是9

    测试输入:30
    预期输出:
    查找失败
    示例代码如下:

    #define MAXSIZE 100    
    #define OK 1
    #define OVERFLOW -2
    
    #include "stdio.h"    
    
    typedef int elemtype;
    typedef struct          
    {elemtype vec[MAXSIZE]; 
     int last;             
    }sequenlist;
    
    /*请在下面写出查找函数的原型。提示:根据主函数处的函数调用判断函数名、函数类型、参数类型*/
    int locate(sequenlist *L, int key)
    {
    	int i=0;
    	int result=-1;
    	L->vec[10]=key;
    	while(i!=10)
    	{
    		if(L->vec[i]==key)
    		{
    			result=i;
    			break;
    		}
    		i++;
    	}
    	return result;
    }
    
     void listprint(sequenlist *L) 
     {int i;
      for(i=0;i<=(*L).last;i++)
      printf("%d ",L->vec[i]);
     }
    
     int main()
     {
      sequenlist sl={{1,3,6,10,15,21,28,36,45},8};
      int key;
      int result;  /*保存查找结果的变量*/
      scanf("%d",&key);
      result=locate(&sl,key);
      if(result!=-1) printf("查找成功!该元素在数组中的下标是%d",result);
      else printf("查找失败!");
      return 0; 
    }
    

    任务三:顺序表的插入、删除操作
    任务描述:
    编写一个程序实现顺序表的插入删除操作。
    相关知识
    需要掌握:
    1.顺序表的插入操作
    2.顺序表的删除

    顺序表的插入
    insert(L,i,x)
    在顺序表L的第i个位置上插入元素x
    需要注意:
    1、顺序表表满的情况
    2、插入位置i的范围 0<i<=L->next+2(n+1)
    3、L->last++

    顺序表的删除
    dele(L,i)
    删除顺序表L的第i个元素。
    需要注意
    1、删除位置i 0<i<=L->last+1
    2、L->last–

    测试说明
    平台会对你编写的代码进行测试:
    please input the insert position and insert value
    3 44
    the insert position: 3
    insert value:44
    i,e=0,1
    i,e=1,2
    i,e=2,44
    i,e=3,3
    i,e=4,4
    i,e=5,5
    i,e=6,6
    i,e=7,7
    i,e=8,8
    i,e=9,9
    i,e=10,10
    please intput the delete position:5
    i,e=0,1
    i,e=1,2
    i,e=2,44
    i,e=3,3
    i,e=4,5
    i,e=5,6
    i,e=6,7
    i,e=7,8
    i,e=8,9
    i,e=9,10

    #define MAXSIZE 100    
    #define OK 1
    #define OVERFLOW -2
    #include "stdio.h"    
    
    typedef int elemtype;
    typedef struct          
    {elemtype vec[MAXSIZE]; 
     int last;              
    }sequenlist;
    
    /****************请写出插入函数定义******************************/
    int insert(L,i,x)
    sequenlist *L;
    int i,x;
    {
    	int j;
    	if( ( (*L).last >= MAXSIZE-1)) 
    	{
    	printf("overflow");
    	return 0; 
    	} /*表空间溢出*/
    	else 
    	if ( (i<=0) || ( i> (*L).last+1 ))
    	{
    	printf("error");
    	return 0;
    	}
    	else
    	{
    		for(j=(*L).last ; j>=i-1 ; j-- )
    		(*L).vec[j+1]=(*L).vec[j];  //结点后移
    		(*L).vec[i-1]=x;
    		(*L).last=(*L).last+1;//终端结点下标加1
    	}
    
    	return (1);
    
    }
    
    /*****************请写出删除函数定义*****************************/
    int dele(L,i)
    sequenlist *L;
    int i;
    {
    	int j;
    	if ((i<0)||(i>(*L).last))
    	{
    	return 0;
    	}
    	else 
    	{
    		for (j=i;j<=(*L).last;j++)
    
    		L->vec[j-1]=L->vec[j];
    
    	}
    	L->last--;
    	return (1);
    
    }
    
     void listprint(sequenlist *L) /*输出线性表*/
     {int i;
      for(i=0;i<=(*L).last;i++)
      printf("i,e=%d,%d\n",i,L->vec[i]);
     }
    
     int main()
     {
      sequenlist sl={{1,2,3,4,5,6,7,8,9,10},9};
      int i,j,x;
      elemtype e;
      printf("please input the insert position and insert value\n");
      scanf("%d%d",&i,&x);
      printf("the insert position: %d\ninsert value:%d\n",i,x);
      insert(&sl,i,x);
      listprint(&sl);
      printf("please intput the delete position:\n");
      scanf("%d",&j);
      dele(&sl,j);A
      listprint(&sl);
      return 0;
    }
    

    任务四
    任务描述:逆置一个顺序表并输出。
    相关知识
    需要掌握:1.如何逆置顺序表

    逆置顺序表
    从两端开始,将顺序表对称元素交换。
    设置两个对称的指针i,j;
    i=0;
    j=L->last;
    while(i<j)
    { 交换i,j下标处的元素;
    i++;
    j–;
    }

    测试说明
    平台会对你编写的代码进行测试:
    测试输入:
    预期输出:
    1 2 3 4 5 6 7 8 9 10
    10 9 8 7 6 5 4 3 2 1

    #define MAXSIZE 100    
    #define OK 1
    #define OVERFLOW -2
    #include "stdio.h"    
    
    typedef int elemtype;
    typedef struct          
    {elemtype vec[MAXSIZE]; 
     int last;              
    }sequenlist;
    
    /*请在下面写出逆置函数的原型函数。*/
    void inverse(sequenlist *L)
    {
    	int i=0;
    	for (i=0;i<= L-> last/2;i++)
    	{
    		L->vec[i]= L->vec[i]+L->vec[L->last-i];
    		L->vec[L->last-i]=L->vec[i]- L->vec[L->last-i];
    		L->vec[i]= L->vec[i]- L->vec[L->last-i];
    	}
    	
    }
    
     void listprint(sequenlist *L) /*输出线性表*/
     {int i;
      for(i=0; i<=(*L).last;i++)
      printf("%d ",L->vec[i]);
      printf("\n");
     }
    
     int main()
     {
      sequenlist sl={{1,2,3,4,5,6,7,8,9,10},9};
      int i,j,x;
      listprint(&sl);
      inverse(&sl);
      listprint(&sl);
      return 0;
    }
    
    

    任务五
    任务描述:有序顺序表中元素的插入
    相关知识
    需要掌握:
    1.如何进行有序顺序表的插入

    先求出插入位置 i
    为了保持有序性,插入位置不能随意指定。必须在指定位置进行插入
    假设顺序表升序
    插入元素为x
    从表头开始(i=0),将L->vec[i]依次与x比较,如果x比表中元素大,则i++继续比较;
    否则,找到插入位置 i ,跳出循环。

    实现在位置 i 处的插入操作
    给定了插入位置和待插入元素,就是普通的插入操作

    编程要求:
    实现有序顺序表中元素的插入

    测试说明
    平台会对你编写的代码进行测试:

    测试输入:8
    预期输出:
    1 3 5 7 8 10

    测试输入:12
    预期输出:1 3 5 7 10 12

    测试输入 0
    预期输出:0 1 3 5 7 10

    #define MAXSIZE 100    
    #define OK 1
    #define OVERFLOW -2
    #include "stdio.h"    
    
    typedef int elemtype;
    typedef struct          
    {elemtype vec[MAXSIZE]; 
     int last;              
    }sequenlist;
    
    void order_insert(sequenlist *L,elemtype x)
    {
    	int i=0,j;
    	while(i<L->last+1 && x>=L->vec[i]) i++;
    	for(j=L->last;j>=i-1;j--)
    	L->vec[j+1]=L->vec[j];
    	L->vec[i]=x;
    	L->last++;
    }
    
     void listprint(sequenlist *L) /*输出线性表*/
     {int i;
      for(i=0;i<=(*L).last;i++)
      printf("%d ",L->vec[i]);
     }
    
     int main()
     {
      sequenlist sl={{1,3,5,7,10},4};
      int x;
      scanf("%d",&x);
      order_insert(&sl,x);
      listprint(&sl);
      return 0;
    }
    
    

    我把我目前写的关于数据结构 题目 的链接全部汇总整理在下面,有需要的小伙伴自己点击哈。

    实验:

    关于顺序表的操作的实验内容就写到这了。
    如果觉得内容对你有帮助的话,可以点个赞再走吗,Thanks♪(・ω・)ノ

    展开全文
  • 18级合工大数据结构实验
  • 数据结构实验一顺序表的实现.pdf
  • 洛阳理工学院实验报告 系别 计算机 班级 学号 姓名 课程名称 数据结构 实验日期 10/23 实验名称 顺序表的基本操作 成绩 实验目的 熟悉掌握线性表顺序存储结构掌握与应用顺序表的查找插入删除等基本操作算法训练和...
  • 数据结构实验C++代码实现

    提示:本文代码主要是根据 数据结构教程5-李春葆改写的


    前言

    书中:2.2线性表的顺序结构存储结构有线性表的c语言代码,我这里是用的C++。
    本文代码已经把基本操作的细节都写好了,根据自己实验的要求再进行进一步的修改,与书中代码不同的是,书中函数只有算法而无提示,本文加的有提示。


    一、实验目的

    功能:建立顺序表,初始化线性表,销毁线性表,判断线性表是否为空,求线性表的长度,输出线性表,按元素查找,插入数据元素,删除数据元素。

    二、实验总代码

    代码如下:

    #include<iostream>
    using namespace std;
    #define MaxSize 1024
    typedef int ElemType;
    
    
    //声明线性表
    typedef struct
    {
    	ElemType data[MaxSize];
    	int length;
    }Sqlist;
    
    
    //建立顺序表
    void CreateList(Sqlist *L)
    {
    	int n = 0, k = 0;
    	cout << "请输入数据的个数\n";
    	cin >> k;
    	for (int i =0; i < k; i++)
    	{
    		printf("list[%d]=", i);
    		cin >> n;
    		L->data[i] = n;
    	}
    	L->length = k;
    	printf("\n");
    }
    
    //输出线性表
    void Displist(Sqlist* L)
    {
    	int i = 0;
    	for (; i < L->length; i++)
    	{
    		printf("data[%d]=", i);
    		printf("%d\n", L->data[i]);
    	}
    	printf("\n");
    }
    
    //初始化线性表
    void Initlist(Sqlist* L)      //这个功能可以直接在main函数实现,不与要用函数来写
    {
    	L = (Sqlist*)malloc(sizeof(Sqlist));  //分配存放线性表的空间
    	L->length = 0;
    }
    
    //销毁线性表
    void Destroylist(Sqlist* L)
    {
    	free(L);                 //释放线性表
    }
    
    //判断线性表是否为空表
    bool Listempty(Sqlist* L)
    {
    	if (L->length == 0)
    		cout << "线性表为空" << endl;
    	else
    		cout << "线性表不为空" << endl;
    	return (L->length);
    }
    
    //求线性表的长度
    int Listlength(Sqlist* L)
    {
    	cout << "线性表长度为" << L->length << endl;
    	return(L->length);
    }
    
    //按元素值来查找
    int Locatelist(Sqlist* L, ElemType e)
    {
    	int i = 0;
    	while (i <= L->length && L->data[i] != e)
    		i++;
    	if (i >= L->length)
    	{
    		cout << "没有该元素数据" << endl;
    		return 0;
    	}
    	else
    	{
    		cout << "元素的位置在第" << i + 1 << "个" << endl;
    		return i + 1;
    	}
    }
    
    //插入数据元素
    bool Listinsert(Sqlist* L)
    {
    	int i = 0, e = 0;
    	cout << "输入你要插入元素的位置:\n";
    	cin >> i;
    	cout << "请输入插入元素的值:\n";
    	cin >> e;
    	int j = 0;
    	if (i<1 || i>L->length + 1)          //插入的数据i的范围超过线性表的范围
    		return false;
    	i--;
    	for (j = L->length; j > i; j--)      //大于i的线性表的向后移
    		L->data[j] = L->data[j - 1];
    	L->data[i] = e;                      //第i个值赋值
    	L->length++;                         //长度+1
    	cout << "插入成功\n";
    	return true;
    }
    
    //删除数据元素
    bool Listdelete(Sqlist* L)
    {
    	int i = 0;
    	cout << "输入你要删除元素的位置:\n";
    	cin >> i;
    	int j = 0;
    	if (i<1 || i>L->length)
    	{
    		cout << "输出错误\n";
    		return false;
    	}
    	i--;
    	for (j = i; j < L->length - 1; j++)
    	{
    		L->data[j] = L->data[j + 1];
    	}
    	L->length--;
    	cout << "删除成功\n";
    	return true;
    	system("cls");
    }
    
    //菜单
    void Menu()
    {
    	cout << "************************************************************************" << endl;
    	cout << "*********************  1、输出线性表数据         ***********************" << endl;
    	cout << "*********************  2、销毁线性表             ***********************" << endl;
    	cout << "*********************  3、判断线性表是否为空表   ***********************" << endl;
    	cout << "*********************  4、线性表长度             ***********************" << endl;
    	cout << "*********************  5、按元素查找线性表       ***********************" << endl;
    	cout << "*********************  7、插入数据元素           ***********************" << endl;
    	cout << "*********************  8、删除数据元素           ***********************" << endl;
    	cout << "*********************  0、退出管理系统           ***********************" << endl;
    	cout << "************************************************************************" << endl;
    }
    
    int main()
    {
    	Sqlist* L;
    	L = (Sqlist*)malloc(sizeof(Sqlist));  //分配存放线性表的空间
    	Initlist(L);               //初始化表
    	CreateList(L);             //建立线性表
    	while (true)
    	{
    		Menu();
    		cout << "请输入你的操作:\n";
    		int select = 0;
    		cin >> select;
    		switch (select)
    		{
    		case 1:
    			Displist(L);       //输出
    			break;
    		case 2:
    			Destroylist(L);    //销毁
    			break;
    		case 3:
    			Listempty(L);      //判断
    			break;
    		case 4:
    			Listlength(L);     //长度
    			break;
    		case 5:                
    			Listinsert(L);     //插入          
    			break;
    		case 6:                
    			Listdelete(L);     //删除
    			break;
    		case 0:
    			return 0;
    			break;
    		default:
    			cout << "无效输入,请重新输入:\n";
    			break;
    		}
    	}
    	system("pause");
    	return 0;
    }
    

    三、每个功能的具体函数

    1.建立顺序表

    代码如下:

    //建立顺序表
    void CreateList(Sqlist *L)
    {
    	int n = 0, k = 0;
    	cout << "请输入数据的个数\n";
    	cin >> k;
    	for (int i =0; i < k; i++)
    	{
    		printf("list[%d]=", i);
    		cin >> n;
    		L->data[i] = n;
    	}
    	L->length = k;
    	printf("\n");
    }
    

    2.输出顺序表

    代码如下(示例):

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

    3.插入数据元素

    代码如下:

    //插入数据元素
    bool Listinsert(Sqlist* L)
    {
    	int i = 0, e = 0;
    	cout << "输入你要插入元素的位置:\n";
    	cin >> i;
    	cout << "请输入插入元素的值:\n";
    	cin >> e;
    	int j = 0;
    	if (i<1 || i>L->length + 1)          //插入的数据i的范围超过线性表的范围
    		return false;
    	i--;
    	for (j = L->length; j > i; j--)      //大于i的线性表的向后移
    		L->data[j] = L->data[j - 1];
    	L->data[i] = e;                      //第i个值赋值
    	L->length++;                         //长度+1
    	cout << "插入成功\n";
    	return true;
    }
    
    

    删除数据元素

    //删除数据元素
    bool Listdelete(Sqlist* L)
    {
    	int i = 0;
    	cout << "输入你要删除元素的位置:\n";
    	cin >> i;
    	int j = 0;
    	if (i<1 || i>L->length)
    	{
    		cout << "输出错误\n";
    		return false;
    	}
    	i--;
    	for (j = i; j < L->length - 1; j++)
    	{
    		L->data[j] = L->data[j + 1];
    	}
    	L->length--;
    	cout << "删除成功\n";
    	return true;
    	system("cls");
    }
    

    总结

    上面写了相对比较复杂的4个算法,其他的可以在二.总代码去找函数/
    本文代码只是写了具体的算法,像清屏需要自己根据要求去修改。

    //清屏
    system("pause");
    

    如果有其他的建议或者发现什么错误可以在本文留言或者私信我

    谢谢大家的欣赏

    展开全文
  • 数据结构实验报告1-顺序表实现简易的学生信息管理系统(C语言),包括实验环境,实验的小结,实验的源代码,实验截图等。 说明:仅供参考,如有bug,还请反馈!
  • 可编辑范本 可编辑范本 淮海工学院计算机科学系 实验报告书 课程名 数据结构 线性表数据结构试验 题 目: 班 级 软件112 学 号 姓 名 评语 成绩 指导教师 批阅时间 年 月 日 线性表实验报告要求 目的与要求 : 1掌握...
  • 数据结构实验 顺序表元素的逆序 静态存储 动态存储

    实验一  顺序表的基本操作的实现必做,设计性实验)

    1. 实验目的

    熟悉将算法转换成程序代码的过程,了解顺序表的逻辑结构特性,熟练掌握顺序表存储结构的C语言描述方法。熟练掌握顺序表的基本操作:查找、插入、删除、合并等,掌握顺序表的随机存取特性。

    1. 实验内容(选其中之一书写实验报告)

    (1)在非递减有序的顺序表中插入一个元素x,保持顺序表有序性。

    (2)顺序表元素的逆置

    (3)两个(有序或无序)顺序表的合并

    要求用静态分配的一维数组和动态分配的一维数组来完成实验题目。分析静态分配的一维数组和动态分配的一维数组在顺序表基本操作实现上的共同点和区别。

    对顺序表插入的算法,要求用两种方法实现:其一:自己编写实现函数;其二:调用顺序表基本操作ListInsert(SqList &L,int i,ElemType x),比较使用自己编写的插入函数和调用顺序表基本操作的函数两种实现方法之间的优缺点。对所编写的算法进行时间复杂度分析。

    1. 问题描述

    题目:顺序表元素的逆序

    要求:要求用静态分配的一维数组和动态分配的一维数组来完成实验题目。分析静态分配的一维数组和动态分配的一维数组在顺序表基本操作实现上的共同点和区别。

    1. 数据结构定义

        (说明你算法中用到的数据结构、数据类型的定义

    数据结构:线性表的顺序存储结构

    数据类型:*elem,length,listsize整型变量分别存储空间基地址,长度,当前分配存储容量

    Typedef  int  ElemType;//元素类型

    typedef  struct  node  

    {   

    ElemType data;

    struct node *next;

    }LNode,*LinkList;

    1. 算法思想及算法设计

        (先文字说明算法的思想,然后给出类C语言算法

    表中元素的逆序,先确定元素个数length,也就是表的长度,先将第(length-1)后者元素赋值给中间变量temp,再将前者元素i赋值给后者元素,再将temp赋值给前者元素,完成前者后者元素的互换,通过for循环语句完成整个表中元素的逆序。

    Void TransList(Sqlist *l){

    for(int i=0;i<(l->length)/2;i++){

    int temp = l->elem[l->length-1-i];

    l->elem[l->length-1-i]=l->elem[i];

    l->elem[i]=temp;

    }

    return OK;

    }

    1. 实验代码

    静态存储

    #include<stdio.h>
    
    #include<stdlib.h>
    
    #define OK 1
    
    #define OVERFLOW 0
    
    #define LIST_INIT_SIZE 10
    
    #define LISTINCREMENT 5
    
    typedef struct{
    
    int *elem;
    
    int length;
    
    int listsize;
    
    }Sqlist;
    
    int InitList(Sqlist *l){
    
    l->elem =new int[LIST_INIT_SIZE];
    
    if(!l->elem){
    
    printf("存储空间分配失败\n");
    
    exit(OVERFLOW);
    
    }
    
    l->length=0;
    
    l->listsize=LIST_INIT_SIZE;
    
    return OK;
    
    }
    
    int TransList(Sqlist *l){
    
    for(int i=0;i<(l->length)/2;i++){
    
    int temp = l->elem[l->length-1-i];
    
    l->elem[l->length-1-i]=l->elem[i];
    
    l->elem[i]=temp;
    
    }
    
    return OK;
    
    }
    
    int CreatList(Sqlist *l,int length){
    
    printf("请输入元素值:\n");
    
    for(int i=0;i<length;i++){
    
    scanf("%d",l->elem+i);
    
    } l->length=length;
    
    return OK;
    
    
    
    }
    
    void PrintList(Sqlist *l){
    
    for(int i=0;i<l->length;i++){
    
    printf("%d ",l->elem[i]);
    
    }
    
    }
    
    int main(){
    
    int length;
    
    Sqlist l;
    
    InitList(&l);
    
    printf("元素的个数是:\n");
    
    scanf("%d",&length);
    
    CreatList(&l,length);
    
    PrintList(&l);
    
    printf("逆置后的结果为:\n");
    
    TransList(&l);
    
    PrintList(&l);
    
    
    
    }

    动态存储

    #include<stdio.h>
    
    #include<stdlib.h>
    
    #define OK 1
    
    #define OVERFLOW 0
    
    #define LIST_INIT_SIZE 10
    
    #define LISTINCREMENT 5
    
    typedef struct{
    
    int *elem;
    
    int length;
    
    int listsize;
    
    }Sqlist;
    
    int InitList(Sqlist *l){
    
    l->elem = (int *)malloc(LIST_INIT_SIZE*sizeof(int));
    
    if(!l->elem){
    
    printf("存储空间分配失败\n");
    
    exit(OVERFLOW);
    
    }
    
    l->length=0;
    
    l->listsize=LIST_INIT_SIZE;
    
    return OK;
    
    }
    
    int CreatList(Sqlist *l,int length){
    
    printf("请输入元素值:\n");
    
    for(int i=0;i<length;i++){
    
    scanf("%d",l->elem+i);
    
    } l->length=length;
    
    return OK;
    
    
    
    }
    
    void PrintList(Sqlist *l){
    
    for(int i=0;i<l->length;i++){
    
    printf("%d ",l->elem[i]);
    
    }
    
    }
    
    int IncreaseList(Sqlist *l ,int length){
    
    if(length>l->listsize){
    
    int *newbase;
    
    newbase=(int*)realloc(l->elem,(l->listsize+LISTINCREMENT)*sizeof(int));
    
    if(!newbase){
    
    printf("存储空间分配失败\n");
    
    exit(OVERFLOW);
    
    }
    
    l->elem=newbase;
    
    l->listsize+= LISTINCREMENT;
    
    }
    
    return OK;
    
    }
    
    int TransList(Sqlist *l){
    
    for(int i=0;i<(l->length)/2;i++){
    
    int temp = l->elem[i];
    
    l->elem[i]=l->elem[l->length-1-i];
    
    l->elem[l->length-1-i]=temp;
    
    }
    
    return OK;
    
    }
    
    int main(){
    
    int length;
    
    Sqlist l;
    
    InitList(&l);
    
    printf("元素的个数是:\n");
    
    scanf("%d",&length);
    
    //IncreaseList(&l,length);
    
    CreatList(&l,length);
    
    PrintList(&l);
    
    printf("逆置后的结果为:\n");
    
    TransList(&l);
    
    PrintList(&l);
    
    
    
    }

    1. 算法测试结果

        (说明测试数据,粘贴实验结果图

    分别输入奇数个和偶数个数据,{1 2 3 4 5 }和{1 2 3 4 5 6 7 8}

     

    1. 分析与总结

        (1)算法复杂度分析及优、缺点分析

            (说明你编写算法的复杂度,算法的优点和缺点有哪些

    时间复杂度O(n)

    静态顺序表创建空间时为静态开辟,不用malloc函数,代码相对简单(一点点),不存在内存泄露问题

    动态顺序表,动态开辟空间,使用相对灵活,相比于静态开辟空间也可以少空间浪费

        (2)实验总结

            (说明你怎么解决实验中遇到的问题,有什么收获

    通过对顺序表元素的逆序操作,更加了解了线性表的存储结构和数据类型,明白了静态和动态分布的区别和优缺点,懂得了如何定义顺序表,对表内元素进行操作。

    展开全文
  • (1)创建顺序表,存放在数组 A[N]中,元素的类型为整型,设计算法调整 A,使其左边的所有元素小于 0,右边的所有元素大于 0(要求算法的时间复杂度和空间复杂度均为 O(n))。 (2)建立个循环单链表,其节点...
  • 编写个程序,实现顺序表的各种基本运算(假设顺序表的元素类型为char),并在此基础上设计个主程序完成如下功能: (1)初始化顺序表L; (2)依次采用尾插法插入a、b、c、d、e元素; (3)输出顺序表L; (4)...
  • (1) 建立顺序表,含有 n 个数据元素。 (2) 输出顺序表。 (3) 在顺序表中删除值为 x 的结点或者删除给定位置 i 的结点。 (4) 实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。 (5) *...
  • 数据结构与算法上机实验一 顺序表

    千次阅读 2019-12-09 22:04:11
    本次继续更新数据结构与算法这门课的上机实验,主要涉及顺序表一数据结构
  • 顺序表是指采用顺序存储结构的线性表,它利用内存中的一片连续存储区域存放表中的所有元素。可以根据需要对表中的所有数据进行访问,元素的插入和删除可以在表中的任何位置进行。 1. 实现顺序表的基本操作,包括顺序...
  • 数据结构实验报告 顺序表与链表

    千次阅读 2020-12-31 12:52:40
    数据结构实验报告:实验 顺序表与链表
  • typedef struct //定义顺序表 { int *elem; int length; }SqList; void InitList_Sq(SqList &L,int n) //创建顺序表 { L.elem=new int(n); if(!L.elem)exit(-2); L.length=0; } voi
  • 数据结构实验课_实验 顺序表

    千次阅读 2020-12-28 21:13:11
    1.输入组整型元素序列,建立顺序表。 2.遍历该顺序表。 3.在该顺序表中进行顺序查找某元素,查找成功返回1,否则返回0。 4.实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。 5.判断该顺序表...
  • 数据结构实验两个有序顺序表的合并.doc
  • 数据结构---顺序表实验(C语言实现)

    千次阅读 多人点赞 2020-10-29 00:36:40
    在给出组初始数据的情况下,实现顺序表的定义、创建、查找、插入、删除。 算法 顺序表的定义:维数组、最大长度、实际长度 顺序表的创建:初始化顺序表 顺序表的查找:给出位置 i 的数据 顺序表的插入:位置 i ...
  • //顺序表的长度,取第i个元素,判断有无e这个元素,把e插到最后,输出表,合并表 #include <iostream> using namespace std; #define max 100 #define ok 1 #define error 0 typedef struct { int *elem; ...
  • 掌握线性表的动态分配顺序存储结构的定义和基本操作的实现 二实验内容 输入组整型数据建立顺序表 实现该线性表的删除 3实现该线性表的插入 实现线性表中数据的显示 实现线性表数据的查找和定位 5编写个主函数,...
  • 数据结构实验报告(顺序表基本操作

    千次阅读 多人点赞 2021-04-04 02:51:00
    #define MAXSIZE 100 //顺序表的最大长度; int k=0;//全局变量,用于循环; typedef int elemtype;//元素类型; typedef struct{ elemtype data[MAXSIZE];//用数组存储线性表的元素; int length;//顺序表的长度...
  • 采用C++语言实现数据结构顺序表的基本运算与操作
  • 实验目的 1.掌握顺序表的定义。 2.熟悉C语言的上机环境,进一步掌握C语言的结构特点。 3.掌握顺序表的初始化、创建、输出、查找、插入、删除、拷贝等基础操作。 4.掌握无序顺序表的冒泡排序和快速排序算法。...
  • 1.依次从键盘读入数据,建立顺序表和链表;2.求顺序表的长度;3.根据指定条件能获取元素;4.实现在指定位置插入和删除元素的功能 主菜单设计要求: 程序运行后创建顺序表和链表,之后给出9个菜单项的内容和输入提示...
  • 数据结构实验总结.pdf

    2019-09-19 16:46:50
    数据结构(用C语言实现)实验总结(源代码),包含顺序表增删查改、链表增删查改、顺序栈、链栈、顺序队列存取、链式队列存取、顺序二叉树、排序二叉树、无向图(用邻接链表和邻接矩阵实现)。
  • 数据结构实验一顺序表的实现及应用

    千次阅读 多人点赞 2020-12-20 21:59:14
    数据结构实验 实验顺序表的实现及应用 实验顺序表的实现及应用 、实验实习目的及要求 了解和掌握线性表的顺序存储结构;掌握用C语言上机调试线性表的基本方法;掌握线性表的基本操作:插入、删除、查找...
  • 第1行输入若干个构成顺序表的正整数,使用 -1 结束,例如:1 2 3 4 5 -1。 第2行输入要插入顺序表的元素。例如:99。 测试数据在1~99之间。 输出格式: 参照主函数及输出样例,输出格式使用%3d。 输入样例: 1 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,979
精华内容 35,191
关键字:

数据结构实验一顺序表

数据结构 订阅