数据结构算法 - 冒泡选择和插入排序

Posted 程序员大咖

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据结构算法 - 冒泡选择和插入排序相关的知识,希望对你有一定的参考价值。


作者红橙Darren
https://www.jianshu.com/p/a19094fc6586


排序算法我们一般可以从以下几个方面入手:


1.手写排序算法;

2.时间复杂度,空间复杂度,排序的稳定性;

3.能够了解各大排序算法的优劣,能根据具体的场景选择合适的算法;

4.能够优化排序算法。


数据结构算法 - 冒泡、选择和插入排序

冒泡排序


冒泡排序的思想:重复地遍历要排序的列表,比较每一对相邻项,如果它们的顺序不对,就交换它们。重复遍历列表,直到不需要交换。


数据结构算法 - 冒泡、选择和插入排序


template<typename T>
void bubbleSort(T arr[], int len) {
    for (int i = 0; i < len - 1; ++i) {
        for (int j = 0; j < len - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
            }
        }
    }
}


时间复杂度:两个 for 循环嵌套,执行的次数是 n-1+n-2+n-3+...+1 。转换一下是 1+2+3+4+...+n-1, 这便是初中数学的等差数列求和即 n²/2-n/2 。因此冒泡排序的时间复杂度是O(n²)级别的。


数据结构算法 - 冒泡、选择和插入排序

选择排序


选择排序的思想:重复地遍历要排序的列表,比较每一对相邻项,记录最小位置的角标,每循环一次后与最小位置进行交换。重复遍历列表,直到不需要交换。


 
  
    
    
  

void selectSort(int arr[], int len) {
    for (int i = 0; i < len - 1; ++i) {
        int min = i;
        for (int j = i + 1; j < len; ++j) {
            if (arr[min] > arr[j]) {
                min = j;
            }
        }
        std::swap(arr[i], arr[min]);
    }
}


时间复杂度与冒泡排序的求法一致都是 O(n²) 级别的,但我们不妨来测试一下执行时间,假设对 20000 数据进行排序,我们分别来看下冒泡和选择所花费时间。


  
    
    
  

// 随机创建一个数组
    int *create_array(int lenint low, int high) {
        int *arr = new int[len];

        for (int i = 0; i < len; ++i) {
            arr[i] = rand() % (high-low) + low;
        }

        return arr;
    }

    // copy 一份数组
    int *copy_array(int *arr, int len) {
        int *copy_arr = (int *) malloc(sizeof(int) * len);
        memcpy(copy_arr, arr, sizeof(int) * len);
        return copy_arr;
    }

    // 创建接一组近有序的数组
    int *create_nearly_ordered_array(int lenint swapNums) {
        int *arr = new int[len];

        for (int i = 0; i < len; ++i) {
            arr[i] = i;
        }

        for (int i = 0; i < swapNums; ++i) {
            int randomX = rand() % (len - 1);
            int randomY = rand() % (len - 1);
            std::swap(arr[randomX], arr[randomY]);
        }

        return arr;
    }

    // 利用函数指针来对数组排序,并打印排序时间
    void sort_array(char *sortName, void(*sort)(int *, int), int *arr, int len) {
        clock_t start = clock();
        sort(arr, len);
        clock_t end = clock();
        LOGE("%s执行时间:%lf", sortName, static_cast<double>(end - start) / CLOCKS_PER_SEC * 1000);

        for (int i = 1; i < len; ++i) {
            assert(arr[i] >= arr[i - 1]);
    }

            

对 20000 条随机数据进行排序,检测结果冒泡排序消耗 4.434036s 选择排序消耗 2.381274s ,对 20000 条接近有序的数据进行排序,检测结果冒泡排序消耗 2.282863s 选择排序消耗 2.379822s 。


为什么会这样我相信我们心里都有了答案,因此基于这个测试,我们便可以去优化我们的排序算法了,从两个方面入手,减少我们循环次数或者减少交换次数。这篇文章主要是分析排序算法,所以这里先不介绍优化。


数据结构算法 - 冒泡、选择和插入排序

插入排序


插入排序的思想:插入排序是在一个已经有序的小序列的基础上,一次插入一个元素。比较是从有序序列的末尾开始,也就是想要插入的元素和已经有序的最大者开始比起,如果比它大则直接插入在其后面,否则一直往前找直到找到它该插入的位置。


数据结构算法 - 冒泡、选择和插入排序


 
  
    
    
  

void insertSort(int arr[], int len) {
    int j;
    for (int i = 1; i < len; ++i) {
        int temp = arr[i];
        for (j = i; j > 0 && temp < arr[j - 1]; --j) {
            arr[j] = arr[j - 1];
        }
        arr[j] = temp;
    }
}


对 20000 条随机数据进行排序,检测结果冒泡排序消耗 4.434036s ,选择排序消耗 2.381274s ,插入排序消耗 2.054081s 。对 20000 条接近有序的数据进行排序,检测结果冒泡排序消耗 2.282863s ,选择排序消耗 2.379822s ,插入排序消耗 0.006815s 。我们可以看到对于一个接近有序的序列,插入排序所消耗的时间远远要低于其他排序算法,那是因为对于一个接近有序的数据,插入排序的时间复杂度最优可达 O(n) 级别。


 推荐↓↓↓ 

以上是关于数据结构算法 - 冒泡选择和插入排序的主要内容,如果未能解决你的问题,请参考以下文章

python 数据结构与算法之排序(冒泡,选择,插入)

Java数据结构和算法——冒泡选择插入排序算法

JavaScript算法(冒泡排序选择排序与插入排序)

Java数据结构和算法——冒泡选择插入排序算法

在路上---学习篇Python 数据结构和算法 -- 冒泡排序选择排序插入排序

数据结构算法 - 冒泡选择和插入排序