实验二、顺序表的基本操作【简单易懂，代码可以直接运行】

最新推荐文章于 2023-03-06 12:04:25 发布
最新推荐文章于 2023-03-06 12:04:25 发布
阅读量2.4k 收藏 27
点赞数 15
分类专栏： 笔记 文章标签： 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45527999/article/details/119838696
版权

实验二、顺序表的基本操作

（1）实验目的
通过该实验，深入理解顺序表的逻辑结构、物理结构等概念，掌握顺序表基本操作的编程实现，注意顺序表插入、删除等操作过程中数据元素的移动现象，培养学生编写程序时，要考虑程序的强壮性，熟练掌握通过函数参数返回函数结果的办法。
（2）实验内容
编程实现顺序表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。
（3）参考界面：
在这里插入图片描述
（4）验收/测试用例
通过菜单调用各个操作，测试点：
 没有初始化前进行其他操作，程序是否能控制住；
 初始化一个顺序表；
 插入数据(位置， 数据)，要测插入位置不合法的情况（0,1）、（2,1），正确插入4个数据（1，2）、（1，1）、（3,3）；
 显示顺序表中的数据，屏幕输出1， 2， 3；
 判空，屏幕输出顺便表非空；
 顺便表长度，屏幕输出3；
 获取指定位置元素，要测指定位置在【1，3】范围之外的情况和之内的情况；
 定位，输入：4， 输出：不存在，输入2，输出位置为2；
 求直接前驱，要测求第一个元素的前驱、不存在顺序表中的元素的直接前驱，其他元素的直接前驱；
 求直接后继，要测最后一个元素的后继、不存在顺序表中的元素的直接后继，其他元素的直接后继；
 删除，要测位置在【1，3】范围之外的情况和之内的情况；
 清空操作后再测长度；
 销毁顺序表

从这个实验开始，数据结构的实验就变得困难了，会大量用到函数与指针，这个实验是我当时写了4天左右才写出来（运行起来，对于我来说运行起来就是写出来了，嘿嘿），但是第一次找老师检查程序的时候里面的bug非常多，换一换数据程序就会卡死，后来和同学进行了很多讨论，也画了很多顺序表的图，想着你们会不想画图，后面我留了一张顺序表合并的图通俗易懂嗷。最后成功做出来了这个程序。很不容易，点个赞吧，秋梨膏！！

小Tip：自己写出来的程序，让老师检查，平时分会更高哦！！

先读懂程序，按照程序写一边，能运行出来，搞懂每一步，能可以在老师的问题下回答出来，就算是自己写出来的。

这个程序算是比较困难的程序了，坚持下去，每一次都能自己做出来程序的话，对于一个对自己变成不自信的人来说还是挺有成就感到，我是自己写出来的程序能够跑起来我就有成就感，hhh。
此外，我当时比较喜欢C艹里面的cin和cout我觉得比scanf和printf更加简单和方便（主要是好敲和不用考虑数据类型）

代码如下：

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

#define ok 1
#define false 0
#define overflow -2
#define maxsize 200

typedef int Status;
typedef int ElemType;

typedef struct{        //给结构体起名：SqList 
	ElemType *elem;     //存储空间基址 
	int length;         //当前长度 
	int listsize;       //当前分配的存储容量 
}SqList;

Status InitList(SqList &L);
Status DestoryList(SqList &L);
Status ClearList(SqList &L);
Status ListEmpty(SqList L);
Status ListLength(SqList L);
Status GetElemt(SqList L,int i);
Status LocateElemt(SqList L,int cur_e);//Status PriorElemt(SqList L,int cur_e,int * pri_e)
Status PriorElemt(SqList L,int i,int *pri_e);
Status NextElemt(SqList L,int i,int *next_e);
Status InsertElem(SqList &L,int i,int e);
Status DeleteElem(SqList &L,int i);
Status ListTraver(SqList &L);
void MergeLsit(SqList LA,SqList LB,SqList &LC);

int main()
{
	int i,j,m,n,inser,dizhi,cur_e,pri_e,next_e;
	//int *e;
	SqList L;
	SqList LA;
	SqList LB;
	SqList LC;
	L.elem = NULL;
		cout<<"*********************"<<endl;
		cout<<"自己可以单独运行一下试试"<<endl;
		cout<<"1.初始化线性表"<<endl;
		cout<<"2.销毁线性表"<<endl;
		cout<<"3.清空线性表"<<endl;
		cout<<"4.判断线性表是否为空"<<endl;
		cout<<"5.求线性表长度"<<endl;
		cout<<"6.输入要查找的位置"<<endl;
		cout<<"7.求前驱"<<endl;
		cout<<"8.求后继"<<endl;
		cout<<"9.在线性表指定位置插入元素"<<endl;
		cout<<"10.删除线性表指定位置位置元素"<<endl;
		cout<<"11.显示线性表"<<endl;
		cout<<"12.初始化线性表LA,LB,LC"<<endl;
		cout<<"13.插入构建线性表LA"<<endl;
		cout<<"14.插入构建线性表LB"<<endl;
		cout<<"15.合并两个非递减顺序表"<<endl;
		cout<<"16.查找元素位置"<<endl;
		cout<<"输入一个负数退出"<<endl;
		cout<<"**********************"<<endl;
		do{
			cout<<"请输入你的选择： "<<endl;
			cin>>n;
			cout<<endl;
			switch(n)
			{
				case 1:InitList(L);
				break;
			    case 2:DestoryList(L);
			    break;
			    case 3:ClearList(L);
			    break;
			    case 4:ListEmpty(L);
			    break;
			    case 5:ListLength(L);
			    break;
			    case 6:
			    	cout<<"输入指定位置："<<endl;
			    	cin>>i;
			    	GetElemt(L,i);
			    	break;
			    case 7:
			    	cout<<"输入要求前驱的元素："<<endl;
			    	cin>>cur_e;
			    	PriorElemt(L,cur_e,&pri_e);//修改去掉了地址引用符 
			    	break;
			    case 8:
			    	cout<<"输入要求后继的元素："<<endl;
			    	cin>>cur_e;
			    	//cout<<""<<endl;
			    	NextElemt(L,cur_e,&next_e);
			    	break;
			    case 9:
			    	cout<<"输入线性表指定位置："<<endl;
			    	cin>>i;
			    	cout<<"输入要插入的元素："<<endl;
			    	cin>>inser;
			    	InsertElem(L,i,inser);
			    	break;
			    case 10:
			    cout<<"输入要删除元素的位置："<<endl;
			    cin>>i;
			    DeleteElem(L,i);
			    break;
			    case 11:
			    ListTraver(L);
			    break;
			    case 12:
			    	InitList(LA);
			    	InitList(LB);
			    	InitList(LC);
			    break;
			    case 13:
			    	cout<<"输入线性表LA指定位置："<<endl;
			    	cin>>i;
			    	cout<<"输入要插入的元素："<<endl;
			    	cin>>inser;
			    	InsertElem(LA,i,inser);
			    	break;
			    case 14:
			    	cout<<"输入线性表LB指定位置："<<endl;
			    	cin>>i;
			    	cout<<"输入要插入的元素："<<endl;
			    	cin>>inser;
			    	InsertElem(LB,i,inser);
			    	break;
			    case 15:
			    	MergeLsit(LA,LB, LC);
			    	break;
			    case 16:
			    	cout<<"输入该元素的位置："<<endl;
			    	cin>>cur_e;
			    	LocateElemt(L,cur_e);
				    break; 
			    default :cout<<"请输入1~16内的数字！！"<<endl;
			    break;
			}
		}while(n > 0);
	
	
}


Status InitList(SqList &L){
	L.elem = (ElemType *)malloc(maxsize*sizeof(ElemType));//申请地址空间，书上有他的伪代码，之后整个语句用到的非常多，一般都是这样用，不要因为这行代码的函数多感到害怕,(ElemType)括号里面加*，这个顺序表就是链表，不加*就是数组
	if(! L.elem) exit(overflow);
	L.length = 0;
	L.listsize = maxsize;
	cout<<"线性表初始化成功！"<<endl;
	return ok;
}

Status DestoryList(SqList &L){
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
	free(L.elem);
	L.elem = NULL;
	cout<<"线性表销毁成功"<<endl;
	
}

Status ClearList(SqList &L){
	//if(L.length == 0)
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}

	L.length = 0;
	cout<<"线性表清除成功"<<endl;
	
}

Status ListEmpty(SqList L){
	//if(L.length == 0)
	if(L.length == 0)
	{
		cout<<"线性表为空"<<endl;
		return ok;
	}
	else
	{
		cout<<"该线性表不为空"<<endl;
		return false;
	}
} 

Status ListLength(SqList L){
	//if(L.length == 0)
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
		cout<<"线性表长度为："<<L.length<<endl;
		return ok;
		//return (L.length);
} 

Status GetElemt(SqList L,int i){
	//if(L.length == 0)
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
	if(i < 1||i > L.length)
	{
		cout<<"不存在，请输入线性表长度范围内的数"<<endl;
		return false;
	}
		//*e = L.elem[i - 1];
		cout<<"该元素为："<<L.elem[i - 1]<<endl; 
		return ok;
}

Status PriorElemt(SqList L,int cur_e,int * pri_e){//求解前驱 
	
    int i = 0;
    //if(L.length == 0)
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
    
   
	while((L.elem[i] != cur_e) && (i < L.length))
	{i++;}
	if(i < L.length)
	{
		if(i == 0)
		{
			cout<<"该元素位于元首，没有前驱！"<<endl;
			return false;
		}
		*pri_e = L.elem[i - 1];
	    cout<<"该元素的前驱："<<*pri_e<<endl; 
		return ok;
	}
	else
	{
		cout<<"该线性表中没有该元素!"<<endl;
		return ok;
	}

}

Status NextElemt(SqList L,int cur_e,int * next_e){
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
	
	int i = 0;
 	while((L.elem[i] != cur_e) && (i < L.length))
 	{i++;}
 	if(i < L.length)
 	{
 		if(i == L.length - 1)
 		{
 			cout<<"该元素没有后继！"<<endl;
 			return false;
		 }
		 *next_e = L.elem[i + 1];
		 cout<<"该元素的后继："<<*next_e<<endl; 
		 return ok;
	 }
	 else
	 {
	 	cout<<"该线性表中没有该元素!"<<endl;
	 	return false;
	 }
	
 
}

Status InsertElem(SqList &L,int i,int e){
	int j;
	//if(L.length == 0)
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
	if(i < 1||i > L.length + 1)//循序表的第一个元素位置记为1了 
	{
		cout<<"请输入线性表长度以内的数"<<endl;
		return false;
	}
	if(L.length == maxsize)    //线性表已经存满 
	{return false;}
	
	for(j = L.length;j >= i - 1;j--)
	{
		L.elem[j + 1] = L.elem[j];
	}
	L.elem[i - 1] = e;
	L.length++;
	cout<<"元素插入成功"<<endl;
	return ok;
}

Status DeleteElem(SqList &L,int i){
	int j;
	//if(L.length == 0)
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
	if(i < 1||i > L.length + 1)
	{
		cout<<"请输入线性表长度以内的数"<<endl;
		return false;
    }
    for(j = i - 1;j <= L.length;j++)
    {
    	L.elem[j] = L.elem[j + 1];
	}
	L.length--;
	cout<<"删除元素成功！"<<endl;
	return ok;
}

Status ListTraver(SqList &L){
	int i;
	//if(L.length == 0)
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
	cout<<"输出该线性表："<<endl;
	for(i = 0;i < L.length;i++)
	{
		cout<<L.elem[i]<<" ";
	}
	cout<<endl;
	return ok;
}
void MergeLsit(SqList LA,SqList LB,SqList &LC){
	int i,j; 
	cout<<"输出线性表LA："<<endl;
	ListTraver(LA);
	cout<<"输出线性表LB:"<<endl;
	ListTraver(LB);
	int *pa,*pb,*pc,*pa_last,*pb_last;
	pa = LA.elem;
	pb = LB.elem;
	LC.length = LA.length + LB.length;
	pc = LC.elem;
	pa_last = LA.elem + LA.length - 1;
	pb_last = LB.elem + LB.length - 1;
	while((pa <= pa_last) && (pb <= pb_last)){
		if(*pa < *pb)
		{
			*pc = *pa;
			*pc++;
			*pa++;
		}
		else
		{
			*pc = *pb;
			*pc++;
			*pb++;
		}
		
	}
	
	while(pa <= pa_last)
	{
		*pc = *pa;
		*pc++;
		*pa++;
	}
	while(pb <= pb_last)
	{
		*pc = *pb;
		*pc++;
		*pb++;
	}
	//新合并的顺序表进行查重
	 for(i = 0;i < LC.length;i++)
	 {
	 	for(j = 0;j < i;j++)
	 	{
	 		if(LC.elem[i] == LC.elem[j])
	 		{
	 			cout<<"重复的元素为："<<LC.elem[i]<<endl;
	 		    cout<<"请输入一个新元素："<<endl;
				 cin>>LC.elem[i];
				 j = -1;
			}
		}
	 }
	 cout<<"输出此时的数组LC:"<<endl;
	  ListTraver(LC);
	
}

Status LocateElemt(SqList L,int cur_e){
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
	
	int i = 0;
	int m = 0;
 	for(i = 0;i < L.length;i++)
 	{
 		if(L.elem[i] == cur_e)
 		{
 			cout<<"该元素的位置为"<<i + 1<<endl;
 			m = -1;
 			return ok;
		 }
	 }
	 if(m == 0)
	 {
	 	cout<<"该元素不在线性表中"<<endl;
	 	return false;
	 }
 	
}

这个程序相对来说还是挺大的，特别是整个小程序该如何构建顺序表，怎么向初始化后的顺序表里面填充数据，下面将手把手演示如何进行数据操作。除此之外，整个程序难的地方还有一个就是两个顺序表合并的问题。里面主要涉及到的是两个顺序表合并的话，如何剔除两个顺序表中的相同元素，我当时实现这个功能的时候一直干到迷惑，后来我单独写了一个小的代码程序，把这个功能给实现了，放在文章后面会贴出来：

小 Tip：画图会让你的视野豁然开朗，不要凭空想象

程序如何运行：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
接下来是合并两个顺序表的代码，它里面主要是指针的所指向的位置不断改变：知道你们可能不想画图，我就给你们画一下吧！
在这里插入图片描述
不要嫌弃字不好看，再合并两个顺序表之后，会有算法去剔除重复的元素的，和实验一那个从集合里面剔除重复元素的算法一样。

代码如下：这个代码的数据，我就不掩饰了，和大程序的12，13，14，15的过程是一样的。

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

#define ok 1
#define false 0
#define overflow -2
#define maxsize 200

typedef int Status;
typedef int ElemType;

typedef struct{        //给结构体起名：SqList 
	ElemType *elem;     //存储空间基址 
	int length;         //当前长度 
	int listsize;       //当前分配的存储容量 
}SqList;
Status InitList(SqList &L);
Status InsertElem(SqList &L,int i,int e);
Status ListTraver(SqList &L);
void MergeLsit(SqList &LA,SqList &LB,SqList &LC);

int main()
{
    int i,j,m,n,inser,dizhi,cur_e,e;
	SqList LA;
	SqList LB;
	SqList LC;
	LA.elem = NULL;
	LB.elem = NULL;
	LC.elem = NULL;
	cout<<"****************"<<endl;
	cout<<"1.初始化线性表LA,LB,LC"<<endl;
	cout<<"2.插入LA构建线性表A"<<endl;
	cout<<"3.插入LB构建线性表B"<<endl;
	cout<<"4.合并线性表LA与LB"<<endl;
	cout<<"****************"<<endl;
	do{
		cout<<"请输入你的选择： "<<endl;
		cin>>n;
		switch(n){
			case 1:
			InitList(LA);
			InitList(LB);
			InitList(LC);
			break;
			case 2:
				cout<<"输入此时插入LA的位置： "<<endl;
				cin>>i;
				cout<<"输入要插入的元素： "<<endl;
				cin>>e;
				InsertElem(LA,i,e);
				break; 
			case 3:
				cout<<" 输入此时插入LB的位置："<<endl;
				cin>>i;
				cout<<" 输入要插入的元素："<<endl;
				cin>>e;
				InsertElem(LB,i,e);
				break; 
			case 4:
				/*cout<<"此时的线性表LA"<<endl;
				ListTraver(LA);
				cout<<"此时的线性表LB"<<endl;
				ListTraver(LB);
				cout<<"输出此时的线性表LC"<<endl;*/
				MergeLsit(LA,LB,LC);
				break;
			default:
				cout<<"请输入1~4内的数"<<endl;
				break; 
				
		}
	}while(n > 0);
}

Status InitList(SqList &L){
	L.elem = (ElemType *)malloc(maxsize*sizeof(ElemType));
	if(L.elem == NULL)
	{exit(overflow);}
	L.listsize = maxsize;
	L.length = 0;
	cout<<"线性表初始化成功！！"<<endl;
	return ok;
}

Status InsertElem(SqList &L,int i,int e){
	int j;
	if(L.elem == NULL){
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
	if(L.length == maxsize)
	{
		cout<<"线性表已满！"<<endl;
		return false;
	}
	if(i < 1||i > L.length + 1)
	{
		cout<<"请输入正确位置"<<endl;
		return false; 
	}
	for(j = i;j < L.length;j++)
	{
		L.elem[j + 1] = L.elem[j];
	}
	L.elem[i - 1] = e;
	L.length++;
	//L.length++;
	cout<<"元素插入成功"<<endl;
	return ok;
}

Status ListTraver(SqList &L){
	int i;
	if(L.elem == NULL)
	{
		cout<<"请先初始化线性表"<<endl;
		return false;
	}
	for(i = 0;i < L.length;i++)
    {
    	cout<<L.elem[i]<<" ";
	}
	return ok;
} 

void MergeLsit(SqList &LA,SqList &LB,SqList &LC){
	int i,j;
	cout<<"此时的线性表LA:"<<endl;
	ListTraver(LA);
	cout<<endl;
	cout<<"此时的线性表LB:"<<endl;
	ListTraver(LB);
	cout<<endl;
	int *pa,*pb,*pc,*pa_last,*pb_last;
	pa = LA.elem;
	pb = LB.elem;
	pc = LC.elem;
	pa_last = pa + LA.length - 1;
	pb_last = pb + LB.length - 1;
	LC.length = LA.length + LB.length;
	while((pa <= pa_last) && (pb <= pb_last))
	{
		if(*pa < *pb)
		{
			*pc = *pa;
			pc++;
			pa++;
		}
		else
		{
			*pc = *pb;
			pc++;
			pb++; 
		}
}
		while(pa <= pa_last)
		{
			*pc = *pa;
			pc++;
			pa++;
		}
	   while(pb <= pb_last)
	   {
	   	    *pc = *pb;
			pc++;
			pb++; 
	   }
	
	for(i = 0;i < LC.length;i++)
	{
		for(j = 0;j < i;j++)
		{
			if(LC.elem[i] == LC.elem[j])
			{
				cout<<"线性表中重复的元素为："<<LC.elem[i]<<endl;
				cout<<"请输入一个新元素：";
				cin>>LC.elem[i];
				j = -1; 
			}
		}
	}
	//cout<<"输出此时的数组LC:"<<endl;
	ListTraver(LC);
	cout<<endl;
}

制作不易，看到这里点个赞吧。留个赞好吗？秋梨膏！！
在这里插入图片描述

henu-于笨笨
关注
  • 15
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构实验一（顺序表基本操作）题目和源程序
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。
线性表之顺序表
sherilindas的博客
07-25 690
线性表线性表是由n(n≥0)个相同类型的数据元素构成的有限序列。对于这个定义应该注意两个概念：一是“有限”，指的是线性表中的数据元素的个数是有限的，线性表中的每一个数据元素都有自己的位置。二是“相同类型，指的是线性表中的数据元素都属于同一种类型。线性表又分为顺序表和链表。顺序表（数组）的概念顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表
线性表的顺序存储结构——顺序表及其操作
striver的博客
03-10 868
文章目录1.线性表：1.1线性表的定义及逻辑表示2.线性表的顺序存储结构——顺序表2.1顺序表定义2.2建立顺序表2.3顺序表的基本操作 1.线性表： 1.1线性表的定义及逻辑表示 线性表是一个具有相同特征的数据元素的有限序列， 线性表的逻辑表示为：( a1，a2，…，ai，ai+1，…，an ) 其中 ai(1≤i≤n) 表示第i（i表示逻辑位序）个元素 2.线性表的顺序存储结构——顺序表 2.1顺序表定义 线性表的顺序存储结构是把线性表中的所有元素按照顺序存储方法进行存储，如下图所示 2.2建立顺序表
数据结构|创建学生成绩的顺序表（实验2.1）
记录软件测试过程中遇到的问题
10-10 4307
一、实验目的 巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二、实验内容 建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。分别输出结果。 源代码如下： #include using namespace std; const int
[实验一] 顺序表的基本操作
哦绝影
03-22 4020
(1) 从键盘上依次输入21、18、30、75、42、55、99、35、40，创建顺序表，并输出顺序表中的各元素值（自己编写） (2) 分别在顺序表的第3个位置和第9个位置插入67和10，给出插入成功或失败的信息，并输出顺序表中的各元素值（参考代码） (3) 查找值为10的元素，找到返回其位序，否则返回0（自己编写） (4) 查找顺序表中的最大元素值并输出（自己编写） (5) 对顺序表元素
线性表——顺序表（含代码）
喜欢黄花鱼的猫
03-29 1656
顺序表 静态分配 动态分配顺序表的实现与基本操作 c++
顺序表的代码实现
m0_73592835的博客
12-15 896
顺序表的代码实现
顺序表的操作实验
your_darling的博客
03-17 4365
实验一 顺序表的操作实验 一、实验名称和性质 所属课程 数据结构与算法 实验名称 顺序表的操作 实验学时 2 实验性质 √验证 □综合 □设计 必做/选做 √必做 □选做 二、实验目的 1．掌握线性表的顺序存储结构的表示和实现方法。 2．掌握顺序表基本操作的算法实现。 3．了解顺序表的应用。 三、实验内容 1．建立含n个数据元素的顺序表并输出该表中各元素的值。 2．在有序顺序表L中插入元素x使线性表仍然有序。 3．写一个函数删除有序顺序表中的重复元素。 四、知识准备 前期要求熟练掌握了C语言的编程规则、方法
顺序表实验——顺序表的基本操作
hsrnb123的博客
12-25 4205
顺序表，线性表i的基本操作
C++ （数据结构）基于顺序表的有关操作
ninini12386的博客
11-03 1324
实验2、基于顺序表的非递减有序表的合并 （1）实验目的 通过该实验，深入理解顺序表的逻辑结构、物理结构等概念，掌握顺序表基本操作的编程实现，注意顺序表插入、删除等操作过程中数据元素的移动现象，培养学生编写程序时，要考虑程序的健壮性，全面考虑问题，熟练掌握通过函数参数返回函数结果的办法。 （2）实验内容 编程实现顺序表下教材第二章定义的线性表的基本操作，并根据已经实现的基本操作，实现两个非递减有序的线性表的合并，注意，合并时，如果有重复的元素，请保留一个。 （3）实验要求 （a）求前驱是指，输入一个元素值（而
顺序表的基本操作实验报告.doc
04-16
有顺序表的插入数据，删除数据，初始化，获取数据
实验一：顺序表基本操作
03-03
大学生实验作业
实验2.0_顺序表的实现及基本操作_
09-29
创建有若干个元素（可以是整型数值）的顺序表，实现对顺序表的初始化，对已建立的顺序表插入操作、删除操作、遍历输出顺序表。 要求各个操作均以函数的形式实现，在主函数中调用各个函数实现以下操作： （1）创建...
数据结构上机_顺序表基本操作_数据结构基础_
09-29
实现顺序表的初始化，输出顺序表中各元素的值，在顺序表中插入数据元素，删除数据元素，求顺序表的长度，顺序表的逆置，顺序表的按值从小到大排序，合并有序的两个顺序表等操作。
顺序表的基本操作.rar
最新发布
03-16
顺序表的基本操作
线性表的顺序存储结构的实现
yzl_rex
07-19 6052
1.初始化线性表L，即进行动态存储空间分配并置L为一个空表 2.清除线性表L中的所有元素，释放存储空间，使之成为一个空表 3.返回线性表L当前的长度，若L为空则返回０ 4.判断线性表L是否为空，若为空则返回1, 否则返回0 5.返回线性表L中第pos个元素的值，若pos超出范围，则停止程序运行 6.顺序扫描（即遍历）输出线性表L中的每个元素 7.从线性表L中查找值与x相等的元素，若查找成功则
数据结构3_线性表_顺序表的基本操作及实现
毛钱儿的博客
04-09 673
数据结构3_线性表_1 总览： 线性表： 线性表是具有相同数据类型的n(n>=0)个数据元素的有序序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，其一般表示为： L=(a1,a2,a3,a4,∗∗∗,an) L = (a1,a2,a3,a4,***,an) L=(a1,a2,a3,a4,∗∗∗,an) a1为表头元素，an为表尾元素，除了an其他元素都有唯一的直接后继，除...
数据结构入门----顺序表的基本操作
qq1457346557的博客
07-04 2920
（1）实验目的 通过该实验，深入理解顺序表的逻辑结构、物理结构等概念，掌握顺序表基本操作的编程实现，注意顺序表插入、删除等操作过程中数据元素的移动现象，培养学生编写程序时，要考虑程序的强壮性，熟练掌握通过函数参数返回函数结果的办法。 （2）实验内容 编程实现顺序表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编成一个完整的小软件。 （3）参考界面 注：销毁是指free(L.elem); L.elem=NULL; L.length=0; L.listsize=0; return TRUE
C语言实现顺序表（动态）
2301_76269963的博客
03-06 1117
C语言实现顺序表（动态）
能够直接运行的顺序表基本操作
06-09
下面是一个完整的、能够直接运行的顺序表基本操作的示例代码，包括初始化、插入、删除、查找和遍历操作： ```c #include #include #define MAXSIZE 100 // 定义顺序表的最大长度 typedef struct { int data...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

henu-于笨笨

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值