【王道数据结构课后习题代码练习完整版】顺序表

一、线性表

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

#include  
//从顺序表中删除最小值的元素（假设唯一），并由函数返回被删除元素的值。空出的位置由最后一个元素填补。若顺序表为空，则显示出错信息并退出运行
//申明顺序表结构类型
#define MaxSize 50
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList;

bool DelMinSqlist(SqList &L,ElemType &e){
    if(L.length==0) //顺序表为空，显示出错信息
    {
        return false;
    }
    e=L.data[0];//用于存储最小元素的值,初始化为data[0]
    int pos;//用于存储最小元素值的下标
    for(int i=1;i

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

#include 
//设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)
#define MaxSize 50
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList;

//逆置函数
//算法思想：依次扫描顺序表L，将前一半元素（i

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

#include 
//对长度为n的顺序表L，编写一个时间复杂度为o(n),空间复杂度为o(1)的算法，该算法删除线性表中所有值为x的元素
//定义顺序表数据结构
#define MaxSize 50
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList;
//方法一：用k记录不等于待删除元素值x出现的次数，并将该元素移动到第k（k=0,1,2..）个位置
bool Del_Sql_x1(SqList &L,ElemType x){
    int k=0;
    for(int i=0;i

2.2.3-4 从有序顺序表中删除其值在s与t之间（s

#include 

//从有序顺序表中删除其值在s与t之间（s=t||L.length==0){
        return false;
    }
    for(i=0;i

2.2.3-5 从顺序表中删除其值在给定值s与t（要求s

#include 

//从顺序表中删除其值在给定值s与t（要求s=t||L.length==0){
        return false;
    }
    for(int i=0;iL.data[i]||t=t||L.length==0){
        return false;
    }
    for(int i=0;i=L.data[i]){
            k++;
        }else{
            L.data[i-k]=L.data[i];
        }
    }
    L.length-=k;
    return 1;
}

int main() {
    SqList L;
    bool ret;//用于接收函数调用的返回值
    L.length=10;
    for(int i=0;i

2.2.3-6 从有序顺序表中删除所有值重复的元素，使表中所有元素均不同

#include 

//从有序顺序表中删除所有值重复的元素，使表中所有元素均不同
#define MaxSize 20
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList;

//算法思想1：由于是有序顺序表，则重复元素是连续的。用k记录非重复元素的个数，将非重复元素移动到K下标所在位置
bool Del_Sql_Rep1(SqList &L){
    if(L.length==0){
        return false;
    }
    int k=0;
    ElemType rep=L.data[0];
    for(int i=1;i

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

#include 
//将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表
#define MaxSize 50
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList;

//算法思想：将顺序表L1与L2表头元素比较，将较小的元素插入顺序表L3，且将较小元素所在表的表头后移；如某个顺序表有剩余，则将剩余部分插入L3
bool MergeSql(SqList L1,SqList L2,SqList &L3){
    if(L1.length+L2.length>MaxSize){ //顺序表的空间要足够存储合并后的顺序表
        return false;
    }
    int i=0,j=0,k=0;
    while(i

2.2.3-8 已知在一维数组A[m+n]中依次存放两个线性表（a1,a2,…,am）和(b1,b2,…,bn),编写一个函数，将数组中两个顺序表的位置互换。

#include 
//已知在一维数组A[m+n]中依次存放两个线性表（a1,a2,...,am）和(b1,b2,...,bn),编写一个函数，将数组中两个顺序表的位置互换。
typedef int ElemType;
//算法思想：在不使用其它辅助空间的前提下，先将数组A[m+n]原地逆置，再分别将前n个元素和后m个元素逆置，即可将两个数组位置互换

//逆置函数
//A[]传递数组起始地址，left表示逆置的起始下标，right表示逆置的结束下标，length表示数组长度
void ReverseArr(ElemType A[],int left,int right,int length){
    if(left>=right||right>=length)
    {
        return;
    }
    ElemType temp;
    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;
    }
}

//顺序表互换函数
//A[]传递数组起始地址，m表示左边线性表的长度，n表示右边线性表的长度
void ExchangeArr(ElemType A[],int m,int n,int length){
    ReverseArr(A,0,m+n-1,length);
    ReverseArr(A,0,n-1,length);
    ReverseArr(A,n,m+n-1,length);
}


//打印函数
void PrintArr(ElemType A[],int length){ //数组传递到子函数后，子函数形参接收到的是数组起始地址，数组长度不能传递，因此要额外定义数组长度
    for(int i=0;i

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

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

typedef int ElemType;
//查找函数
//算法思想：对于有序顺序表，查找可采用折半查找法，时间复杂度是O(log2n)
bool Search_Exchange_Insert(ElemType A[],ElemType x,int length){ //待查找元素为x
    int low=0,high=length-1,mid;
    while(low<=high){   //折半查找，退出条件为没找到(low>high)或者找到(break)
        mid=(low+high)/2;
        if(x==A[mid]){
            break;
        }else if(x>A[mid]){
            low=mid+1;
        }else{
            high=mid-1;
        }
    }
    if(x==A[mid]&&mid!=length-1){ //如找到元素x，且该元素不是最后一个元素，则进行交换
        ElemType temp=A[mid];
        A[mid]=A[mid+1];
        A[mid+1]=temp;
    }
    if(low>high){ //如未找到，则在元素A[high]后面插入
        for(int i=length-1;i>high;i--){
            A[i+1]=A[i];
        }
        A[high+1]=x;
    }
    return true;
}

//打印函数
void PrintArr(ElemType A[],int length){
    for(int i=0;i