手撕排序算法(上)

排序算法(上)

算法指标

• 时间复杂度
• 空间复杂度(是否是原地排序)
• 算法的稳定性

仅仅用执行效率和内存消耗来衡量排序算法的好坏是不够的。针对排序算法，我们还有一个重要的度量指标，稳定性。这个概念是说，如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变。

冒泡排序

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。

我用一个例子，带你看下冒泡排序的整个过程。我们要对一组数据 4，5，6，3，2，1，从小到大进行排序。第一次冒泡操作的详细过程就是这样：

这时候分析一下冒泡排序算法

冒泡排序是原地排序吗

是的，没有借助额外的空间，所以空间复杂度是0(1),是原地排序算法

冒泡排序是稳定的排序算法吗

只要遇到相同的不进行交换那么就能保证元素顺序的一致性，所以是稳定的排序算法

冒泡排序算法的时间复杂度度

• 最好的情况

原本顺序就是有序的，都要遍历一遍不进行交换0(n)

• 最坏的情况

原本是倒叙的，那么就要遍历n次里面也要交换n次时间复杂度是0(n*n)

算法实现

#include <iostream>
#include <vector>

void BubbleSort(std::vector<int>& data) {
  if (data.size() <= 1) {
    return;
  }

  for (int i = 0; i < data.size(); i++) {
    bool flag = false;  // 判断是否有交换
    for (int j = 0; j < data.size() - i - 1; j++) {
      if (data[j] > data[j + 1]) {
        int tmp = data[j];
        data[j] = data[j + 1];
        data[j + 1] = tmp;
        flag = true;
      }
    }
    if (!flag) {
      return;
    }
  }
}

int main() {
  std::vector<int> data = {2, 5, 36, 14, 38, 7, 5, 1, 2, 14};
  BubbleSort(data);
  for (auto value : data) {
    std::cout << value << " ";
  }
  std::cout << std::endl;
}

插入排序

首先，我们将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。插入算法的核心思想是取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。

如图所示，要排序的数据是 4，5，6，1，3，2，其中左侧为已排序区间，右侧是未排序区间。

这里涉及到两个操作，一个是元素的比较，一个是元素的移动

插入排序是原地排序算法吗

是的，没有借助额外的空间，所以空间复杂度是0(1),是原地排序算法

插入排序是稳定的排序算法吗

只要遇到相同的插入到相同元素的后面就能保证元素顺序的一致性，所以是稳定的排序算法

插入排序算法的时间复杂度度

• 最好的情况

原本顺序就是有序的，都要遍历一遍不进行交换0(n)

• 最坏的情况

原本是倒叙的，那么就要遍历n次里面也要移动n次时间复杂度是0(n*n)

算法实现

#include <iostream>
#include <vector>

void InsertionSort(std::vector<int>& data) {
  if (data.size() <= 1) {
    return;
  }

  for (int i = 1; i < data.size(); i++) {
    // 开始选择插入的位置
    int index = i - 1;
    for (int j = index; j >= 0; j--) {
      if (data[j+1] < data[j]) {
        // 交换
        int tmp = data[j + 1];
        data[j+1] = data[j];
        data[j] = tmp;
      }
    }
  }
}

int main() {
  std::vector<int> data = {2, 5, 36, 14, 38, 7, 5, 1, 2, 14};
  InsertionSort(data);
  for (auto value : data) {
    std::cout << value << " ";
  }
  std::cout << std::endl;
}

选择排序

选择排序算法的实现思路有点类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。

选择排序是原地排序算法吗

是的，没有借助额外的空间，所以空间复杂度是0(1),是原地排序算法

选择排序是稳定的排序算法吗

选择排序没有办法保证一致性，所以是不稳定的排序算法

选择排序算法的时间复杂度度

• 最好的情况

原本顺序就是有序的，都要遍历一遍不进行交换0(n)

• 最坏的情况

原本是倒叙的，那么就要遍历n次里面也要移动n次时间复杂度是0(n*n)

算法实现

#include <iostream>
#include <vector>

void ChooseSort(std::vector<int>& data) {
  if (data.size() <= 1) {
    return;
  }

  for (int i = 0; i < data.size(); i++) {
    int min_index = -1;
    int minvalue = INT16_MAX;

    for (int j = i; j < data.size(); j++) {
      if (data[j] < minvalue) {
        min_index = j;
        minvalue = data[j];
      }
    }
    // 交换

    if (min_index != -1) {
      int tmp = data[i];
      data[i] = data[min_index];
      data[min_index] = tmp;
    }
  }
}

int main() {
  std::vector<int> data = {2, 5, 36, 14, 38, 7, 5, 1, 2, 14};
  ChooseSort(data);
  for (auto value : data) {
    std::cout << value << " ";
  }
  std::cout << std::endl;
}

总结