王道书数据结构例题版

No Code（睡觉版）

已于 2024-03-03 02:20:56 修改

阅读量386

点赞数 6

文章标签：数据结构算法

于 2024-02-27 22:58:40 首次发布

本文链接：https://blog.csdn.net/qq_44344388/article/details/136333889

版权

2.2 线性表的顺序表示

2.2.3 本书试题精选

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

/*题一:从顺序表中删除具有最小元素（假设唯一）并由函数返回被删元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出本行*/
#include<iostream>
using namespace std;
#define maxsize 200
typedef struct
{
	int data[maxsize];
	int length;
}Sqlist;
/*题解答案思想：搜索整个顺序表，查找最小值并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置*/
bool Del_Min(Sqlist& L, int& value)
{
	//先查找顺序表L中的最小值位置，然后将其和最后一位元素作替换
	if (L.length == 0)
		return 0;
	value = L.data[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;
}
/*自己的解法：初始化线性表InitList+查找线性表最小元素的值和位置LocateElem和GetElem+删除线性表最小元素deleteList+将线性表最后一个值插入到线性表最小元素的所在位置ListInsert*/
int InitList(Sqlist& L)//初始化线性表
{
	L.length = 0;
	return 0;
}
int minList(Sqlist L, int& e)//在线性表中找到最小元素并返回
{
	int i = 0;
	for (int j = 0;j < L.length;j++)
	{
		if (L.data[i] < L.data[j + 1])
			return L.data[i];
		else
		{
			return L.data[i++];
		}
	}
	e = L.data[i];
	return e;
}
int ListInsert(Sqlist& L, int i, int e)//操作：插入操作——在i位置插入e元素（问：i，e是否都是用户给出的数值？）
{
	if (i<1 || i>L.length + 1)//判断插入位置是否合法
		return false;
	if (L.length == maxsize)//判断存储空间是否为满
		return false;
	for (int j = L.length - 1;j >= i - 1;j--)//注意此处j为L.length-1,且插入是倒着插
		L.data[j + 1] = L.data[j];
	L.data[i - 1] = e;
	L.length++;
	return true;
}
int deleteList(Sqlist &L, int i, int& e)//删除L中i位置的元素,且返回i位置的元素——容易写错！！！！
{
	if (i<1 || i>L.length)
		return true;
	if (i == L.length)
		return false;
	e = L.data[i-1];
	for (int j = i;j < L.length;j++)
	{
		L.data[j-1] = L.data[j];
	}
	L.length--;
	return e;
}
int LocateElem(Sqlist L, int e)//操作：按值查找——在线性表L中查找值为e的数的位置
{
	int i;
	for (i = 0;i < L.length;i++)
	{
		if (L.data[i] == e)
			return i + 1;
	}
	return -1;
}
int GetElem(Sqlist L, int i, int& e) //操作：按位查找——在线性表中查找i位置的元素，返回给e，注意此处的引用符号&的实际使用方法
{
	e = L.data[i - 1];//注意这里返回的是数组的i-1
	return e;
}
int main()
{
	int i;
	int e;
	Sqlist L;
	InitList(L);
	ListInsert(L, 1, 1);
	ListInsert(L, 2, 2);
	ListInsert(L, 3, 3);
	ListInsert(L, 4, 4);
	ListInsert(L, 5, 5);
	ListInsert(L, 6, 6);
	int c = L.length;
	int f = minList(L, i);
	std::cout << "线性表最小值为"<<f<<endl;
	int a = LocateElem(L, f);
	std::cout << "线性表最小值的位置在" <<a<<endl;
	deleteList(L, a, e);
	int d = L.data[c - 1];
	ListInsert(L, f, d);
	for (int b = 0;b < L.length;b++)
	{
		std::cout << L.data[b];
	}
	std::cout << endl;
	std::cout << "线性表第一个值为" << GetElem(L,1,e)<<endl;
	/*题解只需一个函数：Del_Min(L.e)可解决问题*/
	std::cout << "线性表被删掉的值为" << Del_Min(L, e) << endl;
	for (int b = 0;b < L.length;b++)
	{
		std::cout << L.data[b];
	}
	return 0;
}

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

/*题2：设计一个高级算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)。*/
#include<iostream>
#define maxsize 200
using namespace std;
typedef struct{
	int data[maxsize];
	int length;
}Sqlist;
int Init_Sqlist(Sqlist& L)
{
	L.length = 0;
	return 0;
}
/*题解*/
void reverseList(Sqlist &L)
{
	for (int i = 0;i < L.length / 2;i++)
	{
		int tempt = L.data[i];//设置一个中间值
		L.data[i] = L.data[L.length-i-1];//为什么这里是L.length-i-1(交换L.data[i]与L.data[L.length-i-1])
		L.data[L.length-i-1] = tempt;
	}
 }
int main() {
	Sqlist L;
	Init_Sqlist(L);
	L.length = 10;
	for (int i = 0;i < L.length;i++)
	{
		L.data[i] = i;
	}
	reverseList(L);
	for (int i = 0;i < L.length;i++)
	{
		cout << L.data[i];
	}
}

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

/*题三：对长度为n的顺序表L，编写一个时间复杂度为O(n)，空间复杂度为O(1)的算法，该算法删除线性表中的所有值为x的数据元素*/
#include<iostream>
#define maxsize 200
using namespace std;
typedef struct {
	int data[maxsize];
	int length;
}Sqlist;
int Init_Sqlist(Sqlist& L)
{
	L.length = 0;
	return 0;
}
/*我解：但时间复杂度为O(n^2),且如果第一个和最后一个元素是需要删除的元素，可能会删不掉*/
int delete_same(Sqlist& L, int e)//删除线性表中所有值为e的数据元素
{
	for (int i = 0;i < L.length;i++)//遍历线性表中的每个元素
	{
		if (e == L.data[i])//如果线性表中有元素为e值，则执行删除操作
		{
			for (int j = i;j < L.length;j++)
			{
				L.data[j] = L.data[j+1];
			}
			L.length--;
		}
	}
	return 0;
}
/*题解一：用k记录顺序表L中不等于x的元素个数（即需要保存的元素个数），边扫描L边统计k，并将不等于x的元素向前移动k个位置，最后修改L的长度*/
void del_x_1(Sqlist& L, int x) {
	int k = 0;//记录值不为x的元素个数
	for (int i = 0;i < L.length;i++)
	{
		if (L.data[i] != x)
		{
			L.data[k] = L.data[i];//关键步骤：将值不为x的元素重新排列成一个数组
			k++;//不等于x的元素增一
		}	
	}
	L.length = k;//顺序表L的长度等于k
}
/*题解二：用k记录顺序表L中等于x的元素个数，边扫描L边统计k，并将不等于x的元素前移k个位置，最后修改L的长度*/
void del_x_2(Sqlist& L, int 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的长度递减
}
int ListInsert(Sqlist& L, int i, int e)//操作：插入操作——在i位置插入e元素（问：i，e是否都是用户给出的数值？）
{
	if (i<1 || i>L.length + 1)//判断插入位置是否合法
		return false;
	if (L.length == maxsize)//判断存储空间是否为满
		return false;
	for (int j = L.length - 1;j >= i - 1;j--)//注意此处j为L.length-1,且插入是倒着插
		L.data[j + 1] = L.data[j];
	L.data[i - 1] = e;
	L.length++;
	return true;
}
int main() 
{
	Sqlist L;
	Init_Sqlist(L);
	ListInsert(L, 1, 2);
	ListInsert(L, 2, 2);
	ListInsert(L, 3, 3);
	ListInsert(L, 4, 4);
	ListInsert(L, 5, 2);
	ListInsert(L, 6, 2);
	ListInsert(L, 7, 2);
	for (int i = 0;i < L.length;i++)
	{
		cout << L.data[i];
	}
	std::cout << endl;
	std::cout << "插入元素后数组长度为" << L.length<<endl;
	//delete_same(L,2);
	//del_x_1(L, 2);
	//del_x_2(L, 2);
	for (int i = 0;i < L.length;i++)
	{
		cout << L.data[i];
	}
	std::cout << endl;
	std::cout << "删除相同元素后数组长度为"<<L.length<<endl;
}

题四 / 五：从有序（无序）顺序表中删除其值在给定s与t之间（要求s<t）的所有元素，如果s和t不合理或顺序表为空，则显示出错信息并退出运行。

/*题四：从有序顺序表中删除其值在给定s与t之间（要求s<t）的所有元素，如果s和t不合理或顺序表为空，则显示出错信息并退出运行*/
#include<iostream>
#define maxsize 200
using namespace std;
typedef struct {
	int data[maxsize];
	int length;
}Sqlist;
int Init_Sqlist(Sqlist& L)
{
	L.length = 0;
	return 0;
}
/*我解*/
int dele_num(Sqlist& L, int s, int t)
{
	int k = 0;
	if (L.length == 0)//判断顺序表是否为空，此处不太全面是未判断s和t值是否合法
		return false;
	for (int i = 0;i < L.length;i++) //遍历数组，如果有s-t范围内的数值，则排除且重新组成一个新数组
	{
		if (L.data[i] <  s ||L.data[i]>t)
	{
		L.data[k] = L.data[i];
		k++;
	}	
	}
	L.length = k;
	return 0;
}
/*题解：先寻找值大于等于s的第一个元素（第一个删除的元素），然后寻找值大于t的第一个元素（最后一个要删除的元素的下一个元素），要将这段元素删除，只需直接将后面的元素后移*/
bool Del_s_t2(Sqlist& L, int s, int t)//删除有序顺序表L中值在给定值s与t之间的所有元素
{
	int i, j;
	if (s >= t || L.length == 0)//判断s和t是否合法，且顺序表是否为空
		return false;
	for (i = 0;i < L.length && L.data[i] < s;i++);//寻找值大于等于s的第一个元素，记录i值
		if (i >= L.length)
			return false;//所有元素值均小于s，返回
	for (j = i;j < L.length && L.data[j] <= t;j++);//寻找值大于t的第一个元素，记录j值
	for (;j < L.length;i++, j++)
		L.data[i] = L.data[j];//前移，填补被删除元素位置
	L.length = i;
	return true;
}
int ListInsert(Sqlist& L, int i, int e)//操作：插入操作——在i位置插入e元素（问：i，e是否都是用户给出的数值？）
{
	if (i<1 || i>L.length + 1)//判断插入位置是否合法
		return false;
	if (L.length == maxsize)//判断存储空间是否为满
		return false;
	for (int j = L.length - 1;j >= i - 1;j--)//注意此处j为L.length-1,且插入是倒着插
		L.data[j + 1] = L.data[j];
	L.data[i - 1] = e;
	L.length++;
	return true;
}
int main()
{
	Sqlist L;
	Init_Sqlist(L);
	ListInsert(L, 1, 1);
	ListInsert(L, 2, 2);
	ListInsert(L, 3, 3);
	ListInsert(L, 4, 4);
	ListInsert(L, 5, 5);
	ListInsert(L, 6, 6);
	ListInsert(L, 7, 7);
	for (int i = 0;i < L.length;i++)
	{
		cout << L.data[i];
	}
	std::cout << endl;
	std::cout << "插入元素后数组长度为" << L.length << endl;
	//dele_num(L, 1, 3);
	//Del_s_t2(L, 1, 3);
	for (int i = 0;i < L.length;i++)
	{
		cout << L.data[i];
	}
	std::cout << endl;
	std::cout << "删除1-3范围内元素后数组长度为" << L.length << endl;
}

题六：从有序顺序表删除所有值重复的元素,使表中所有元素的值均不同。

/*题六：从有序顺序表删除所有值重复的元素,使表中所有元素的值均不同*/
#include<iostream>
using namespace std;
#define maxsize 200
typedef struct{
	int data[maxsize];
	int length;
}Sqlist;
/*我解*/
void vergeList(Sqlist& L)
{
	int k = 0;
	for (int i = 0;i < L.length;i++)
	{
		if (L.data[i] == L.data[i + 1])
		{
			for (int j = i;j < L.length;j++)
			{
				L.data[j] = L.data[j+1];
			}
			L.length--;
		}		
	}
}
/*题解：类似直接插入排序的思想*/
bool Delete_Same(Sqlist& L)
{
	if (L.length == 0)//判断线性表是否为空
		return false;
	int 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;
}
int Init_Sqlist(Sqlist& L)
{
	L.length = 0;
	return 0;
}
int ListInsert(Sqlist& L, int i, int e)//操作：插入操作——在i位置插入e元素（问：i，e是否都是用户给出的数值？）
{
	if (i<1 || i>L.length + 1)//判断插入位置是否合法
		return false;
	if (L.length == maxsize)//判断存储空间是否为满
		return false;
	for (int j = L.length - 1;j >= i - 1;j--)//注意此处j为L.length-1,且插入是倒着插
		L.data[j + 1] = L.data[j];
	L.data[i - 1] = e;
	L.length++;
	return true;
}
int main()
{
	Sqlist L;
	Init_Sqlist(L);
	ListInsert(L, 1, 1);
	ListInsert(L, 2, 2);
	ListInsert(L, 3, 2);
	ListInsert(L, 4, 2);
	ListInsert(L, 5, 3);
	ListInsert(L, 6, 3);
	ListInsert(L, 7, 3);
	//vergeList(L);
	Delete_Same(L);
	for (int i = 0;i < L.length;i++)
	{
		cout << L.data[i];
	}
}

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

/*题七：将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表*/
#include<iostream>
using namespace std;
#define maxsize 200
typedef struct {
	int data[maxsize];
	int length;
}Sqlist;
int Init_Sqlist(Sqlist &L)
{
	L.length = 0;
	return 0;
}
/*我解：没解出来，不能理解为啥这个思路不对*/
void vergeList(Sqlist L, Sqlist J, Sqlist &K)
{
	for (int i = 0;i < L.length;i++)//遍历L线性表
	{
		for(int j = 0;j < J.length;j++)//遍历J线性表，如果J线性表有大于L线性表的元素，则将L线性表的元素录入新线性表K中
			if (L.data[i] < J.data[j])
			{
				K.data[i] = L.data[i];
			}
			else //如果J线性表有小于L线性表的元素，则将J线性表的元素录入新线性表K中
				K.data[i] = J.data[j];
	}
	K.length = L.length + J.length;
}
/*题解：按顺序不断取下两个顺序表表头较小的结点存入新的顺序表中。然后，看哪个表还有剩余，将剩下的部分加到新的顺序表后面*/
bool Merge(Sqlist A, Sqlist B, Sqlist& C)//将有序顺序表A与B合并为一个新的有序顺序表C
{
	if (A.length + B.length > 200)//大于顺序表的最大长度
		return false;
	int i = 0,j = 0,k = 0;
	while (i < A.length && 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 (i < B.length)
		C.data[k++] = B.data[j++];
	C.length = k;
	return true;
}
int ListInsert(Sqlist& L, int i, int e)//操作：插入操作——在i位置插入e元素（问：i，e是否都是用户给出的数值？）
{
	if (i<1 || i>L.length + 1)//判断插入位置是否合法
		return false;
	if (L.length == maxsize)//判断存储空间是否为满
		return false;
	for (int j = L.length - 1;j >= i - 1;j--)//注意此处j为L.length-1,且插入是倒着插
		L.data[j + 1] = L.data[j];
	L.data[i - 1] = e;
	L.length++;
	return true;
}
int main() {
	Sqlist L;
	Sqlist J;
	Sqlist K;
	Init_Sqlist(L);
	Init_Sqlist(J);
	Init_Sqlist(K);
	ListInsert(L, 1, 1);
	ListInsert(L, 2, 3);
	ListInsert(L, 3, 5);
	ListInsert(L, 4, 7);
	ListInsert(J, 1, 2);
	ListInsert(J, 2, 4);
	ListInsert(J, 3, 6);
	ListInsert(J, 4, 8);
	//vergeList(L, J, K);
	//Merge(L, J, K);
	for (int i = 0;i < J.length;i++)
	{
		cout << J.data[i];
	}
	std::cout << endl;
	for (int i = 0;i < L.length;i++)
	{
		cout << L.data[i];
	}
	std::cout << endl;
	for (int i = 0;i < K.length;i++)
	{
		cout << K.data[i];
	}
}

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

/*
【2010 408统考真题】题10：
设将n(n>1)个整数存放到一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p（0<p<n）个位置，即将R中的数据由（X0，X1,...,Xn-1）变换为(Xp,Xp+1,...,Xn-1,X0,...,Xp-1)
*/
#include<iostream>
using namespace std;
#define maxsize 200
typedef struct {
	int data[maxsize];
	int length;
}Sqlist;
int Init_Sqlist(Sqlist &L)
{
	L.length = 0;
	return 0;
}
/*
我解，可视为解法一
算法思想：设置一个辅助线性表，将线性表L的数据元素全部存入P线性表，P的前p位顺序存放到L的倒数p位中，P的p位以及p位后的元素从线性表L的首位开始排
（主要就是设置一个辅助线性表）
*/
int left(Sqlist& L, Sqlist &P,int p)//将线性表L的元素循环左移p位，P线性表用于存放线性表L的元素
{
	P.length = L.length;
	for (int q = 0;q < L.length;q++)//先将线性表L的元素存放在线性表P中
	{
		P.data[q] = L.data[q];
	}
	for (int i = 0;i < p;i++)//将线性表L的前p位放到线性表L的倒数几位中
	{
		L.data[L.length-p+i] = P.data[i];
	}
	for (int j = p;j < L.length;j++)//将线性表L的p位及p位后的元素从线性表的首位开始排
	{
		L.data[j - p] = P.data[j];
	}
	return 0;
}
/*
题解，可视为解法二
算法思想：可视为将数组ab转换成数组ba（a代表数组的前p个元素，b代表数组中余下的n-p个元素），将a逆置得到a^-1 b，再将b逆置得到a^-1 b^-1，最后将整个a^-1 b^-1逆置得到ba。
设Reverse函数执行将数组元素逆置的操作，对abcdefgh向左循环移动3（p=3）个位置的过程如下：
①Reverse(0,p-1)得到cba defgh
②Reverse(p,n-1)得到cba hgfed
③Reverse(0,n-1)得到defgh abc
*/
void Reverse(int R[], int from, int to) 
{
	int i,tempt;
	for (int i = 0;i < (to - from + 1) / 2;i++)
	{
		tempt = R[from + i];
		R[from + i] = R[to - i];
		R[to - i] = tempt;
	}
}//Reverse
void Converse(int R[], int n, int p)
//这里的n和p需要搞清楚是啥
//n为数组长度，p为所需循环左移的位数
{
	Reverse(R, 0, p - 1);
	Reverse(R, p, n - 1);
	Reverse(R, 0, n - 1);
}
int InsertList(Sqlist& L,int i, int e)
{
	L.data[i - 1] = e;
	for (int j=L.length;j>i;j--)
	{
		L.data[j] = L.data[j-1];
	}
	L.length++;
	return 0;
}
int main()
{
	Sqlist L;
	Sqlist P;
	Init_Sqlist(L);
	Init_Sqlist(P);
	InsertList(L, 1, 1);
	InsertList(L, 2, 2);
	InsertList(L, 3, 3);
	InsertList(L, 4, 4);
	InsertList(L, 5, 5);
	int R[] = { 1,2,3,4,5 };
	//left(L,P,3);
	Converse(R, 5, 2);
	for (int i = 0;i < L.length;i++)
	{
		cout << R[i] << endl;
	}
}
//总结：我觉得我解更易理解！！

【2011统考真题】题十一：一个长度为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的中位数。

/*【2011统考真题】题11：
一个长度为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的中位数。*/
#include<iostream>
using namespace std;
#define maxsize 200
typedef struct{
	int data[maxsize];
	int length;
}Sqlist;
int Init_Sqlist(Sqlist& L)
{
	L.length = 0;
	return 0;
}
/*我解：两个有序线性表合并，然后取中位数*/
int vergeList(Sqlist L, Sqlist J,Sqlist &K, int& e)
{
	int j = 0;
	int k = 0;
	int i = 0;
	while (i < L.length && j < J.length)
	{
		if (L.data[i] > J.data[j])
		{
			K.data[k++] = J.data[j++];
		}
		else
		{
			K.data[k++] = L.data[i++];
		}
	}
	while (i < L.length)
	{
		K.data[k++] = L.data[i++];
	}
	while (j < J.length)
	{
		K.data[k++] = J.data[j++];
	}
	K.length = L.length + J.length;
	e = K.data[K.length / 2];
	return e;
}
/*题解：分别求两个升序序列A、B的中位数，设为a和b。求序列A、B的中位数过程如下：
很奇怪，题解返回不了任何值*/
int M_Search(int A[], int B[], int n)
{
	int s1 = 0, d1 = n - 1, m1, s2 = 0, d2 = n - 1, m2;//分别表示序列A和B的首位数、末位数和中位数
	while (s1 != d1 || s2 != d2)
	{
		m1 = (s1 + d1) / 2;
		m2 = (s2 + d2) / 2;
		if (A[m1] == B[m2])
			return A[m1];
		if (A[m1] < B[m2])
		{
			if ((s1 + d1) % 2 == 0) {
				s1 = m1;
				d2 = m2;
			}
			else {
				s1 = m1 + 1;
				d2 = m2;
			}
		}
		else{
			if ((s2 + d2) % 2 == 0)
			{
				d1 = m1;
				s2 = m2;
			}
			else
			{
				d1 = m1;
				s2 = m2 + 1;
			}
		}
	}
	return A[s1] < B[s2] ? A[s1] : B[s2];
}
int InsertList(Sqlist& L, int i, int e)
{
	L.data[i - 1] = e;
	for (int j = L.length;j > i;j--)
	{
		L.data[j] = L.data[j - 1];
	}
	L.length++;
	return 0;
}
int main()
{
	int i;
	int e;
	int n = 0;
	Sqlist L;
	Sqlist J;
	Sqlist K;
	Init_Sqlist(L);
	Init_Sqlist(J);
	Init_Sqlist(K);
	InsertList(L, 1, 1);
	InsertList(L, 2, 3);
	InsertList(L, 3, 5);
	InsertList(L, 4, 7);
	InsertList(J, 1, 2);
	InsertList(J, 2, 4);
	InsertList(J, 3, 6);
	InsertList(J, 4, 8);
	vergeList(L, J, K, e);
	int A[] = { 1,3,5,7 };
	int B[] = { 2,4,6,8 };
	//M_Search(A,B,n);
	for (int i = 0;i < K.length;i++)
	{
		cout << K.data[i]<<endl;
	}
	//cout <<"K线性表的中位数："<< M_Search(A, B, n)<< endl;
	cout << "K线性表的中位数：" <<e<< endl;
}

No Code（睡觉版）

关注

6
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
王道书数据结构例题版

Xn-1）变换为(Xp,Xp+1,…题一：从顺序表中删除具有最小元素（假设唯一）并由函数返回被删元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出本行。题三：对长度为n的顺序表L，编写一个时间复杂度为O(n)，空间复杂度为O(1)的算法，该算法删除线性表中的所有值为x的数据元素。例如，若序列S1={11,13,15,17,19},则S1的中位数是15，两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2={2,4,6,8,20}，则S1和S2的中位数是11,。
复制链接

扫一扫