在一个整型数组a中，删除所有的大于24的数值，并且要求算法对任意的这种数组算法都成立。_编程:请分别求解以下问题在一个整型数组a中,删除所有的大于24的数值,并且要求算-CSDN博客

本文链接：https://blog.csdn.net/Supreme_One/article/details/85276396

题目：

编程：请分别求解以下问题

在一个整型数组a中，删除所有的大于24的数值，并且要求算法对任意的这种数组算法都成立。

如果要求剩余数组中元素不改变原有元素的相对顺序，且空间复杂度为O(1)
如果要求算法时间复杂度为O(n)，空间复杂度为O(1)

void deleteall(int a[] ,int &n)//a为待删除的数组，n为元素个数

分别构造10组测试用例，证明算法确实对任意的这种数组算法都成立。

代码及注释：

#include <iostream>

using namespace std;

const int max = 1e5;
int a[max];//数组

void deleteallone(int a[] , int &n);//算法函数1：不改变元素的相对顺序，空间复杂度为O(1)

void deletealltwo(int a[] , int &n);//算法函数2：时间复杂度为O(n)，空间复杂度为O(1)

void swap(int &v1 , int &v2);//交换两个数值


int main()
{
    int n,i;

    cin>>n;//输入数组个数

    for(i = 0 ; i < n ; i++)//输入数组的每个值
    {
           cin>>a[i];
    }

    //deleteallone(a,n);//调用

    deletealltwo(a,n);//调用

    i= 0;

    if(i== n)//判断打印
    {
           cout<<"该数组的值都大于24"<<endl;
    }else
    {
           for(i = 0 ; i < n ;i++)//打印
           {
                  cout<<a[i]<<" ";
           }
    }

    return 0;
}


void deleteallone(int a[] , int &n)
{
    int i= 0,pos= n-1;
    while(i<= pos)
    {
           if(a[i]> 24)
           {
                  for(int j= i; j< pos; j++)//将后面的值向前移
                  {
                         a[j]= a[j+1];
                  }
                  pos--;
           }else{
                  i++;//移到下一个
           }
    }

    n= pos+1;
}


void deletealltwo(int a[] , int &n)
{

    int i= 0,pos= n-1;

    while(i<= pos)
    {
           if(a[i]> 24)
           {
                  swap(a[i],a[pos]);//将当前值与最后一个值交换
                  pos--;//最后一个值向前移
           }else
           {
                  i++;//移到下一个
           }

    }

    n= pos+1;

}


void swap(int &v1 , int &v2)
{

       v1= v2-v1;

       v2= v2-v1;

       v1= v2+v1;

       /*int count;

       count= v1;

       v1=v2;

       v2=count;*/

}

测试用例

输入：   8

70 56 75 19 42 90 96 46

算法函数1输出：19

算法函数2输出：19

输入：   10

12 5 46 59 73 63 93 78 12 25

算法函数1输出：12 5 12

算法函数2输出：12 5 12

输入：   6

3 88 1 58 75 1

算法函数1输出：3 1 1

算法函数2输出：3 1 1

输入：   5

25 25 25 25 25

算法函数1输出：该数组的值都大于24

算法函数2输出：该数组的值都大于24

输入：   5

              24 24 24 24 24

算法函数1输出：24 24 24 24 24

算法函数2输出：24 24 24 24 24

输入：   22

35 54 16 99 11 25 16 64 70 30 12 11 81 38 22 5 76 71 35 57 5 98

算法函数1输出：16 11 16 12 11 22 5 5

算法函数2输出：5 5 16 22 11 11 16 12

输入：   40

38 7 49 81 3 79 88 41 42 87 82 67 26 24 7 18 98 56 98 15 17 31 42 78 98 46 83 31 45 19 18 71 64 66 80 67 39 8 96 38

算法函数1输出：7 3 24 7 18 15 17 19 18 8

算法函数2输出：8 7 18 19 3 17 15 18 7 24

输入：   99

67 27 17 48 91 66 34 66 96 46 21 79 38 80 88 64 95 90 44 20 92 11 32 22 29 97 64 73 86 67 1 83 36 63 79 83 13 0 75 65 66 89 74 65 29 34 2 70 50 15 47 48 91 62 33 58 4 20 72 5 8 63 35 55 36 49 49 51 79 29 93 53 95 10 62 56 70 37 10 75 65 24 82 49 38 67 22 28 32 74 17 15 95 35 44 98 75 89 21

算法函数1输出：17 21 20 11 22 1 13 0 2 15 4 20 5 8 10 10 24 22 17 15 21

算法函数2输出：21 15 17 17 22 24 10 10 8 5 21 20 4 15 2 0 13 1 22 20 11

输入：   30

40 3 58 85 2 50 93 54 37 24 9 98 81 47 61 0 87 78 2 13 4 14 25 24 20 76 63 29 89 63

算法函数1输出：3 2 24 9 0 2 13 4 14 24 20

算法函数2输出：20 3 24 14 2 4 13 2 0 24 9

输入：   13

60 70 28 1 41 58 12 97 0 65 56 7 40

算法函数1输出：1 12 0 7

算法函数2输出：7 0 12 1