顺序表经典题目

最新推荐文章于 2023-01-03 12:11:31 发布

Pitt张

最新推荐文章于 2023-01-03 12:11:31 发布

阅读量715

点赞数

文章标签：顺序表删除操作逆置删除重复元素算法实现

本文链接：https://blog.csdn.net/qq_59961221/article/details/120680311

版权

1.删除最小值（假设唯一）

//---------------------删除最小值（假设唯一）-----------------------
//从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值
//若顺序表为空则显示出错信息并退出运行

//下面已经给出了函数名称和参数类型，删除L中的最小值，并用min_value返回，
//把代码（包含注释）复制到b中，请完善函数主体内容，并在主函数中调用(注意在head.h中声明函数名)
Status Del_Min(SqList &L, ElemType &min_value){
    
    return OK;
}
//思路提醒：先假定顺序表第一个元素为最小值，然后从第二个元素开始遍历顺序表比较，若遇到更小值，则更新最小值

我的答案：

//我的答案：
Status Del_Min(SqList &L, ElemType &min_value){
	int i = 1;
	int e;
	min_value = L.elem[0];
	for( int j = 1; j < L.length; j++){
		if(L.elem[j] < min_value){
			min_value = L.elem[j];
			i = j + 1;
		}
	}
	printf("该顺序表中的最小元素是%d \n", min_value);
	ListDelete_Sq( L, i, e);
    
    return OK;
}

2.删除最小值（空位填补）

删除空出的位置由最后一个元素填补

//---------------------删除最小值（假设唯一），空位填补-----------------------
//从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值
//空出的位置由最后一个元素填补
bool Del_Min_fill(SqList &L, ElemType &min_value){
    
}

我的答案：

//我的答案：
Status Del_Min_fill(SqList &L, ElemType &min_value){
	int i = 1;
	int e;
	min_value = L.elem[0];
	for( int j = 1; j < L.length; j++){
		if(L.elem[j] < min_value){
			min_value = L.elem[j];
			i = j + 1;
		}
	}
	printf("该顺序表中的最小元素是%d \n", min_value);
	L.elem[i-1] = L.elem[L.length - 1];
	L.length--;
//	ListDelete_Sq( L, i, e);
    
    return OK;
}

3.顺序表逆置

将顺序表L中的元素逆置如1 2 3 4 5 —> 5 4 3 2 1, 代码已经写好，给下面代码添加注释，并尝试在主函数中调用

void Reverse1(SqList &L){
    SqList Lb;
    InitList_Sq(Lb);
    for(int i=0; i<L.length; i++){
        Lb.elem[i] = L.elem[L.length-i-1];
    }
    for (int i = 0; i < L.length; ++i) {
        L.elem[i] = Lb.elem[i];
    }
}

想想有没有复杂度更低（空间复杂度为O(1))的方法实现顺序表逆置?

//设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为 0(1)
#include "head.h"
void Reverse(SqList &L){
	int i = L.length / 2;
	int e;
	for(int j = 0;j < i; j++){
		e = L.elem[j];
		L.elem[j] = L.elem[L.length - 1 - j];
		L.elem[L.length - 1 - j] = e;
	}
}

我的答案：

//我的答案：

4.删除顺序表L中所有值为x的元素

尝试写一写

void del_x_1(SqList &L, ElemType x){
	
}

我的答案：

//我的答案：
void del_x_1(SqList &L, ElemType x){
	int e;
	int k = 0;
	for(int i = 0; i < L.length; i++){
		if(L.elem[i] == x){
			k++;
//			ListDelete_Sq( L, i+1, e);
//			i--;
		}
		else
		L.elem[i-k] = L.elem[i];
	}
	L.length = L.length - k;
}

5.删除有序顺序表s与t之间元素

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

示例：1 2 2 3 4 5 5 7 9--删除2到5之间--->1 7 9

//1 1 2 2 3 4 5 5 7 9--删除2到5之间--->1 1 7 9
bool Del_s_t(SqList &L, ElemType s, ElemType t){

    return true;
}

我的答案：

//我的答案：
bool Del_s_t(SqList &L, ElemType s, ElemType t){
	int k = 0;
	int j , i;
	for( i = 0; i < L.length ; i++){
		if(L.elem[i] >= s && L.elem[i] <= t){
			k++;
			j = i;
		}
	}
	for (i = j; i < L.length; i++)	{
		L.elem[i + 1 - k] = L.elem[i + 1];
	}
	L.length = L.length - k;
    return true;
}
bool Del_s_t_02(SqList &L, ElemType s, ElemType t){
    int m = 0, n = 0;
    for (int i = 0; i < L.length; ++i) {
        if(L.elem[i] < s)   m++;//m表示小于s的元素个数
        if(L.elem[i] <= t)    n++;//n表示小于等于t的元素个数
    }
    for (int j = n; j < L.length; j++)
        L.elem[m++] = L.elem[j];
    L.length = m;
    return true;
}

6.删除顺序表s与t之间元素

从顺序表中删除其值在给定值 s 与 t 之间（要求 s < t ）包含s和t 的所有元素

示例：6 2 2 7 3 1 5 8 --删除2到5之间的元素 -->6 7 1 8

bool Del_s_t_Sq(SqList &L, ElemType s, ElemType t){

    return true;
}

我的答案：

//我的答案：
bool Del_s_t_Sq(SqList &L, ElemType s, ElemType t){
	int k = 0;
	int i;
	if (L.length == 0 || s >= t) 
		return false;
	for( i = 0; i < L.length ; i++){
		if(L.elem[i] >= s && L.elem[i] <= t)
			k++;
		else
			L.elem[i-k] = L.elem[i];
	}
	L.length = L.length - k;
    return true;
}

7.有序顺序表中删除值重复的元素

1 2 2 2 2 3 3 3 4 4 5 --> 1 2 3 4 5

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

先自己尝试写

//有序顺序表中删除值重复的元素
bool Delete_same(SqList &L){
    
    return true;
}

我的答案：

//我的答案：
bool Delete_same(SqList &L){
    int k = 0 , i , j = 0;
    
    for(i = 1; i < L.length; i++){
    	if(L.elem[i] != L.elem[j])
    		L.elem[++j] = L.elem[i];
	}
	L.length = j + 1;
    return true;
}

8.无序顺序表删除值重复的元素

2 2 3 2 4 3 2 1 ---> 2 3 4 1

下面是示例代码，尝试读读理解理解

bool Delete_same_3(SqList &L) {
    int i, j = 0, k;
    for (i = 1; i < L.length; ++i) {//i记录遍历L中的每一个元素
        k = 0;//每次循环k都从0开始
        while (k <= j && L.elem[k] != L.elem[i]) 
            k++;
        if (k > j)//表示L.elem[i]与L.elem[0..j]中的元素都不相同
            L.elem[++j] = L.elem[i];//j记录结果的下标
    }
    L.length = j + 1;
}
//i = 3; k = 1; j = 1;
//L元素： 2 2 3 2 4 3 2 1
//L结果： 2 3 4 1

我的答案：

//我的答案：

9.反转顺序表left到right

注意这里left和right指的是下标

示例1：0 1 2 3 4 5 6 7 --反转下标2到6的元素--> 0 1 6 5 4 3 2 7
示例2：19 8 12 31 71 25 46 37 --反转下标2到5--> 19 8 25 71 31 12 46 37

9.1先来回忆一下前面讲过的顺序表逆置

//设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为 0(1)
void Reverse(SqList &L){
    for(int i=0; i<L.length/2; i++){//首尾元素交换法完成元素逆置
        int temp = L.elem[i];
        L.elem[i] = L.elem[L.length - i - 1];
        L.elem[L.length-i-1] = temp;
    }
}

9.2那么如何逆置下标left到right之间的元素呢？

//0 1 2 3 4 5 --逆置下标2到4之间的元素--> 0 1 4 3 2 5
void Reverse_l_r(SqList &L, int left, int right){

}

我的答案：

//我的答案：
void Reverse_l_r(SqList &L, int left, int right){
	int i = ( right - left ) / 2;
	int e;
	for(int j = left;j <= left+i; j++){
		e = L.elem[j];
		L.elem[j] = L.elem[right - j + left];
		L.elem[right - j + left] = e;
	}
}

9.3 反转数组 a 中下标 left 到 right 之间的元素函数实现：

示例1：0 1 2 3 4 5 6 7 --反转下标2到6的元素--> 0 1 6 5 4 3 2 7
示例2：19 8 12 31 71 25 46 37 --反转下标2到5--> 19 8 25 71 31 12 46 37

函数实现如下：与上面的函数Reverse_l_r(SqList &L, int left, int right)如出一辙

int *Reverse_arr_1(ElemType *a, int left, int right, int arraySize){

    
}

我的答案：

//我的答案：
int *Reverse_arr_1(ElemType *a, int left, int right){
	int i = ( right - left ) / 2;
	int e;
	for(int j = left;j <= left+i; j++){
		e = a[j];
		a[j] = a[right - j + left];
		a[right - j + left] = e;
	}	
    return a;
}

10.两个顺序表位置互换

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

我的答案：

//我的答案：
int *Reverse_arr_1(ElemType *a, int left, int right){
	int i = ( right - left ) / 2;
	int e;
	for(int j = left;j <= left+i; j++){
		e = a[j];
		a[j] = a[right - j + left];
		a[right - j + left] = e;
	}	
    return a;
}
int *Exchange(ElemType *a, int m, int n){
	Reverse_arr_1(a,0,m-1);
	Reverse_arr_1(a,m,m+n-1);
	Reverse_arr_1(a,0,m+n-1);
	return a;
}

Pitt张

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
顺序表经典题目

1.删除最小值（假设唯一）//---------------------删除最小值（假设唯一）-----------------------//从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值//若顺序表为空则显示出错信息并退出运行//下面已经给出了函数名称和参数类型，删除L中的最小值，并用min_value返回，//把代码（包含注释）复制到b中，请完善函数主体内容，并在主函数中调用(注意在head.h中声明函数名)Status Del_Min(SqList &L,
复制链接

扫一扫