C语言--设A是n个非0实数构成的数组，设计一个算法重新排列数组中的数，使得负数都排在正数前面

最新推荐文章于 2024-04-20 20:18:23 发布

兔子骑士叫旺仔

最新推荐文章于 2024-04-20 20:18:23 发布

阅读量1.6k

点赞数 4

分类专栏： C 排序算法文章标签：算法 c语言排序算法

本文链接：https://blog.csdn.net/hanxiaochuan1/article/details/127716831

版权

C 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

排序算法

3 篇文章 0 订阅

订阅专栏

文章目录

问题
三种算法
三种算法的运行时间对比
完整代码
测试用例
体会

问题

设A是n个非0实数构成的数组，设计一个算法重新排列数组中的数，使得负数都排在正数前面

三种算法

int* bestSort(int array[], int length) {
    //第一种, 最佳的排序算法, 基于快速排序，时间复杂度O(n), 空间复杂度O(1)
    int low = 0, high = length - 1;  // 设置两个指针low和high，分别指向数组的开始元素和末尾元素
    int temp;  // 设置中间变量，作为交换两个元素的中间容器
    while (low < high) {
        while (array[low] < 0 && low < high)  // 当low指向的元素为负数并且low和high没有遇见
            low++;  // low后移
        while (array[high] > 0 && low < high)  // 当high指向的元素为正数并且low和high没有遇见
            high--;  // high后移
        temp = array[low];  // 交换元素
        array[low] = array[high];
        array[high] = temp;
    }
    return array;
}

第一种算法：
设置两个整型变量low和high分别存储数组的第一个元素和最后一个元素的下标，low从前至后，high从后至前，如果low位置的值小于0，不用移动元素，low指针后移；同理，如果high位置的值大于0，high指针前移。如果low位置的元素大于0，high位置的元素小于0，交换两元素位置，否则就继续移动。如果在遍历过程中low >= high，说明整个数组已经遍历完成。时间复杂度为O(n)，空间复杂度为O(1)。

int* choiceSort(int array[], int length) {
    // 第二种,时间复杂度：O(n^2), 空间复杂度O(1)
    int i = 0, j = 0, negative = 0, positive = 0;  // negative：记录负数位置 positive：记录正数位置
    int temp;  // 设置中间变量，作为交换两个元素的中间容器
    for (i = 0; i < length - 1; i++) {  // 遍历数组
        if (array[i] > 0) {  // 如果当前元素为正数
            positive = i;  // 记录当前元素的位置
            for (j = i + 1; j < length; j++) {  // 遍历当前元素的后方元素
                if (array[j] < 0) {  // 发现第一个负数
                    negative = j;  // 记录该负数的位置
                    break;  // 退出内循环
                }
            }
            temp = array[positive];  // 交换两个元素位置
            array[positive] = array[negative];
            array[negative] = temp;
        }
        else {  // 如果当前元素为负数，跳过，进行下一个元素的判断
            continue;
        }
    }
    return array;
}

第二种算法
遍历数组，若当前元素为正数，记录当前元素的位置，然后在未遍历的元素中寻找第一个负数的位置，然后交换两个元素；若当前元素为负数，则满足条件，直接进行下一个元素的判断，直到遍历完成。时间复杂度为O(n^2)，空间复杂度为O(1)。

int* insertionSort(int array[], int length) {
    //第三种,时间复杂度O(n^2), 空间复杂度O(1)
    int i, j;
    int key;
    for (i = 1; i < length; i++) {
        key = array[i];
        j = i - 1;
        while ((j >= 0) && (array[j] > key)) {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = key;
    }
    return array;
}

第三种算法
将第一个元素看作一个有序的序列，遍历该元素之后未被排序的数组，将遍历到的每个元素插入有序序列的适当位置，如果待插入的元素与排好序的序列中某个元素相等，则排在相等元素的后方。时间复杂度为O(n^2)，空间复杂度为O(1)。

int* insertionSort(int array[], int length) {
    //第三种,时间复杂度O(n^2), 空间复杂度O(1)
    int i, j;
    int key;
    for (i = 1; i < length; i++) {
        key = array[i];
        j = i - 1;
        while ((j >= 0) && (array[j] > key)) {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = key;
    }
    return array;
}

三种算法的运行时间对比

算法运行时间（单位：秒）	一万数据	十万数据	百万数据
第一种	0	0.001	0.006
第二种	0.014	1.447	135.664
第三种	0.026	2.57	258.946

完整代码

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/*
 * 设A是n个非0实数构成的数组，设计一个算法重新排列数组中的数，使得负数都排在正数前面，要求用多种算法实现，并保证至少算法中有一种算法使用O(n)的时间和O(1)的空间。
 */

int* bestSort(int array[], int length) {
    //第一种, 最佳的排序算法, 基于快速排序，时间复杂度O(n), 空间复杂度O(1)
    int low = 0, high = length - 1;  // 设置两个指针low和high，分别指向数组的开始元素和末尾元素
    int temp;  // 设置中间变量，作为交换两个元素的中间容器
    while (low < high) {
        while (array[low] < 0 && low < high)  // 当low指向的元素为负数并且low和high没有遇见
            low++;  // low后移
        while (array[high] > 0 && low < high)  // 当high指向的元素为正数并且low和high没有遇见
            high--;  // high后移
        temp = array[low];  // 交换元素
        array[low] = array[high];
        array[high] = temp;
    }
    return array;
}

int* choiceSort(int array[], int length) {
    // 第二种,时间复杂度：O(n^2), 空间复杂度O(1)
    int i = 0, j = 0, negative = 0, positive = 0;  // negative：记录负数位置 positive：记录正数位置
    int temp;  // 设置中间变量，作为交换两个元素的中间容器
    for (i = 0; i < length - 1; i++) {  // 遍历数组
        if (array[i] > 0) {  // 如果当前元素为正数
            positive = i;  // 记录当前元素的位置
            for (j = i + 1; j < length; j++) {  // 遍历当前元素的后方元素
                if (array[j] < 0) {  // 发现第一个负数
                    negative = j;  // 记录该负数的位置
                    break;  // 退出内循环
                }
            }
            temp = array[positive];  // 交换两个元素位置
            array[positive] = array[negative];
            array[negative] = temp;
        }
        else {  // 如果当前元素为负数，跳过，进行下一个元素的判断
            continue;
        }
    }
    return array;
}

int* insertionSort(int array[], int length) {
    //第三种,时间复杂度O(n^2), 空间复杂度O(1)
    int i, j;
    int key;
    for (i = 1; i < length; i++) {
        key = array[i];
        j = i - 1;
        while ((j >= 0) && (array[j] > key)) {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = key;
    }
    return array;
}

int main(void) {
    //int testArray[100000];
    int* testArray = (int*)malloc(sizeof(int) * 1000000);  // 开辟连续的空间，开辟空间数取决于测试集的数据数目
    int i = 0, num = 0, lastNeg = 0, firstPos = 0;  // num：首个正数的位置，lastodd：最后一个负数，firstOpt
    double timeStart = 0, timeEnd = 0;  // timeStart：记录起始时间，timeEnd：记录结束时间
    errno_t err;
    FILE* fp;

    // 读取文件
    fp = fopen_s(&fp, "D:\\programming\\cpp_VS_pro\\no1\\100万.txt", "r");  // 打开数据文件，更改为自己的文件路径
    if ((err = fopen_s(&fp, "D:\\programming\\cpp_VS_pro\\no1\\100万.txt", "r")) != 0) {  // 如果文件不存在
        printf("文件不存在!\n");
        return -1;
    }
    while (!feof(fp)) {  // 将文件内容写入数组
        fscanf_s(fp, "%d", &testArray[i]);
        i++;
    }
    fclose(fp);  // 关闭文件

    timeStart = (double)clock() / CLOCKS_PER_SEC;  // 记录算法开始时间

    //调用排序函数，使负数排在正数前面，第二个参数根据数据量自行更改
    bestSort(testArray, 1000000);  // 第一种排序(最佳排序)
    //choiceSort(testArray, 1000000);  // 第二种排序
    //insertionSort(testArray, 1000000);  // 第三种排序

    timeEnd = (double)clock() / CLOCKS_PER_SEC;  // 记录算法结束时间
    
    printf("\n排序后:\n");  // 输出排序后的数组
    for (i = 0; i < 1000000; i++) {  // i小于几需要按照数据长度自行更改
        printf("%-8d", testArray[i]);
        if (testArray[i] < 0 && testArray[i + 1] > 0) {  // 记录首个正数位置，最后一个正数和第一个负数
            num = i + 1;
            lastNeg = testArray[i];
            firstPos = testArray[i + 1];
        }
    }

    // 打印输出
    printf("\n首个正数位置为：%d\n", num);
    printf("最后一个负数为：%d\n", lastNeg);
    printf("首个正数数值为：%d\n", firstPos);
    printf("算法运行时间为：%f\n", (timeEnd - timeStart));
}

注意：使用不同的测试数据，需要更改的地方有：

开辟空间数目
文件路径
调用排序函数时的参数需要与数据量对应
最后循环输出数据时，需要根据数据量修改循环次数

测试用例

链接：https://pan.baidu.com/s/1gK60mMzy59cwKH91HBmz4g?pwd=1wxq
提取码：1wxq

体会

在之前的代码算法学习中，对于时间复杂度相关的内容不以为然，也从没有试过十万百万级数据的测试，经过本次实验中的测试，从结果中可以看出，在处理数据量较小的工作时，不同算法的实际差别通过人的体会并不是很明显，但当数据量上升，算法的优异程度就很明显的可以体会到了，比如一百万数据，优秀的算法很快就执行完毕，但当算法的时间复杂度较高时，比如后两种算法，执行需要数分钟，差异十分明显。