顺序表编程题

执念讶

于 2022-11-17 16:23:36 发布

阅读量277

点赞数 1

文章标签：数据结构 c语言

本文链接：https://blog.csdn.net/weixin_42788519/article/details/127906013

版权

#include<stdio.h>

#define MAXSIZE  100

typedef int ElemType;
typedef struct{
	ElemType data[MAXSIZE];
	int length;
}Sqlist;

1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的值。空出来的位置由最后一个元素填补若顺序表为空，则显示出错信息并退出运行。

ElemType Del_Min(Sqlist L)
{
	if(L.length==0)
	{
		printf("表空\n");
		exit(0);
	}
	
	ElemType i;
	ElemType k = 0;
	ElemType min = L.data[0];
	for(i = 1; i < L.length; i++)
	{
		if(L.data[i]<min)
		{
			min = L.data[i];
			k = i;
		}
	}
	L.data[k] = L.data[L.length - 1];
	L.length--;
	return k;
}

2.设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)

void ReverseSqlist(Sqlist &L)
{
	ElemType temp;
	for(int i = 0;i < L.length/2; i++)
	{
		temp = L.data[i];
		L.data[i] = L.data[L.length-1-i];
		L.data[L.length-1-i] = temp;
	}
	
}

3.对长度为n的顺序表L，编写一个时间复杂度为O(n)，空间复杂度为O(1)的算法，该算法删除线性表中所有值为x的数据元素。

void Del_X(Sqlist &L,ElemType x)
{
	
	int k ; //用来记录值为x的元素个数
	for(int i = 0;i < L.length;i++)
	{
		if(L.data[i] == x)
			k++;
		else
			L.data[i-k] = L.data[i];
	}
	L.length-=k;
}

4.从顺序表中删除其值在给定值s与t之间（要求s<t）的所有元素，若s或t不合理或顺序表为空，则显示出错信息并退出运行。

/*算法思想：用k来记录介于s与t之间的元素个数，遍历顺序表，
将不在s与t的元素向前移动k个元素即可。*/

void Del_betweenST(Sqlist &L,ElemType s,ElemType t)
{
	if(s >= t||L.length == 0)
		exit(0);
	int k = 0;
	for(int i = 0 ; i < L.length ; i++)
	{
		if(L.data[i] >= s && L.data[i] <= t)
			k++;
		else
			L.data[i-k] = L.data[i];
	}
	L.length-=k;
}

5.从有序顺序表中删除所有其值重复的元素，使表中所有的元素的值均不同

/*
	算法思想：定义i与j作为遍历指针，其中i始终为j的前驱指针，遍历顺序表直到j指向最后一个元素，
	在遍历过程中若i和j所指元素相同，k++，否则将j向前移动k个元素即可
*/

bool Del_sameElemType(Sqlist &L)
{
	if(L.length == 0)
		return false;
	int i,j,k = 0;
	for(i = 0,j = 1;j < L.length;i++,j++)
	{
		if(L.data[i] == L.data[j])
			k++;
		else
			L.data[j-k]=L.data[j];
	}
	L.length-=k;
	return true;
	
}

6.将两个有序的顺序表合并为一个新的有序的顺序表，并由函数返回结果顺序表

/*
算法思想：i用来遍历L1，j用来遍历L2，若L1.data[i]<=L2.data[j],将L1中的比较元素插入新表L中，否则将L2中的元素插入L中，
	若有一个表遍历结束，另外一个表还有元素，将剩余元素依次插入新表中
*/
bool MergeList(Sqlist L1,Sqlist L2,Sqlist &L)
{
	if(L1.length + L2.length > MAXSIZE)
		return false;
	int k = 0;
	for(int i = 0,j = 0;i<L1.length&&i<L2.length;)
	{
		if(L1.data[i]<=L2.data[j])
		{
			L.data[k++]=L1.data[i++];
		}
		else
		{
			L.data[k++]=L2.data[j++];
		}
	}
	while(i<L1.length)  //如果L1还有剩余
	{
		L.data[k++] = L1.data[i++];
	}
	while(j<L2.length)  //如果L2还有剩余
	{
		L.data[k++] = L2.data[j++];
	}
	L.length = k;
	return true;
}

7.已知在一维数组A[m+n]中依次存放两个线性表(a1,a2,a3…,am)和(b1,b2,b3,…,bn)。编写一个函数将数组中两个顺序表的位置互换，即(b1,b2,b3,…bn)放在a1(,a2,a3…,am)的前面。

/*
	算法思想：首先将(a1,a2,a3...,am)进行逆置，再将(b1,b2,b3,...,bn)逆置，此时表L为(am,...,m3,m2,m1,bn,...,b2,b1),
	在将此时的表L逆置即可。
*/
void ReverseSqlist2(Sqlist &L,int low,int high)
{
	ElemType temp;
	int mid = (high + low)/2;
	while(low<=mid)
	{
		temp = L.data[low-1];
		L.data[low-1] = L.data[high-1];
		L.data[high-1] = temp;
		low++;
		high--;
	}	
}
bool ReverseFunction(Sqlist &L,int m ,int n)
{
	ReverseSqlist2(L,1,m);
	ReverseSqlist2(L,m+1,n);
	ReverseSqlist2(L,1,n);
}

8.线性表(a1,a2,a3,…,an)中的元素递增有序且按顺序存储于计算机内，要求设计一个算法完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置交换，若找不到，则将其插入表中并使表中元素仍然递增有序。

void function(Sqlist &L,ElemType x)
{
	int low = 0 , high = L.length - 1,mid,temp;
	while(low<=high)
	{
		mid = (low+high)/2;
		if(L.data[mid] == x)
			break;
		else if(L.data[mid] < x)
			low = mid + 1;
		else
			high = mid - 1;
	}
	//查找成功，并且查找的x不是最后一个元素
	if(low<=high&&mid!=L.length-1)
	{
		temp = L.data[mid];
		L.data[mid] = L.data[mid+1];
		L.data[mid+1] = temp;
	}
	//查找失败
	if(low>high)
	{
		for(int i = L.length-1;i >=low ;i--)
			L.data[i+1] = L.data[i];
		L.data[low] = x;
		L.length++;
	}
}

9.设将n(n>1)个整数存放到一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p(0<p<n)个位置，即将R中的数据由(X0,X1,…,Xn-1)变换为(Xp,Xp+1,…,Xn-1,X0,X1,…,Xp-1)。

/*
	算法思想：先将前p个元素进行逆置得到(Xp-1,Xp-2,...,X1,X0)，在将p+1到n的元素进行逆置得到
	(Xn-1,Xn-2,...,Xp+1,Xp),其实数组中的元素为(Xp-1,Xp-2,...,X1,X0,Xn-1,Xn-2,...,Xp+1,Xp),在将此时的
	数组逆置即可
	
	时间复杂度：O(n)，空间复杂度O(1)
*/
void Reverse(Sqlist &L,int low,int high)
{
	int mid = (low + high)/2;
	int temp;
	while(low<=mid)
	{
		temp = L.data[low-1];
		L.data[low-1] = L.data[high-1];
		L.data[high-1] = temp;
		low++;
		high--;
	}
	
}

void function10(Sqlist &L,int p, int n)
{
	Reverse(L,1,p);
	Reverse(L,p+1,n);
	Reverse(L,1,n);
}

10.一个长度为L(L>=1)的升序序列S，处在第[L/2]个位置的数称为S的中位数。列如，若序列S1={11,13,15,17,19},则S1的中位数是15，两个序列的中位数是含他们所有元素的升序序列的中位数。例如，若S2 = {2,4,6,8,20}，则S1和S2的中位数是11.现在有两个等长生序序列A和B，设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A和B的中位数。

/*
算法思想：将S1和S2进行"伪合并",合并后的数组长度一定为2n，此时中位数一定是第n个元素。故只需找到"合并"后的数组中
	第n个元素即可
	时间复杂度为：O(n) 空间复杂度为：O(1)
*/
int function11(Sqlist L1,Sqlist L2)
{
	int i=0,j=0,k=0;
	int mid ; //用来记录中位数的值
	while(k<L1.length)
	{
		if(L1.data[i]<=L2.data[j])
		{
			mid = L1.data[i];
			i++;	
		}
		else
		{
			mid = L2.data[j];
			j++;
		}
		k++;
	}	
	return mid;
}

11.已知一个整数序列A=(a0,a1,…,an-1)，其中0≤ai≤n（0≤i≤n）。若存在ap1=ap2=…=apm=x，且m＞n/2，则称x为A的主元素，例如A =(0,5,5,3,5,7,5,5)，则5为主元素，又如(0,5,5,3,5,1,5,7)，则A中没有主元素。假设A中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出A中的主元素，若存在主元素则输出该元素，否则输出-1。

int findMain(Sqlist L)
{
	int c = L.data[0];
	int count = 1,mainCount = 0;
	for(int i = 1;i<L.length;i++)
	{
		if(L.data[i] == c)
			count++;
		else
		{
			if(count > 0)
				count--;
			else
			{
				count = 1;
				c = L.data[i];
			}
		}
	}
	if(count > 0 )
	{
		for(int i = 0;i < L.length; i++)
			if(L.data[i] == c)
				mainCount++;
	}
	if(mainCount>L.length/2)
		return c;
	else
		return -1;
	
}