2024 王道考研-数据结构

第二章 线性表算法题(线性表的顺序表示)

二、综合应用题

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

        算法思想：搜索整个顺序表，查找最小值元素并记录其位置，搜索结束后用最后一个元素填补空出的最小值元素的位置。

bool Del_Min(SqList &L,ElemType &value)
{
	if(L.length==0)
		return false;
	value=L.data[0];//假定0号元素的值最小 
	int pos=0;
	for(int i=1;i<L.length;i++)
	{
		if(L.data[i]<value)
		{
			value=L.data[i];
			pos=i;
		}
	}
	L.data[pos]=L.data[L.length-1];//空出的位置由最后一个元素填补 
	L.length--;	
	return true;	
} 

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

        算法思想：扫描顺序表L的前半部分元素，对于元素L.data[i](0<=i

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

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

        算法思想：解法1：用k记录顺序表L中不等于x的元素个数(即需要保存的元素个数)，扫描时将不等式x的元素移动到下标k的位置，并更新k值。扫描结束后修改L的长度。

void del_x_1(SqList &L,ElemType x)
{
	int k=0,i;//记录值不等于x的元素个数
	for(i=0;i<L.length;i++)
	{
		if(L.data[i]!=x)
		{
			L.data[k]=L.data[i];
			k++;//不等于x的元素增1 
		}	
	}
	L.length=k; //顺序表L的长度等于k 
}

        算法思想：解法2：用k记录顺序表L中等于x的元素个数，边扫描L边统计k,并将不等于x的元素前移k个位置。扫描结束后修改L的长度。

void Del_x_2(SqList &L,ElemType x)
{
	int k=0,i=0;//k记录值等于x的元素个数 
	while(i<L.length)
	{
		if(L.data[i]==x)
			k++;
		else
			L.data[i-k]=L.data[i];//当前元素前移k个位置 
		i++;
	}
	L.length=L.length-k;//顺序表L的长度递减 
}

04. 从有序顺序表中删除其值在给定值s与t之间(要求s 或顺序表为空，则显示出错信息并退出运行。

        算法思想：先寻找值大于或等于s的第一个元素(第一个删除的元素)，然后寻找值大于t的第一个元素(最后一个删除的元素的下一个元素)，要将这段元素删除，只需直接将后面的元素前移。

bool Del_s_t2(SqList &L,ElemType s,ElemType t)
{
	int i,j;
	if(s>=t||L.length==0)
		return false;
	for(i=0;i<L.length&&L.data[i]<s;i++)//寻找值大于或等于s的第一个元素 
	if(i>=L.length)
		return false;//所有值均小于s,返回 
	for(j=i;j<L.length&&L.data[j]<=t;j++)//寻找值大于t的第一个元素 
	for(;j<L.length;i++,j++)
		L.data[i]=L.data[j];//前移，填补被删除的元素 
	L.length=i;
	return true;
}

05. 从顺序表中删除其值在给定值s与t之间(包含s和t，要求s 1不合理或顺序表为空，则显示出错信息并退出运行。

        算法思想：从前向后扫描顺序表L，用k记录下元素值在s到t之间元素的个数(初始时k=0)。对于当前扫描的元素，若其值不在s到t之间，则前移k个元素；否则执行k++。由于这样每个不在s到t之间的元素仅移动一次，因此算法效率高。

bool Del_s_t(SqList &L,ElemType s,ElemType t)
{
	int i,k=0;
	if(L.length==0||s>=t)
		return false;//线性表为空或s,t不合法，返回 
	for(i=0;i<L.length;i++)
	{
		if(L.data[i]>=s&&L.data[i]<=t)
			k++;
		else
			L.data[i-k]=L.data[i];//当前元素前移k个位置 
	}
	L.length-=k;//长度减小 
	return true;	
}

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

        算法思想：注意是有序顺序表，值相同的元素一定在连续的位置上，用类似于直接插入排序的思想，初始时将第一个元素视为非重复的有序表。之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同，则继续向后判断，若不同，则插入前面的非重复有序表的最后，直至判断到表尾为止。

bool Delete_Same(SqList &L)
{
	if(L.length==0)
		return false;
	int i,j;//i存储第一个不相同的元素，j为工作指针 
	for(i=0,j=1;j<L.length;j++)
		if(L.data[i]!=L.data[j])//查找下一个与上个元素值不同的元素 
			L.data[++i]=L.data[j];//找到后，将元素前移 
	L.length=i+1;
	return true;
}

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

        算法思想：首先，按顺序不断取下两个顺序表表头较小的结点存入新的顺序表中。然后，看哪个表还有剩余，将剩下的部分加到新的顺序表后面。

bool Merge(SqList A,SqList B,SqList &C)
{
	if(A.length+B.length>C.length)//大于顺序表的最大长度 
		return
	int i=0,j=0,k=0;
	while(i<A.lenth&&j<B.length)//循环，两两比较，小者存入结果表 
	{
		if(A.data[i]<B.data[j])
			C.data[k++]=A.data[i++];
		else
			C.data[k++]=B.data[j++];
	}
	while(i<A.length)//还剩一个没有比较完的顺序表 
		C.data[k++]=A.data[i++];
	while(j<B.length)
		C.data[k++]=B.data[j++];
	C.length=k;
	return true;
}

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

        算法思想：先将数组A[m+n]中全部元素(a1,a2,a3,...,am,b1,b2,b3,...,bn)原地逆置为(bn,bn-1,bn-2,...,b1,am,am-1,am-2,...,a1),再对前n个元素和后m个元素分别使用逆置算法，即可得到(b1,b2,b3,...,nn,a1,a2,a3,...,am),从而实现顺序表的位置互换。

typedef int DataType;
void Reverse(DataType A[],int left,int right,int arraySize)
{
	if(left>=right||right>=arraySize)
		return;
	int mid=(left+right)/2;
	for(int i=0;i<mid-left;i++)
	{
		DataType temp=A[left+i];
		A[left+i]=A[right-i];
		A[right-i]=temp;
	}
}
void Exchange(DataType A[],int m,int n,int arraySize)
{
	Reverse(A,0,m+n-1,arraySize);
	Reverse(A,0,n-1,arraySize);
	Reverse(A,n,m+n-1,arraySize);
}

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

        算法思想：顺序存储的线性表递增有序，可以顺序查找，也可以折半查找。题目要求“用最少的时间在表中查找数值为x的元素",这里应使用折半查找。

//09
void SearchExchangeInsert(ElemType A[],ElemType x)
{
	int low=0,high=n-1,mid;//low和high指向顺序表下界和上界的下标 
	while(low<high)
	{
		mid=(low+high)/2;//找中间位置 
		if(A[mid]==x) 
			break;
		else if(A[mid]<x)
			low=mid+1;
		else
			high=mid-1;
	}
	if(A[mid]==x&&mid!=n-1)//若最后一个元素与x相等，则不存在与其后继交换的操作 
	{
		t=A[mid];
		A[mid]=A[mid+1];
		A[mid+1]=t;
	}
	if(low>high)//查找失败，插入数据元素x 
	{
		for(i=n-1;i>high;i--)//后移元素 
			A[i+1]=A[i];
		A[i+1]=x;//插入x 
	}
}

10. [2010统考真题]设将n(n>1)个整数存放到一维数组R中。设计一个在时间和空间
两方面都尽可能高效的算法。将R中保存的序列循环左移p(0 中的数据由(X0,X1,...,Xn-1)变换为(Xp.Xp+1,...,Xn-1,X0,X1,...,Xp-1).要求:

1)给出算法的基本设计思想。

        可将问题视为把数组ab转换成数组ba(a代表数组的前p个元素，b代表数组中余下的n-p个元素)，先将a逆置得到a逆b,再将b逆置得到a逆b逆，最后将整个a逆b逆逆置得到(a逆b逆)逆=ba。设Reverse函数执行将数组逆置的操作，对abcdefgh向左循环移动3(p=3)个位置的过程如下：

         Reverse(0,p-1)得到cbadefgh;

         Reverse(p,n-1)得到cbahgfed;

         Reverse(0,n-1)得到defghabc;

2)根据设计思想，采用C或C++或Java语言描述算法，关键之处给出注释。

void Reverse(int R[],int from,int to)
{
	int i,temp;
	for(i=0;i<(to-from)/2;i++)
	{
		temp=R[from+i];
		R[from+i]=R[to-i];
		R[to-i]=temp;
	}
}
void Converse(int R[],int n,int p)
{
	Reverse(R,0,p-1);
	Reverse(R,n,p-1);
	Reverse(R,0,n-1);		
} 

3)说明你所设计算法的时间复杂度和空间复杂度。

        上述算法中三个Reverse函数的时间复杂度分别为O(p/2)、O((n-p)/2)和O(n/2),故所设计的算法的时间复杂度为O(n),空间复杂度为O(1）。

11. [2011统考真题]一个长度为L(L≥1)的升序序列s, 处在第[L21个位置的数称为S
的中位数，例如，若序列S,=(11,13,15,17,19)， 则S的中位数是15,两个序列的中位
数是含它们所有元素的升序序列的中位数，例如，若S:=(2,4,6,8,20)， 则S和S:的中
位数是11.现在有两个等长升序序列4和B,试设计一个在时间和空间两方面都尽可能
高效的算法，找出两个序列A和B的中位数、要求:

1)给出算法的基本设计思想。

        分别求两个升序序列A、B的中位数，设为a和b,求序列A、B的中位数过程如下：

1.若a=b,则a或b即为所求中位数，算法结束。

2.若a

3.若a>b,则舍弃序列A中较大的一半，同时舍弃序列B中较小的一半，要求两次舍弃的长度相等。

2)根据设计思想，采用C或C+或Java语言描述算法，关键之处给出注释。

int M_Search(int A[],int B[],int n)
{
	int s1=0,d1=n-1,m1,s2=0,d2=n-1,m2;
	while(s1!=d1||s2!=d2)
	{
		m1=(s1+d1)/2;
		m2=(s2+d2)/2;
		if(A[m1]==B[m2])
			return A[m1];//满足条件1 
		if(A[m1]<A[m2])//满足条件2 
		{
			if((s1+d1)%2==0)//若元素个数为奇数 
			{
				s1=m1;//舍弃A中间点以前的部分且保留中间点 
				d2=m2;//舍弃B中间点以后的部分且保留中间点 
			}
			else//若元素个数为偶数 
			{
				s1=m1+1;//舍弃A中间点及中间点以前的部分 
				d2=m2;//舍弃B中间点以后部分且保留中间点 
			}
		}
		else//满足条件3 
		{
			if((s2+d2)%2==0)//若元素个数为奇数 
			{
				d1=m1;//舍弃A中间点以后的部分且保留中间点 
				s2=m2;//舍弃B中间点以前的部分且保留中间点
			}
			else//若元素个数为偶数 
			{
				d1=m1;//舍弃A中间点以后的部分且保留中间点 
				s2=m2+1;//舍弃B中间点及中间点以前部分 
			}
		}
	}
	return A[s1]<B[s2]?A[s1]:B[s2];
}

3)说明你所设计算法的时间复杂度和空间复杂度。

        算法的时间复杂度为O(log2n),空间复杂度为O(1)。

12. [2013统考真题]已知一个整数序列A=(a0,a1,...,an-1),其中0≤ai 存在ap1=ap2=...=apm=x且m>n/2 (0≤pk A=(0,5,5,3,5,7,5,5),则5为主元素;又如A=(0,5,5,3,5,1,5,7)， 则A中没有主元
素。假设A中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出
A的主元素。若存在主元素，则输出该元素:否则输出-1.要求:

1)给出算法的基本设计思想。

        算法的基本设计思想:算法的策略是从前向后扫描数组元素，标记出一个可能成为主元素的元素Num。然后重新计数，确认Num是否是主元素。

        算法可分为以下两步:

①选取候选的主元素。依次扫描所给数组中的每个整数，将第一个遇到的整数Num保存到c中，记录Num的出现次数为1;若遇到的下一个整数仍等于Num, 则计数加1，否则计数减1;当计数减到0时，将遇到的下一个整数保存到c中，计数重新记为1，开始新一轮计数，即从当前位置开始重复上述过程，直到扫描完全部数组元素。

②判断c中元素是否是真正的主元素。再次扫描该数组，统计C中元素出现的次数，若大于n/2，则为主元素;否则，序列中不存在主元素。

2）根据设计思想，采用C或C++或Java语言描述算法，关键之处给出注释。

int Majority(int A[],int n)
{
	int i,c,count=1;//c用来保存候选主元素，count用来计数 
	c=A[0];//设置A[0]为候选主元素
	for(i=1;i<n;i++)//查找候选主元素 
	{
		if(A[i]==c)
			count++;//对A中的候选主元素计数 
		else
			if(count>0)//处理不是候选主元素的情况 
				count--;
			else//更换候选主元素，重新计数 
			{
				c=A[i];
				count=1;	
			}
	} 
	if(count>0)
			for(i=count=0;i<n;i++)//统计候选主元素的实际出现次数 
				if(A[i]==c)
					count++;
		if(count>n/2)
			return c;//确认候选主元素 
		else
			return -1;//不存在主元素 
}

3）说明你所设计算法的时间复杂度和空间复杂度。

        实现的程序的时间复杂度为O(n),空间复杂度为O(1)。