王道数据结构——线性表中顺序表的一些综合应用题

1.长度为n的顺序表中，编写一个时间复杂度为O(n)，空间复杂度为O(1)的算法，用于删除线性表中所有值为x的数据元素。（满足要求的数放在第k位上）

#include <cstdio>

/*输出数组名为a、长度为n的数组*/
void print(int *a, int n){
    for(int i = 0;i < n; i++){
        printf("%d ", a[i]);
    }
    puts("");
}

/*解法1，第几个不等于x的数就应该在结果的第几个位置上,千万记得最后修改删除后的数组长度为k*/
void f1(int *a, int n, int x){
    int k = 0;
    for(int i = 0; i < n; i++){
        if(a[i] != x){
            a[k++] = a[i];
        }
    } 
    n = k;
    print(a,k);
}

/*解法2，用k记录等于x的个数，那么下一个不等于x的数在结果中的位置应该提前k个位置，最后数组的长度减去k*/
void f2(int *a, int n, int x){
    int k = 0;
    for(int i = 0; i < n; i++){
        if(a[i] == x)
            k++;
        else
            a[i - k] = a[i];
    }
    n -= k;
    print(a, n);
} 

int main()
{
    int a[10] = {1,2,3,2,4,2,5,2,6,2};
    f1(a,10,2);

    int b[10] = {1,2,3,2,4,2,5,2,6,2};
    f2(b,10,2);
    return 0;
}

 2.从有序顺序表中删除其值在给定值s与t之间（包括s和t，要求s<t）的所有元素，如果s或者t不合理或者顺序表为空则显示出错信息并退出运行。（掐掉中间这段）

#include <cstdio>

/*在有序顺序表中，删除值在[s,t]内的元素
只需找到第一个大于或者等于s的位置计数为i，然后往后找第一个大于t的数，将其后的所有元素依次放到i及之后*/ 

bool Del_s_t(int a[], int n, int s,int t){
    if(s>=t || n == 0)
        return false;
    int i = 0, j = 0;
    for(i = 0; i < n && a[i] < s; i++);
    if(i >= n)
        return false;//全部小于s
    for(j = i; j < n && a[j] <= t; j++);
    for(;j < n; j++){
        a[i++] = a[j];
    }
    n = i;
    //输出 
    for(int i = 0; i < n; i++){
        printf("%d ", a[i]);
    }
    puts("");
    return true;
}
int main()
{
    int a[]={2,4,5,6,7,8,9,11,12,13,14,15,15};
    Del_s_t(a, 13, 3, 10);
    return 0;
}

3.从顺序表中删除其值在给定值s与t之间（包括s和t，要求s<t）的所有元素，如果s或者t不合理或者顺序表为空则显示出错信息并退出运行(注意与上题的区别是无序的)。

（满足要求的数放在第k位上）

#include <cstdio>
#include <algorithm>
using namespace std;

void print(int a[], int n){
    for(int i = 0; i < n; i++){
        printf("%d ", a[i]);
    }
    puts("");
}
/*对于无序的顺序表，将数分成两类，一个在区间一个不在区间，然后计数不在区间的数为k
碰到在区间的数应该在结果的第k个位置上，最后总长度为k*/ 
void Del_s_t2(int a[], int n, int s, int t){
    if(s >= t || n == 0)
    return;
    int k = 0;
    for(int i = 0; i < n; i++) {
        if(a[i] < s || a[i] > t)
            a[k++] = a[i];
    } 
    n = k;
    print(a, n);
}
int main()
{
    int a[] = {7,2,9,4, 5,1,3,14};
    //sort(a, a + 8);
    print(a, 8);
    Del_s_t2(a, 8, 3, 7);
    return 0;
}

4.从有序的顺序表中删除相同的元素，使得表中每个元素都不同。（满足要求的数放在第k位上）

#include <cstdio>
#include <algorithm>
using namespace std;

void print(int a[], int n){
    for(int i = 0; i < n; i++){
        printf("%d ", a[i]);
    }
    puts("");
}
/*从有序表中删除相同的元素，只需将于之前不同的数放在第k个位置上即可*/ 
void Del_diffe(int a[], int n){
    int k = 1;
    for(int i = 1; i < n; i++){
        if(a[i] != a[i - 1])
            a[k++] = a[i];
    } 
    n = k;
    print(a, k);
} 
int main()
{
    int a[] = {1,1,2,2,2,4,4,5,5,5,5,6,6};
    Del_diffe(a, 13);
    return 0;
}

5.合并两个有序表。

#include <cstdio>
/*合并两个有序表，依次比较，然后添加剩余*/
const int lmax = 50;
int c[lmax];
bool merge(int a[], int la, int b[], int lb){
    if(la + lb >= lmax)
        return false;
    int i = 0,j = 0,k = 0;
    while(i < la && j < lb){
        if(a[i] <= b[j])
            c[k++] = a[i++];
        else
            c[k++] = b[j++];
    }
    while(i < la){
        c[k++] = a[i++];
    }
    while(j < lb){
        c[k++] = b[i++];
    }
    return true;
    
    for(i = 0; i < k; i++){
        printf("%d ", c[i]);
    }
    puts("");
} 

int main()
{
    int a[]={1,5,6,8,9,11,12,15,17},la = 9;
    int b[]={2,3,4,6,7,9,10}, lb = 7;
    merge(a,la,b,lb);
    return 0;
} 

6.将一个顺序表中的两个顺序表互换位置。（矩阵逆置）

#include <cstdio>
void print(int a[], int n){
    for(int i = 0; i < n; i++){
        printf("%d ", a[i]);
    }
    puts("");
}
/*逆置数组某一区间的方法
数组及其长度，逆置的起始位置和终止位置
中间位置等于起始位置加上终止位置除以2 
*/
void Reverse(int a[],int n, int s, int t)
{
    if(s >= t || t >= n)
        return; 
    int mid = (s + t)/2;
    for(int i = 0; i <= (mid - s); i++){
        int temp = a[s + i];
        a[s + i] = a[t - i];
        a[t - i] = temp;
    }
} 
/*
sc表示交换次数 
*/
void Reverse2(int a[], int n, int s, int t){
    if(s >= t || t >= n)
        return;
    int sc = (t - s + 1)/2;
    for(int i = 0; i < sc;i ++){
        int temp = a[s + i];
        a[s + i] = a[t - i];
        a[t - i] = temp;
    }
}
int main()
{
    int a[] = {1,2,3,4, 5,6,7,8};
    print(a, 8);
    Reverse2(a, 8, 0, 7);
    Reverse2(a, 8, 0, 3);
    Reverse2(a, 8, 4, 7);
    print(a, 8);
    return 0;
}

6.用最少的时间在有序表中查找数值为x的元素。（折半查找法）

#include <cstdio>
#include <algorithm>
using namespace std;

void print(int a[], int n){
    for(int i = 0; i < n; i++){
        printf("%d ", a[i]);
    }
    puts("");
}
/*折半查找法，选定上界和下届，分三种情况，找到，大了，往左半边找，小了，往右半边找*/
bool B_Search(int a[], int n, int x){
    int l = 0, h = n - 1, mid;//low 和 high 分别是顺序表的上界和下届
    int flag = 0;
    while(l <= h){
        mid = (l + h) / 2;
        if(a[mid] == x)    {
            flag = 1;
            break;
        }
        if(a[mid] < x)    l = mid + 1;
        else h = mid - 1;    
    } 
    //如果查找失败，插入x到此前h + 1的位置上，因为 
    if(l > h){
        int i;
        for(i = n - 1; i > h; i--)
            a[i + 1] = a[i];
        a[i + 1] = x; 
    } 
    if(flag == 1)
        return true;
    return false;
} 
int main()
{
    int a[] = {1,2,3,4,5,6,7};
    B_Search(a, 7, 2);
    print(a, 7);
    return 0;
}

 7.设计一个将含有n（n>=1）整数的数组实现循环左移的算法，要求时间和空间复杂度尽可能的高效。（借助矩阵逆运算）

#include <cstdio>

void print(int a[], int n){
    for(int i = 0; i < n; i++){
        printf("%d ", a[i]);
    }
    puts("");
}
void Reverse(int a[], int from, int to){
    int sc = (to - from + 1) / 2;
    for(int i = 0; i < sc; i++) {
        int temp = a[from + i];
        a[from + i] = a[to - i];
        a[to - i] = temp;
    }
}
/*借助矩阵逆运算，ab->ba,即ab->a逆b->a逆b逆->(a逆b逆)逆=ba*/
void Rotate_left(int a[], int n, int p){
    Reverse(a, 0, p - 1);
    Reverse(a, p, n - 1);
    Reverse(a, 0, n - 1);
}

int main()
{
    int a[] = {1,2,3,4,5,6,7,8,9};
    for(int i = 1; i <= 9; i++){
        Rotate_left(a, 9, i);
        print(a, 9);
    }
    return 0;
}

 8.找出两个等长、升序数组中的中位数。中位数：升序排列后为与中间位置的数叫做中位数。（每次取两数组中的中位数比较，等于就是中位数，不等于舍弃不可能存在的区间）

#include <cstdio>
/*有种折半查找的意味，每次去两个中位数，相等就说明一样，
        大于或者小于表示中位数在各自区域的另一半，不同的是
        每次舍弃时要舍弃一样的长度，需要分情况讨论。 
*/
int slove(int a[], int b[], int n){
    int s1 = 0,d1 = n - 1,m1, s2 = 0, d2 =  n - 1, m2;
    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)//若a的元素的个数为奇数个 
            {
                s1 = m1;//舍弃a中间点之前的部分且保留中间结点 
                d2 = m2;//舍弃b中间点之后的部分且保留中间结点 
            }
            else//若a的元素的个数为偶数个 
            {
                s1 = m1 + 1;//舍弃a中间点以及中间点之前的部分
                d2 = m2; 
            } 
        }
        else{
            if((s2 + d2) % 2 == 0)//若b的元素的个数为奇数个 
            {
                d1 = m1;//舍弃b中间点之后的部分且保留中间结点
                s2 = m2;//舍弃a中间点之前的部分且保留中间结点  
            }
            else//若b的元素的个数为偶数个 
            {
                d1 = m1;
                s2 = m2 + 1;//舍弃b中间点以及中间点之前的部分
            } 
        } 
    }
    return a[s1] < b[s2] ? a[s1] : a[s2];//返回较小的那个数为中位数 
}
int main()
{
    int a[] = {1,3,5,7,9,11};
    int b[] = {0,2,4,6,8,10};
    int mid = slove(a, b, 6);
    printf("%d
", mid); 
    return 0;
}

 9.寻找一个数组中的是否存在主元素，存在输出主元素，不存在输出-1。（排序后遍历找出个数最大，最后判断即可）

#include <cstdio>
#include <algorithm>
using namespace std;

//先排序后将等值元素集中在一起，然后集中遍历，记录个数最多的元素最后判断即可 
int slove(int a[], int n){
    sort(a, a + n);
    int rs = a[0], max = 1;
    int temp = 1;
    for(int i = 1; i < n; i++){
        if(a[i] == a[i - 1])
            temp++;
        else{
            if(temp > max){
                rs = a[i - 1];
                max = temp;
            }
            temp = 1;
        }    
    }
    if(max > n/2)
        return rs;
    return -1;
}
int main()
{
    int i, c, cnt = 1;
    int a[] = {1, 2, 2, 2, 4, 2,};
    printf("%d
", slove(a, 6));
    int b[] = {1, 2, 3, 4, 5, 6,};
    printf("%d
", slove(b, 6));
    return 0;
}

 10.顺序表的原地逆置,循环左移和循环右移

#include<cstdio>
/*关于顺序表中基本操作中使用到矩阵运算的总结
1.实现顺序表中两个顺序子表的原地逆置
2.循环左移k位
3.循环右移k位 
*/
void Reverse(int a[], int fr, int to){
    int i, mid = (to - fr + 1)/2, temp;
    for(i = 0; i < mid; i++){
        temp = a[fr + i];
        a[fr + i] = a[to - i];
        a[to - i] = temp;
    }
}

void Solve2(int a[], int k)
{
    /*欲循环左移k位，先将后k位逆置，再将前n-k位逆置，最后整体逆置*/
    int n = 9;
    Reverse(a, k, n-1);
    Reverse(a, 0, k-1);    
    Reverse(a, 0, n-1);
    printf("接着循环左移4位：");
    for(int i = 0; i < n; i++){
        printf("%d ", a[i]);
    }puts("");
} 
void Solve3(int a[], int k)
{
    /*欲循环右移k位，先将前k位逆置，再将后n-k位逆置，最后整体逆置*/
    int n = 9;
    Reverse(a, 0, k-1);
    Reverse(a, k, n-1);
    Reverse(a, 0, n-1);
    printf("接着循环右移5位：");
    for(int i = 0; i < n; i++){
        printf("%d ", a[i]);
    }puts("");
} 
/*欲ab->ba，则(a逆b逆)逆 = ba*/
void Solve1(int a[], int fr1, int to1, int fr2, int to2){
    Reverse(a, fr1, to1);
    Reverse(a, fr2, to2);
    Reverse(a, fr1, to2);
    printf("原地逆置：");
    for(int i = fr1; i <= to2; i++){
        printf("%d ", a[i]);
    }puts("");
}
int main()
{
    int a[]={5,6,7,8,9,1,2,3,4};
    //目标是 {1,2,3,4,5,6,7,8,9};
    printf("原数组：");
    for(int i = 0; i <9; i++){
        printf("%d ", a[i]);
    }puts("");
    
    Solve1(a,0,4,5,8);
    
    Solve2(a,4);
    
    Solve3(a,5);
    /*
    原数组：5 6 7 8 9 1 2 3 4
    原地逆置：1 2 3 4 5 6 7 8 9
    接着循环左移4位：5 6 7 8 9 1 2 3 4
    接着循环右移5位：1 2 3 4 5 6 7 8 9
    */
    return 0;    
}