编程数据结构与算法题_数据结构算法题

考研资料链接处：

https://github.com/HachiLin/GRE-Review​github.com https://www.cnblogs.com/monkeycode/p/12774129.html#commentform​www.cnblogs.com

---

编程题：

2021版王道《数据结构》编程题汇总_shazi4399的博客-CSDN博客​blog.csdn.net

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<memory.h>
#include<string.h>

//1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。
//空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。
//算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填空出的原最小值元素的位置。

bool Del_Min(sqList &L,ElemType &value){
	if(L.length==0)
		return false;
	value = L.data[0];	//默认第一个元素为最小值
	int index = 0;		//默认最小值为第一个下标的元素 
	for(int i=0;i<L.length;i++){
		if(L.data[i] < value){
			value = L.data[i];
			index = i; 
		}
	} 
	L.data[index] = L.data[L.length-1];
	L.length--;
	return true;
}

//2.设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O（1）。
//算法思想：扫描顺序表L的前半部分元素，对于元素L.data[i]（0<=i<L.1 ength/2），
//将其与后半部分的对应元素L.data[L.1 ength-i-1]进行交换。

void Reverse(Sqlist &L){
	ElemType temp = 0;
	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(m）、空间复杂度为O（1）的算法，该算法删除线性表中所有值为x的数据元素。
//解法一：用k记录顺序表L中不等于x的元素个数（即需要保存的元素个数），边扫描L边统计k，
//并将不等于x的元素向前移动k个位置，最后修改L的长度

void del_x_1(Sqlist &L,Elemtype x){
	int k = 0;
	for(int i=0;i<L.length;i++){
		if(L.data[i] != x){
			L.data[k] = L.data[i];
			k++;
		}
	}
	L.length = k;
}

//4.从有序顺序表中删除其值在给定值s与t之间（要求s<t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行。
//注意：本题与上一题的区别。因为是有序表，所以删除的元素必然是相连的整体。
//算法思想：先寻找值大于等于s的第一个元素（第一个删除的元素），然后寻找值大于t的第个元素（最后一个删除的元素的下一个元素），
//要将这段元素删除，只需直接将后面的元素前移

bool fun4(SqList &L,ElemType s,ElemType t){
	if(s>=t || L.length==0)
		return false;
	for(int i=0; i<L.length&&L.data[i]<s ;i++);//找到第一个≥s的下标
	if(i>L.length)
		return true;	//全部都小于s，不用移动
	for(int j=i; j<L.length&&L.data[j]<=t ;j++);//找到第一个＞t的数
	for(i,j ; j<L.length ;i++,j++){
		L.data[i] = L.data[j];
	}
	L.length = i;
	return true;
}

//5.从顺序表中删除其值在给定值s与t之间（包含s和t，要求s<t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行
//算法思想:从前向后扫描顺序表L,用k记录下元素值在s到t之间元素的个数(初始时k=0).对于当前扫描的元素,若其值不在s到t之间,
//则前移k个位置;否则执行k++.由于这样每个不在s到t之间的元素仅移动一次,所以算法效率高.

bool fun5(SqList &L,ElemType s,ElemType t){
	if(s>=t || L.length==0)
		return false;
	int k = 0;
	for(int i=0;i<L.length;i++){
		if(L.data[i]>s && L.data[i]<t)
			L.data[k++] = L.data[i];
	}
	L.length = k;
	return true;
}

//6.从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同
//算法思想:注意是有序顺序表,值相同的元素一定在连续的位置上,用类似于直接插入排序的思想,初始时将第一个元素视为非重复的有序表.
//之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同,1 1 2 3 3 4 5 6 6
//若相同则继续向后判断,若不同则插入到前面的非重复有序表的最后,直至判断到表尾为止.

void fun6(SqList &L){
	int k=1;
	for(int i=1;i<L.length;i++){
		if(L.data[i]!=L.data[i-1])
			L.data[k++] = L.data[i];
	}
	L.length = k;
}

//7.将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表。
//算法思想:首先,按顺序不断取下两个顺序表表头较小的结点存入新的顺序表中.然后,看哪个表还有剩余,将剩下的部分加到新的顺序表后面.

bool Merga(SqList La,SqList Lb,SqList &Lc){
	int lenA = La.length;
	int LenB = Lb.length;
	int i=0,j=0,k=0;
	while(i<lenA && j<lenB){//找到第一个大于Lb的下标 
		if(La.data[i] <= Lb.data[j])  Lc.data[k++] = La.data[i++];
		else Lc.data[k++] = Lb.data[i++];	
	}
	while(i<lenA) Lc.data[k++] = La.data[i++];
        while(i<lenB) Lc.data[k++] = Lb.data[j++];
	Lc.length = k;
	return true;
} 

//8.已知在一维数组A[m+n]中依次存放两个线性表（a1,a2,a3,…，am）和（b1，b2,b3,…，bn）。
//试编写一个函数，将数组中两个顺序表的位置互换，即将（b1，b2b3，…，bn）放在（a1，a2a3，…，an的前面。
//算法思想:先将数组A[m+n]中的全部元素(a1,a2a3…,am,b1,b2b3;…,bn)原地逆置为(bnbn-1, n2,",D1,m,m-1,am-2, a1),
//再对前n个元素和后m个元素分别使用逆置算法,即可得到(b,b2, b3,…,bn、a1,a2,a3,…,an),从而实现顺序表的位置互换.

#include<stdio.h>
typedef int DataType;
void Reverse(DataType A[],int left, int right, int arraysize){
	//逆转(a1eft, aleft+1, aleft+2… aright)为( aright, aright-1,…, aleft)
	if (left>=right || right>=arraysize)
		return ;
	DataType temp = 0;
	int mid=(left+right)/2;
	for(int i=0;i<=mid-left;i++){
		temp = A[left+i]; 
		A[left+i] = A[right-i]; 
		A[right-i] = temp;
	}
}
void Exchange(DataType A[],int m, int n, int arraysize){
	/*数组A[m+n]中,从0到m-1存放顺序表(a1,a2,a3,…,am),从m到m+n-1存放顺序表
	(b1,b2,b3…,bn),算法将这两个表的位置互换*/ 
	Reverse(A, 0, m+