线性表课后习题

2023年数据结构考研复习指导（王道论坛）

第二章 线性表

课后习题1-9

#include <iostream>
#include <unordered_set>
using namespace std;
typedef struct SeqList
{
    int* data;
    int MaxSize = 100;
    int length;
}SeqList;
//1.由顺序表删除具有最小值的元素（唯一）并返回被删元素的值。空出的位置由最后一个元素填充
//使用cpp引用类型
int MinDelete(SeqList& L) {
    int minNum = 100;
    int minIndex = -1;
    for (int i = 0; i < L.length; i++) {
        if (*(L.data + i) < minNum) {
            minNum = *(L.data + i);
            minIndex = i;
        }
    }
    *(L.data + minIndex) = *(L.data + L.length - 1);
    L.length--;
    return minNum;
}
//使用指针
int MinDelete(SeqList* L) {
    if (L->length < 0) {
        cout << "The List is NULL" << endl;
        return -1;
    }
    int minNum = 100;
    int minIndex = -1;
    for (int i = 0; i < L->length; i++) {
        if (*((*L).data + i) < minNum) {//L->data = (*L).data
            minNum = *(L->data + i);
            minIndex = i;
        }
    }
    *(L->data + minIndex) = *(L->data + L->length - 1);
    L->length--;
    return minNum;
}
//2.将顺序表元素逆置
void Reverse(SeqList& L) {
    int low = 0, high = L.length - 1;
    while (low < high) {
        int temp = L.data[low];
        L.data[low] = L.data[high];
        L.data[high] = temp;
        low++;
        high--;
    }
    return;
}
//3.O(n)时间复杂度,O(1)空间复杂度，删除L中值为x的元素
void DeleteTarget(SeqList& L, int target) {
    int count = 0;
    for (int i = 0; i < L.length; i++) {
        //如果值相等，则count+1
        if (target == L.data[i]) {
            count++;
        }
        //值不相等,不是x,此时下标是i,前面有k个x,那么应该从下标为i-k的应该赋值为这个数字，相当于把所有的x都放在最后面
        else {
            L.data[i - count] = L.data[i];
        }
    }
    L.length = L.length - count;
    return;
}
//4.从有序顺序表中删除值在s和t之间的所有元素
//5.从顺序表中删除值在s和t之间的所有元素
void DeleteBlock(SeqList& L, int minNum, int maxNum) {
    if (L.length <= 0) {
        cout << "NULL";
        return;
    }
    if (minNum >= maxNum) {
        cout << "Error";
        return;
    }
    int count = 0;
    for (int i = 0; i < L.length; i++) {
        //如果值符合，则count+1
        if (minNum <= L.data[i] && maxNum >= L.data[i]) {
            count++;
        }
        //值不符合,不是x,此时下标是i,前面有count个x,那么应把下标为i-count的赋值为这个数字，相当于把所有的x都放在最后面
        else {
            L.data[i - count] = L.data[i];
        }
    }
    L.length = L.length - count;
    return;
}
//6.有序顺序表删除值重复的元素
void DeleteRepete(SeqList& L) {
    //双指针
    int index1 = 0, index2 = 0;
    for (index1, index2; index2 < L.length;) {
        if (L.data[index1] == L.data[index2]) {
            index2++;
        }
        else {
            index1++;
            L.data[index1] = L.data[index2];
            index2++;
        }
    }
    L.length = index1 + 1;
    return;
}
//顺序表删除值重复的元素(使用散列表)
void DeleteDuplicate(SeqList& L) {
    unordered_set<int> hash;
    int count = 0;
    for (int i = 0; i < L.length; i++) {
        //证明重复
        if (hash.find(L.data[i]) != hash.end()) {
            count++;
        }
        else {
            hash.insert(L.data[i]);
            L.data[i - count] = L.data[i];
        }
    }
    L.length = L.length - count;
    return;
}
//7.将两个有序顺序表合并为一个新的有序顺序表
SeqList* Merge(SeqList A, SeqList B) {
    SeqList* L = new SeqList();
    L->data = new int[A.length+B.length];
    int i = 0, j = 0, k = 0;
    while (i < A.length && j < B.length) {
        if (A.data[i] < B.data[j]) {
            L->data[k++] = A.data[i++];
        }
        else {
            L->data[k++] = B.data[j++];
        }
    }
    while (i < A.length) {
        L->data[k++] = A.data[i++];
    }
    while (j < B.length) {
        L->data[k++] = B.data[j++];
    }
    L->length = k;
    return L;
}
//8.交换顺序表 
void Reverse(SeqList &L,int left,int right){
    int temp = 0;
    int i = left,j = right - 1;
    while(i < j){
        temp = L.data[i];
        L.data[i] = L.data[j];
        L.data[j] = temp;
        i++;
        j--; 
    }
    return;

}
void Exchange(SeqList &L,int m,int n){
    //先将数组[a0,a1,...,am,b0,b1,...,bn]逆置为[bn,..,b0,am,..a0],再将前面N个元素和后面M个元素进行逆置
    Reverse(L,0,m+n);
    Reverse(L,0,n);
    Reverse(L,n,m+n);
    return;

}
//9.查找
void Find(int target,SeqList &L){
    int low = 0,high = L.length - 1;
    int middle;
    bool flag = false;
    while(low <= high){
        middle = low + (high - low) / 2;
        if(L.data[middle] == target){
            flag = true;
            break;
        }
        else if(L.data[middle] < target){
            low = middle + 1;
        }
        else if(L.data[middle] > target){
            high = middle - 1;
        }
    }
    if(flag){
        if(middle != L.length - 1){
            int temp = L.data[middle];
            L.data[middle] = L.data[middle + 1];
            L.data[middle + 1] = temp;
        }
        
    }
    else{
        //插入
        int *num = new int[L.length + 1];
        for(int i = 0;i <= high;i++){
            num[i] = L.data[i]; 
        }
        num[high + 1] = target;
        for(int i = high + 2,j = high + 1;i < L.length + 1;i++,j++){
            num[i] = L.data[j];
        }
        //数组名就是首地址
        L.data = num;
        L.length++;
    }
    return;

}
int main() {
    int data[10] = { 1,3,5,7,9,11,13,15,17,19 };
    int data1[10] = { 2,4,6,8,10,12,14,16,18,20 };
    SeqList L{ &data[0],100,10 };
    SeqList L1{ &data1[0],100,10 };
    //int a = MinDelete(&L);
    //cout<<a<<" "<<L.length<<endl;
    /*for(int i = 0;i < L.length;i++){
        cout<<L.data[i]<<" ";
    }
    cout<<endl;*/
    //Reverse(L);
    //DeleteTarget(L,5);
    //DeleteBlock(L,5,10);
    //DeleteRepete(L);
    /*DeleteDuplicate(L);
    for(int i = 0;i < L.length;i++){
        cout<<L.data[i]<<" ";
    }*/
    //SeqList* L2 = Merge(L, L1);
    //Exchange(L,4,6);
    Find(10,L);
    for (int i = 0; i < L.length; i++) {
        cout << L.data[i] << " ";
    }
    return 0;
}