顺序表作业

已于 2022-02-02 11:03:12 修改
阅读量5.2k 收藏 58
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 算法 c语言
于 2021-10-11 16:47:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50849959/article/details/120700290
版权

1:第二章 实验题2：2.1 顺序表——调整数据元素
总时间限制: 10000ms 内存限制: 10000kB
描述
假设一个顺序表L中所有元素为整数，设计一个算法调整该顺序表，使其中所有小于零的元素移动到所有大于等于零的元素的前面。

输入
无
输出
2 -1 0 2 -2 3 -3
-3 -1 -2 2 0 3 2
样例输入
无
样例输出
2 -1 0 2 -2 3 -3
-3 -1 -2 2 0 3 2

ac代码：

#include <stdio.h>
#include <iostream>
using namespace std;
#define MaxSize 100
typedef int ElemType;				//设置顺序表元素为int类型
typedef struct
{	ElemType data[MaxSize];			//存放顺序表的元素
	int length;						//顺序表的实际长度
} SqList;							//顺序表类型声明
void InitList(SqList &L)			//初始化顺序表L
{
	L.length=0;
}
void DestroyList(SqList L)			//销毁顺序表L
{
}
int GetLength(SqList L)				//求长度
{
	return L.length;
}
int GetElem(SqList L,int i,ElemType &e)	//求第i个元素
{	if (i<1 || i>L.length)			//无效的i值
		return 0;
	else
	{	e=L.data[i-1];
		return 1;
	}
}
int Locate(SqList L,ElemType x)		//查找第一个x元素的位置
{	int i=0;
	while (i<L.length && L.data[i]!=x)
		i++; 						//查找第1个值为x的元素
	if (i>=L.length) return(0);		//未找到返回0
	else return(i+1);				//找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i)	//插入x作为第i个元素
{	int j;
	if (i<1 || i>L.length+1)		//无效的参数i
		return 0;
	for (j=L.length;j>i;j--)		//将位置为i的元素及之后的元素后移
		L.data[j]=L.data[j-1];
	L.data[i-1]=x;					//在位置i处放入x
	L.length++;						//顺序表长度增1
	return 1;
}
int DelElem(SqList &L,int i)		//删除第i个元素
{	int j;
	if (i<1 || i>L.length)			//无效的参数i
		return 0;
	for (j=i;j<L.length;j++)		//将位置为i的元素之后的元素前移
		L.data[j-1]=L.data[j];
	L.length--;						//顺序表长度减1
	return 1;
}
void DispList(SqList L)				//输出顺序表
{	int i;
	for (i=0;i<L.length;i++)
		printf("%d ",L.data[i]);
	printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n)	//整体创建顺序表L
{
	int i,k=0;						//k累计顺序表L中的元素个数
	for (i=0;i<n;i++)
	{
		L.data[k]=a[i];				//向L中添加一个元素
		k++;						//L中元素个数增1
	}
	L.length=k;						//设置L的长度
}
void Move(SqList &L)	
{
	int j=L.length-1;
	for(int i=0;i<L.length/2;i++)
	{
		if(L.data[i]>=0&&L.data[j]<=0)
		{
			int k=L.data[i];
			L.data[i]=L.data[j];
			L.data[j]=k;
		}
		j--;
	}
 } 
int main()
{
	SqList L;
	int a[]={2,-1,0,2,-2,3,-3};
	int n=sizeof(a)/sizeof(a[0]);
	CreateList(L,a,n);
    DispList(L);
	Move(L);//  移动求解算法 
	DispList(L);
	DestroyList(L);
	return 0;
}

2:第二章 实验题2：2.2 顺序表——删除最大值
总时间限制: 10000ms 内存限制: 10000kB
描述
有一个整数序列，采用顺序表L存储。设计尽可能高效的算法删除L中最大值的元素（假设这样的元素有多个）。

输入
无
输出
2 1 5 4 2 5 1 5 4
2 1 4 2 1 4
样例输入
无
样例输出
2 1 5 4 2 5 1 5 4
2 1 4 2 1 4

ac代码：

#include <stdio.h>
#include<iostream> 
using namespace std;
#define MaxSize 100
typedef int ElemType;				//设置顺序表元素为int类型
typedef struct
{	ElemType data[MaxSize];			//存放顺序表的元素
	int length;						//顺序表的实际长度
} SqList;							//顺序表类型声明
void InitList(SqList &L)			//初始化顺序表L
{
	L.length=0;
}
void DestroyList(SqList L)			//销毁顺序表L
{
}
int GetLength(SqList L)				//求长度
{
	return L.length;
}
int GetElem(SqList L,int i,ElemType &e)	//求第i个元素
{	if (i<1 || i>L.length)			//无效的i值
		return 0;
	else
	{	e=L.data[i-1];
		return 1;
	}
}
int Locate(SqList L,ElemType x)		//查找第一个x元素的位置
{	int i=0;
	while (i<L.length && L.data[i]!=x)
		i++; 						//查找第1个值为x的元素
	if (i>=L.length) return(0);		//未找到返回0
	else return(i+1);				//找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i)	//插入x作为第i个元素
{	int j;
	if (i<1 || i>L.length+1)		//无效的参数i
		return 0;
	for (j=L.length;j>i;j--)		//将位置为i的元素及之后的元素后移
		L.data[j]=L.data[j-1];
	L.data[i-1]=x;					//在位置i处放入x
	L.length++;						//顺序表长度增1
	return 1;
}
int DelElem(SqList &L,int i)		//删除第i个元素
{	int j;
	if (i<1 || i>L.length)			//无效的参数i
		return 0;
	for (j=i;j<L.length;j++)		//将位置为i的元素之后的元素前移
		L.data[j-1]=L.data[j];
	L.length--;						//顺序表长度减1
	return 1;
}
void DispList(SqList L)				//输出顺序表
{	int i;
	for (i=0;i<L.length;i++)
		printf("%d ",L.data[i]);
	printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n)	//整体创建顺序表L
{
	int i,k=0;						//k累计顺序表L中的元素个数
	for (i=0;i<n;i++)
	{
		L.data[k]=a[i];				//向L中添加一个元素
		k++;						//L中元素个数增1
	}
	L.length=k;						//设置L的长度
}
void Deletex(SqList &L,ElemType x)
{	int i,k=0;
	for (i=0;i<L.length;i++)
		if (L.data[i]!=x)		//将不为x的元素插入到L中
		{	L.data[k]=L.data[i];
			k++;
		}
	L.length=k;					//重置L的长度
}
int Delmaxe(SqList &L)
{int max=L.data[0];
	for(int i=0;i<L.length-1;i++)
	{
		
		if(L.data[i]<L.data[i+1])
		{
			max=L.data[i+1];
		}
	}
	//printf("%d\n",max);
	for(int i=0;i<L.length;i++)
	{
		if(L.data[i]==max)
		{
			//printf("%d\n",L.data[i]);
			DelElem(L,i+1);
		}
		
	}
}
int main()
{
	SqList L;
	int a[]={2,1,5,4,2,5,1,5,4};
	int n=sizeof(a)/sizeof(a[0]);
	CreateList(L,a,n);
	DispList(L);
	Delmaxe(L);
	DispList(L);
	DestroyList(L);
	return 0;
}

3:第二章 实验题2：2.5 有序顺序表——删除重复元素
总时间限制: 10000ms 内存限制: 10000kB
描述
设计一个算法从有序顺序表中删除重复的元素，多个值相同的元素仅保留第一个。

输入
无
输出
1 2 2 2 5 5 5
1 2 5
样例输入
无
样例输出
1 2 2 2 5 5 5
1 2 5

ac代码：

#include <stdio.h>
#include<iostream> 
using namespace std;
#define MaxSize 100
typedef int ElemType;				//设置顺序表元素为int类型
typedef struct
{	ElemType data[MaxSize];			//存放顺序表的元素
	int length;						//顺序表的实际长度
} SqList;							//顺序表类型声明
void InitList(SqList &L)			//初始化顺序表L
{
	L.length=0;
}
void DestroyList(SqList L)			//销毁顺序表L
{
}
int GetLength(SqList L)				//求长度
{
	return L.length;
}
int GetElem(SqList L,int i,ElemType &e)	//求第i个元素
{	if (i<1 || i>L.length)			//无效的i值
		return 0;
	else
	{	e=L.data[i-1];
		return 1;
	}
}
int Locate(SqList L,ElemType x)		//查找第一个x元素的位置
{	int i=0;
	while (i<L.length && L.data[i]!=x)
		i++; 						//查找第1个值为x的元素
	if (i>=L.length) return(0);		//未找到返回0
	else return(i+1);				//找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i)	//插入x作为第i个元素
{	int j;
	if (i<1 || i>L.length+1)		//无效的参数i
		return 0;
	for (j=L.length;j>i;j--)		//将位置为i的元素及之后的元素后移
		L.data[j]=L.data[j-1];
	L.data[i-1]=x;					//在位置i处放入x
	L.length++;						//顺序表长度增1
	return 1;
}
int DelElem(SqList &L,int i)		//删除第i个元素
{	int j;
	if (i<1 || i>L.length)			//无效的参数i
		return 0;
	for (j=i;j<L.length;j++)		//将位置为i的元素之后的元素前移
		L.data[j-1]=L.data[j];
	L.length--;						//顺序表长度减1
	return 1;
}
void DispList(SqList L)				//输出顺序表
{	int i;
	for (i=0;i<L.length;i++)
		printf("%d ",L.data[i]);
	printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n)	//整体创建顺序表L
{
	int i,k=0;						//k累计顺序表L中的元素个数
	for (i=0;i<n;i++)
	{
		L.data[k]=a[i];				//向L中添加一个元素
		k++;						//L中元素个数增1
	}
	L.length=k;						//设置L的长度
}
void DelSame(SqList &L)
{
	for(int i=0;i<L.length;i++)
	{
		int k=L.data[i];
		for(int j=i+1;j<L.length;j++)
		{
			if(L.data[j]==L.data[i])
			{
				DelElem(L,j);
				j--;
			}
		}
	}
}
int main()
{
	SqList L;
	int a[]={1,2,2,2,5,5,5};
	int n=sizeof(a)/sizeof(a[0]);
	CreateList(L,a,n);
	DispList(L);
	DelSame(L);  //删除重复元素
	DispList(L);
	DestroyList(L);
}

4:顺序表区间元素删除
总时间限制: 5000ms 内存限制: 5000kB
描述
若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。

输入
三行数据，第一行是顺序表的元素个数，第二行是顺序表的元素，第三行是x和y。
输出
删除元素值在[x,y]之间的所有元素后的顺序表。
样例输入
10
5 1 9 10 67 12 8 33 6 2
3 10
样例输出
1 67 12 33 2

ac代码：

#include <stdio.h>
#include<iostream> 
using namespace std;
#define MaxSize 100
typedef int ElemType;				//设置顺序表元素为int类型
typedef struct
{	ElemType data[MaxSize];			//存放顺序表的元素
	int length;						//顺序表的实际长度
} SqList;							//顺序表类型声明
void InitList(SqList &L)			//初始化顺序表L
{
	L.length=0;
}
void DestroyList(SqList L)			//销毁顺序表L
{
}
int GetLength(SqList L)				//求长度
{
	return L.length;
}
int GetElem(SqList L,int i,ElemType &e)	//求第i个元素
{	if (i<1 || i>L.length)			//无效的i值
		return 0;
	else
	{	e=L.data[i-1];
		return 1;
	}
}
int Locate(SqList L,ElemType x)		//查找第一个x元素的位置
{	int i=0;
	while (i<L.length && L.data[i]!=x)
		i++; 						//查找第1个值为x的元素
	if (i>=L.length) return(0);		//未找到返回0
	else return(i+1);				//找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i)	//插入x作为第i个元素
{	int j;
	if (i<1 || i>L.length+1)		//无效的参数i
		return 0;
	for (j=L.length;j>i;j--)		//将位置为i的元素及之后的元素后移
		L.data[j]=L.data[j-1];
	L.data[i-1]=x;					//在位置i处放入x
	L.length++;						//顺序表长度增1
	return 1;
}
int DelElem(SqList &L,int i)		//删除第i个元素
{	int j;
	if (i<1 || i>L.length)			//无效的参数i
		return 0;
	for (j=i;j<L.length;j++)		//将位置为i的元素之后的元素前移
		L.data[j-1]=L.data[j];
	L.length--;						//顺序表长度减1
	return 1;
}
void DispList(SqList L)				//输出顺序表
{	int i;
	for (i=0;i<L.length;i++)
		printf("%d ",L.data[i]);
	printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n)	//整体创建顺序表L
{
	int i,k=0;						//k累计顺序表L中的元素个数
	for (i=0;i<n;i++)
	{
		L.data[k]=a[i];				//向L中添加一个元素
		k++;						//L中元素个数增1
	}
	L.length=k;						//设置L的长度
}
void Del(SqList &L,int x,int y)
{
	for(int i=0;i<L.length;i++)
	{
		if(L.data[i]>=x&&L.data[i]<=y)
		{	
			//printf("%d%d\n",i,L.data[i]);
			DelElem(L,i+1);
			i--;	
		}	
	}
}
int main()
{
	SqList L;
	int n;
	scanf("%d",&n);
	int a[n];
	//int n=sizeof(a)/sizeof(a[0]);
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	CreateList(L,a,n);
	int x,y;
	scanf("%d%d",&x,&y);
//	printf("%d %d\n",x,y);
//	for(int i=0;i<L.length;i++)
//	{
//		printf("%d\n",L.data[i]);
//	}
	Del(L,x,y);
	DispList(L);
	DestroyList(L);
}

5:顺序有序表中删除多余元素
总时间限制: 1000ms 内存限制: 65535kB
描述
编写算法，在一个非递减有序的顺序表中删除所有值相等的多余的元素。要求时间复杂度为O（n),空间复杂度为O（1）。

输入
两行，第一行为数据元素的个数n，第二行为n个元素，n<=1000000
输出
删除多余元素后的数据序列
样例输入
10
-1 -1 1 2 2 3 3 3 4 5
样例输出
-1 1 2 3 4 5

ac代码：

#include <stdio.h>
#include<iostream> 
using namespace std;
#define MaxSize 1000000
typedef int ElemType;				//设置顺序表元素为int类型
typedef struct
{	ElemType data[MaxSize];			//存放顺序表的元素
	int length;						//顺序表的实际长度
} SqList;							//顺序表类型声明
void InitList(SqList &L)			//初始化顺序表L
{
	L.length=0;
}
void DestroyList(SqList L)			//销毁顺序表L
{
}
int GetLength(SqList L)				//求长度
{
	return L.length;
}
int GetElem(SqList L,int i,ElemType &e)	//求第i个元素
{	if (i<1 || i>L.length)			//无效的i值
		return 0;
	else
	{	e=L.data[i-1];
		return 1;
	}
}
int Locate(SqList L,ElemType x)		//查找第一个x元素的位置
{	int i=0;
	while (i<L.length && L.data[i]!=x)
		i++; 						//查找第1个值为x的元素
	if (i>=L.length) return(0);		//未找到返回0
	else return(i+1);				//找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i)	//插入x作为第i个元素
{	int j;
	if (i<1 || i>L.length+1)		//无效的参数i
		return 0;
	for (j=L.length;j>i;j--)		//将位置为i的元素及之后的元素后移
		L.data[j]=L.data[j-1];
	L.data[i-1]=x;					//在位置i处放入x
	L.length++;						//顺序表长度增1
	return 1;
}
int DelElem(SqList &L,int i)		//删除第i个元素
{	int j;
	if (i<1 || i>L.length)			//无效的参数i
		return 0;
	for (j=i;j<L.length;j++)		//将位置为i的元素之后的元素前移
		L.data[j-1]=L.data[j];
	L.length--;						//顺序表长度减1
	return 1;
}
void DispList(SqList L)				//输出顺序表
{	int i;
	for (i=0;i<L.length;i++)
		printf("%d ",L.data[i]);
	printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n)	//整体创建顺序表L
{
	int i,k=0;						//k累计顺序表L中的元素个数
	for (i=0;i<n;i++)
	{
		L.data[k]=a[i];				//向L中添加一个元素
		k++;						//L中元素个数增1
	}
	L.length=k;						//设置L的长度
}
void DelSame(SqList &L)
{
	int k=0;
	for(int i=0;i<=L.length;i++)
	{
		if(L.data[i]!=L.data[k])
		{
			k++;
			L.data[k]=L.data[i];
		}
	}
	L.length=k;
}
int main()
{
	SqList L;
	int n;
	cin>>n;
	int a[1000000];
	for(int i=0;i<n;i++)
	{
		cin>>a[i];
	}
	CreateList(L,a,n);
	DelSame(L);  //删除重复元素
	DispList(L);
	DestroyList(L);
}

6:整数顺序表的基本运算
总时间限制: 10000ms 内存限制: 10000kB
描述
设计整数顺序表的基本运算程序，并用相关数据进行测试

输入
顺序输入顺序表A的元素个数及各个元素
输出
第一行：创建顺序表A后，输出所有元素
第二行：删除第一个元素，输出删除后的所有元素
第三行：输出删除元素后顺序表的长度
第四行：在第二元素处插入一个新的元素100
第五行：输出第一个元素100所在位置
样例输入
6
1 2 3 4 0 9
样例输出
1 2 3 4 0 9
2 3 4 0 9
5
2 100 3 4 0 9
2

ac代码：

#include <stdio.h>
#include<iostream> 
using namespace std;
#define MaxSize 100
typedef int ElemType;				//设置顺序表元素为int类型
typedef struct
{	ElemType data[MaxSize];			//存放顺序表的元素
	int length;						//顺序表的实际长度
} SqList;							//顺序表类型声明
void InitList(SqList &L)			//初始化顺序表L
{
	L.length=0;
}
void DestroyList(SqList L)			//销毁顺序表L
{
}
int GetLength(SqList L)				//求长度
{
	return L.length;
}
int GetElem(SqList L,int i,ElemType &e)	//求第i个元素
{	if (i<1 || i>L.length)			//无效的i值
		return 0;
	else
	{	e=L.data[i-1];
		return 1;
	}
}
int Locate(SqList L,ElemType x)		//查找第一个x元素的位置
{	int i=0;
	while (i<L.length && L.data[i]!=x)
		i++; 						//查找第1个值为x的元素
	if (i>=L.length) return(0);		//未找到返回0
	else return(i+1);				//找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i)	//插入x作为第i个元素
{	int j;
	if (i<1 || i>L.length+1)		//无效的参数i
		return 0;
	for (j=L.length;j>=i;j--)		//将位置为i的元素及之后的元素后移
		L.data[j]=L.data[j-1];
	L.data[i-1]=x;					//在位置i处放入x
	L.length++;						//顺序表长度增1
	return 1;
}
int DelElem(SqList &L,int i)		//删除第i个元素
{	int j;
	if (i<1 || i>L.length)			//无效的参数i
		return 0;
	for (j=i;j<L.length;j++)		//将位置为i的元素之后的元素前移
		L.data[j-1]=L.data[j];
	L.length--;						//顺序表长度减1
	return 1;
}
void DispList(SqList L)				//输出顺序表
{	int i;
	for (i=0;i<L.length;i++)
		printf("%d ",L.data[i]);
	printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n)	//整体创建顺序表L
{
	int i,k=0;						//k累计顺序表L中的元素个数
	for (i=0;i<n;i++)
	{
		L.data[k]=a[i];				//向L中添加一个元素
		k++;						//L中元素个数增1
	}
	L.length=k;						//设置L的长度
}
void DelSame(SqList &L)
{
	int k=0;
	for(int i=0;i<=L.length;i++)
	{
		if(L.data[i]!=L.data[k])
		{
			k++;
			L.data[k]=L.data[i];
		}
	}
	L.length=k;
}
int main()
{
	SqList L;
	int n;
	cin>>n;
	int a[100];
	for(int i=0;i<n;i++)
	{
		cin>>a[i];
	}
	CreateList(L,a,n);
	DispList(L);
	DelElem(L,1);
	DispList(L);
	cout<<L.length<<endl;
	InsElem(L,100,2);
	DispList(L);
	cout<<Locate(L,100)<<endl;
	DestroyList(L);
}

7:整数顺序表的并集、差集和交集
查看提交统计提问
总时间限制: 10000ms 内存限制: 10000kB
描述
采用顺序表存储非空整数集合（同一个集合中没有相同的元素，两个集合中可能存在相同的元素），设计完成如下功能的算法并用相关数据进行测试。

①求两个集合A、B的并集C=A∪B

②求两个集合A、B的差集C=A-B

③求两个集合A、B的交集C=A∩B

输入
顺序输入集合A的元素个数及各个元素，集合B的元素个数及各个元素
输出
如果A集合或B集合内有重复，输出“Repeat Error!”
如果A集合和B集合合法，则输出并集（输出提示标识为CU）、差集（输出提示标识为CD）、交集（输出提示标识为CI）。
样例输入
4
1 2 3 4
5
3 4 5 6 7
样例输出
CU:1 2 3 4 5 6 7
CD:1 2
CI:3 4

ac代码：

#include <stdio.h>
#include <iostream>
using namespace std;
#define MaxSize 100
typedef int ElemType;				//设置顺序表元素为int类型
typedef struct
{	ElemType data[MaxSize];			//存放顺序表的元素
	int length;						//顺序表的实际长度
} SqList;							//顺序表类型声明
void InitList(SqList &L)			//初始化顺序表L
{
	L.length=0;
}
void DestroyList(SqList L)			//销毁顺序表L
{
}
int GetLength(SqList L)				//求长度
{
	return L.length;
}
int GetElem(SqList L,int i,ElemType &e)	//求第i个元素
{	if (i<1 || i>L.length)			//无效的i值
		return 0;
	else
	{	e=L.data[i-1];
		return 1;
	}
}
int Locate(SqList L,ElemType x)		//查找第一个x元素的位置
{	int i=0;
	while (i<L.length && L.data[i]!=x)
		i++; 						//查找第1个值为x的元素
	if (i>=L.length) return(0);		//未找到返回0
	else return(i+1);				//找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i)	//插入x作为第i个元素
{	int j;
	if (i<1 || i>L.length+1)		//无效的参数i
		return 0;
	for (j=L.length;j>=i;j--)		//将位置为i的元素及之后的元素后移
		L.data[j]=L.data[j-1];
	L.data[i-1]=x;					//在位置i处放入x
	L.length++;						//顺序表长度增1
	return 1;
}
int DelElem(SqList &L,int i)		//删除第i个元素
{	int j;
	if (i<1 || i>L.length)			//无效的参数i
		return 0;
	for (j=i;j<L.length;j++)		//将位置为i的元素之后的元素前移
		L.data[j-1]=L.data[j];
	L.length--;						//顺序表长度减1
	return 1;
}
void DispList(SqList L)				//输出顺序表
{	int i;
	for (i=0;i<L.length;i++)
		printf("%d ",L.data[i]);
	printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n)	//整体创建顺序表L
{
	int i,k=0;						//k累计顺序表L中的元素个数
	for (i=0;i<n;i++)
	{
		L.data[k]=a[i];				//向L中添加一个元素
		k++;						//L中元素个数增1
	}
	L.length=k;						//设置L的长度
}
// 在此处补充你的代码
int FindSame(SqList &L,SqList &L1)
{
	int m=0;//记录发现 
	int k=0;//用于L 
	int p=0;//用于L1 
	for(int i=0;i<L.length-1;i++)
	{
		if(k==1)
		{
			break;
		}
		for(int j=i+1;j<L.length;j++)
		{
			if(k!=1&&(L.data[i]==L.data[j]))
			{
				m++;
				k=1;
				break;
			}
			else if(k==1)
				break;
		}
	}
	for(int i=0;i<L1.length-1;i++)
	{
		if(p==1)
		{
			break;
		}
		for(int j=i+1;j<L1.length;j++)
		{
			if(p!=1&&(L1.data[i]==L1.data[j]))
			{
				m++;
				p=1;
				break;
			}
			else if(p==1)
				break;
		}
	}
	if(m>=1)
		return 0;
	else
		return 1;
}
void DelSame(SqList &L)
{
	for(int i=0;i<L.length;i++)
	{
		
		for(int j=i+1;j<L.length;j++)
		{
			if(L.data[j]==L.data[i])
			{
				DelElem(L,j+1);
				j--;
			}
		}
	}
}
void cu(SqList &L,SqList &L1,SqList &L2)
{
	for(int i=0;i<L1.length;i++)
	{
		InsElem(L2,L1.data[i],L.length+i+1);
	}
	DelSame(L2);
		
}
void cha(SqList &L,SqList &L1,SqList &L2)
{
	int k=0;
	for(int i=0;i<L2.length;i++)
	{
		if((Locate(L1,L2.data[i])<1) || (Locate(L1,L2.data[i])>L1.length))
		{
			L2.data[k]=L2.data[i];
			k++;
		}
	}
	L2.length=k;
}

void jiao(SqList &L,SqList &L1,SqList &L2)
{
	int k=0;
	for(int i=0;i<L.length;i++)
	{
		if((Locate(L2,L.data[i])<1)||(Locate(L2,L.data[i])>L2.length))
		{
			InsElem(L2,L.data[i],k+1);
			k++;
		}
	}
	L2.length=k;
}


int main()
{
	SqList L;
	SqList L1;
	SqList L2;
	int n,n1;
	int a[MaxSize],b[MaxSize],c[MaxSize];
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>a[i];
	}
	CreateList(L,a,n);
	cin>>n1;
	for(int i=0;i<n1;i++)
	{
		cin>>b[i];
	}
	CreateList(L1,b,n1);
	CreateList(L2,a,n);
	if(FindSame(L,L1)){
		cu(L,L1,L2);
		cout<<"CU:";
		DispList(L2);
		
		cha(L,L1,L2);
		cout<<"CD:";
		DispList(L2);
		
		jiao(L,L1,L2);
		cout<<"CI:";
		DispList(L2);
		
		DestroyList(L);
		DestroyList(L1);
		DestroyList(L2);
	}
	else
	{
		cout<<"Repeat Error!"<<endl;
	}
	return 0;
}

8:奇偶顺序表
总时间限制: 10000ms 内存限制: 10000kB
描述
设有一个顺序表L，其元素均为正整数，设计一个算法将L中所有偶数删除并存到另一个顺序表L1中，而顺序表保留原来的所有奇数。并用相关数据进行测试。

输入
输入第一行：数据长度
输入第二行：数据具体数值
输出
输出第一行：数据中包含基数
输出第二行：数据中包含偶数
样例输入
8
1 9 2 8 3 7 4 6
样例输出
1 9 3 7
2 8 4 6

#include <stdio.h>
#define MaxSize 100
#include<iostream> 
using namespace std;
const int MAXSIZE=100;
typedef int ElemType;				//设置顺序表元素为int类型
typedef struct
{	ElemType data[MaxSize];			//存放顺序表的元素
	int length;						//顺序表的实际长度
} SqList;							//顺序表类型声明
void InitList(SqList &L)			//初始化顺序表L
{
	L.length=0;
}
void DestroyList(SqList L)			//销毁顺序表L
{
}
int GetLength(SqList L)				//求长度
{
	return L.length;
}
int GetElem(SqList L,int i,ElemType &e)	//求第i个元素
{	if (i<1 || i>L.length)			//无效的i值
		return 0;
	else
	{	e=L.data[i-1];
		return 1;
	}
}
int Locate(SqList L,ElemType x)		//查找第一个x元素的位置
{	int i=0;
	while (i<L.length && L.data[i]!=x)
		i++; 						//查找第1个值为x的元素
	if (i>=L.length) return(0);		//未找到返回0
	else return(i+1);				//找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i)	//插入x作为第i个元素
{	int j;
	if (i<1 || i>L.length+1)		//无效的参数i
		return 0;
	for (j=L.length;j>i;j--)		//将位置为i的元素及之后的元素后移
		L.data[j]=L.data[j-1];
	L.data[i-1]=x;					//在位置i处放入x
	L.length++;						//顺序表长度增1
	return 1;
}
int DelElem(SqList &L,int i)		//删除第i个元素
{	int j;
	if (i<1 || i>L.length)			//无效的参数i
		return 0;
	for (j=i;j<L.length;j++)		//将位置为i的元素之后的元素前移
		L.data[j-1]=L.data[j];
	L.length--;						//顺序表长度减1
	return 1;
}
void DispList(SqList L)				//输出顺序表
{	int i;
	for (i=0;i<L.length;i++)
		printf("%d ",L.data[i]);
	printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n)	//整体创建顺序表L
{
	int i,k=0;						//k累计顺序表L中的元素个数
	for (i=0;i<n;i++)
	{
		L.data[k]=a[i];				//向L中添加一个元素
		k++;						//L中元素个数增1
	}
	L.length=k;						//设置L的长度
}

//开始补充代码
void Split(SqList &L,SqList &L1)
{
	int k=0;
	for(int i=0;i<L.length;i++)
	{
		if(L.data[i]%2==0)
		{
			InsElem(L1,L.data[i],k+1);
			DelElem(L,i+1);
			i--;
			k++;
		}
	}
}
int main()
{
	SqList L,L1;
	int n,a[MAXSIZE];
	cin>>n;
	for(int i=0;i<n;i++)
	    cin>>a[i];
	CreateList(L,a,n);
	Split(L,L1);
	DispList(L);
	DispList(L1);
	DestroyList(L);
	DestroyList(L1);
	return 0;
}
浮鱼浮鱼
关注
  • 5
    点赞
  • 踩
  • 58
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构专周22
weixin_60660955的博客
12-22 589
题目22 顺序表排序
顺序表区间元素删除
03-23
若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。
6、顺序表区间元素删除——Linkedlist（java数据结构）
weixin_47202652的博客
10-18 1176
顺序表区间元素删除 若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。 输入格式: 三行数据，第一行是顺序表的元素个数，第二行是顺序表的元素，第三行是x和y。 输出格式: 删除元素值在[x,y]之间的所有元素后的顺序表。 输入样例: 10 5 1 9 10 67 12 8 33 6 2 3 10 输出样例: 1 67 12 33 2 代码如下： import java.util.LinkedLi
(PTA)7-1 jmu-ds-顺序表区间元素删除 (15分）(C语言)
weixin_45637300的博客
04-07 2048
代码如下： #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAXSIZE 1000 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemTy...
有序顺序表删除定区间的元素
weixin_30652879的博客
10-08 298
大概思路是：用数组A【】表示有序表，i位置是存储符合要求的数，j位置是用于遍历整个数组判断是否符合要求，若符合则把该位置的元素值复制给i++位置。最后返回i+1长度的顺序表，个人想了蛮久，测试的时候代码一直报错，希望哪位小哥哥小姐姐能否告知我是疏忽了什么？感谢 #define Maxsize 100 typedef struct{ ElemType data[Maxsize]; ...
PTA 7-2 jmu-ds-顺序表区间元素删除 (15 分)
BigDream123的博客
05-22 5168
若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。 输入格式: 三行数据，第一行是顺序表的元素个数，第二行是顺序表的元素，第三行是x和y。 输出格式: 删除元素值在[x,y]之间的所有元素后的顺序表。 输入样例: 10 5 1 9 10 67 12 8 33 6 2 3 1...
顺序表作业.cpp
10-25
顺序表作业.cpp
实验一：顺序表基本操作
03-03
实验一顺序表基本操作是大学生实验作业的一部分，旨在让学生掌握线性表中元素的前驱、后继的概念，以及顺序表的建立、插入元素、删除表中某元素的算法。在该实验中，学生需要完成并实现顺序表的基本操作，包括初始化...
使用c++实现顺序表的基本操作：1、顺序表的初始化2、顺序表的长度3、顺序表插入元素4、删除顺序表元素5、遍历顺序表
03-27
在IT领域，数据结构是计算机科学的基础，而顺序表是一种简单但重要的数据结构。本文将深入探讨如何使用C++来实现顺序表，并介绍其基本操作，包括初始化、获取长度、插入元素、删除元素以及遍历和查找元素。 首先，...
利用C语言实现顺序表的实例操作
12-26
本文实例讲述了C语言实现顺序表(线性表)的方法。分享给大家供大家参考，具体如下： 一：顺序表代码实现 #ifndef _SEQ_LIST_H #define _SEQ_LIST_H #include <stdio> #include <stdlib> #include <assert> #include <string> #define ElemType float //以float类型测试算法通用性，而不是以惯用的int #define INIT_SIZE 10 //顺序表默认初始化大小 #define LIST_INCREMENT 5 //顺序表容量增量，容量不够
C++ 顺序表存储 课程设计 C++作业
02-22
在C++编程中，顺序表是一种常见的数据结构，它用于存储一组同类型的元素。顺序表在内存中是连续分配的，元素之间的位置关系反映了它们的逻辑顺序。这种数据结构简单直观，易于理解和实现，尤其在小规模数据处理时...
4-7-1 jmu-ds-简单密码
m0_73667402的博客
04-04 643
Julius Caesar曾经使用过一种很简单的密码。对于明文中的每个字符，将它用它字母表中后5位对应的字符来代替，这样就得到了密文。比如字符A用F来代替。如下是密文和明文中字符的对应关系。密文明文你的任务是对给定的密文进行解密得到明文。你需要注意的是，密文中出现的字母都是大写字母。密文中也包括非字母的字符，对这些字符不用进行解码。
删除整数顺序表 L 中所有值在[x，y]范围内的元素
just do something
04-17 5418
任务描述 本关任务：设计一个高效的用于删除整数顺序表 L 中所有值在[x，y]范围内的元素的算法。 阅读以下的算法代码，试着分析它的效率 void fun1(SqList *&L,ElemType x,ElemType y) { int i,j; for (i=0;i<L->length;i++) if (L->data[i]>=x && L->data[i]<=y) {
Java中ArrayList如何删除指定位置的元素
m0_71777195的博客
01-08 4469
总结：使用迭代器遍历时ArrayList会用lastRet和cursor两个变量来维护当前遍历的元素索引和下一次需要遍历元素的索引，通过这两个变量就可以实现迭代中正确的删除某个位置的元素。我们通过list.iterator()拿到的就是这个内部类的对象实例，这个类中有两个字段cursor和lastRet，这两个字段就是我们能在迭代器中正确删除对应位置的元素的关键。首先当我们删除第10位元素时，List会将后面的元素向前补位，之后再查第10位元素就会输出第11位元素。
数据结构算法题：有一个顺序表L，其元素为整形数据，设计一个算法，将L中所有小于表头元素的整数放在前半部分，大于表头元素的整数放在后半部分。
Dasy_的博客
06-02 1万+
网上查了这个题的代码，没有任何完整的能正确运行的，因为有点不太懂所以动手随便写了个能运行的调试看过程，分享给需要的朋友。#include&lt;iostream&gt; using namespace std; #define MaxSize 7 typedef struct { int data[MaxSize]; int length; }Sqlist; void InitList(Sql...
第二周 顺序表
m0_46825630的博客
09-21 2129
线性表 （一周中最煎熬、折磨人的数据结构课过去了。说实话，老师上课讲的知识结构有点问题。多数人还是第一次接触现在的内容。上课讲的算法举例跳过了最基础的线性表的创建、头文件之类的。班上只有打ACM的少数人能听得懂。讲完这些就让我们上机做顺序表的实验，写了2个小时代码，都通过不了。有点失望。） 自己整理吧。。。 线性表的定义 （注意：逻辑下标是从1开始的。） 如（1，2，3，1，5） 线性表的基本运算： （ps：GetElem的e变量是形参，就是把返回值暂存在这个变量里。） Locate函数值得注意。
设计一个高效算法，将顺序表L中的所有元素逆置
热门推荐
Jennifer_Love_Frank的博客
07-14 5万+
题目要求： /*设计一个高效算法，将顺序表L中的所有元素逆置，要求算法的空间复杂度为O（1）*/ /*设计一个高效算法，将顺序表L中的所有元素逆置，要求算法的空间复杂度为O（1）*/ #include <iostream> #include <cstring> #include<math.h> #define MAXSIZE 20 #define Elem...
头歌csdn顺序表链表作业
最新发布
10-31
头歌csdn是一个提供编程学习资源的网站，常常有一系列的作业和题目供学生练习。其中，顺序表和链表是数据结构中的两个重要概念。 顺序表是一种线性结构，它的特点是元素之间在内存中的存储是连续的。顺序表的主要操作包括插入、删除和查找。在csdn的顺序表作业中，可能会涉及到实现顺序表的基本功能，如创建一个空表、插入元素到指定位置、删除指定位置上的元素以及获取指定位置上的元素等等。完成这些作业可以帮助学生更好地理解和掌握顺序表的实现原理和基本操作。 链表是另一种常用的数据结构，与顺序表不同，链表的元素在内存中是离散的、通过指针相互连接起来的。链表的主要操作包括插入、删除和查找，与顺序表相似。链表的另一个重要特点是插入和删除操作不会导致内存的重新分配，因此对于某些场景，链表的性能可能会更好。在csdn的链表作业中，可能会涉及到链表的创建、插入元素到指定位置、删除指定位置上的元素以及查找指定元素等等。 通过完成这些作业，学生可以巩固对顺序表和链表的理解，并且锻炼编码能力。在实际的编程项目中，顺序表和链表常常被用来存储和操作大量数据，因此对这两个概念的熟悉和掌握是非常重要的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值