常见的排序算法的应用场景及java实现方式

1. 冒泡排序（Bubble Sort）

• 原理：通过重复遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
• 优点：实现简单，容易理解。
• 缺点：效率低下，时间复杂度为O(n^2)，不适合大数据量排序。
• 稳定性：稳定。

  public static void bubbleSort(int[] arr) {
      int n = arr.length;
      boolean swapped;
      for (int i = 0; i < n - 1; i++) {
          swapped = false;
          for (int j = 0; j < n - 1 - i; j++) {
              if (arr[j] > arr[j + 1]) {
                  // 交换 arr[j] and arr[j + 1]
                  int temp = arr[j];
                  arr[j] = arr[j + 1];
                  arr[j + 1] = temp;
                  swapped = true;
              }
          }
          if (!swapped) break; // 遍历一轮结束仍然没有交换时，无需继续遍历比较
      }
  }
  

2. 选择排序（Selection Sort）

• 原理：每次从未排序的部分找出最小（或最大）的元素，放到已排序序列的末尾。
• 优点：实现简单，交换次数较少。
• 缺点：比较次数较多，时间复杂度为O(n^2)，不适合大数据量排序。
• 稳定性：不稳定。

  public static void selectionSort(int[] arr) {
      for (int i = 0; i < arr.length - 1; i++) {
          int minIndex = i;
          for (int j = i + 1; j < arr.length; j++) {
              if (arr[j] < arr[minIndex]) {
                  minIndex = j;
              }
          }
          // 交换 arr[i] 和 arr[minIndex]
          int temp = arr[i];
          arr[i] = arr[minIndex];
          arr[minIndex] = temp;
      }
  }
  

3. 插入排序（Insertion Sort）

• 原理：将未排序的数据插入到已排序序列中的适当位置，逐步构建排序数组。
• 优点：实现简单，对于小数据量或部分有序数据效率较高。
• 缺点：时间复杂度为O(n^2)，对于大数据量效率低。
• 稳定性：稳定。

  public static void insertionSort(int[] arr) {
      for (int i = 1; i < arr.length; i++) {
          int key = arr[i];
          int j = i - 1;
          while (j >= 0 && arr[j] > key) {
              arr[j + 1] = arr[j];
              j--;
          }
          arr[j + 1] = key;
      }
  }
  

4. 希尔排序（Shell Sort）

• 原理：是插入排序的一种更高效的改进版本，通过将原始数组按不同的增量分组，对每一组使用插入排序算法排序。
• 优点：比普通的插入排序快得多，可以达到接近O(n^(3/2))的时间复杂度。
• 缺点：增量序列的选择影响效率，稳定性受增量序列影响。
• 稳定性：不稳定。

  public static void shellSort(int[] arr) {
      int n = arr.length;
      for (int gap = n / 2; gap > 0; gap /= 2) {
          for (int i = gap; i < n; i++) {
              int temp = arr[i];
              int j;
              for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                  arr[j] = arr[j - gap];
              }
              arr[j] = temp;
          }
      }
  }
  

5. 归并排序（Merge Sort）

• 原理：使用分治法，将数组分成两半，递归地对两半进行排序，然后将两个已排序的半部分合并在一起。
• 优点：时间复杂度稳定为O(n log n)，适合大数据量排序。
• 缺点：需要额外的空间来存放临时数组，空间复杂度为O(n)。
• 稳定性：稳定。

  public static void mergeSort(int[] arr, int l, int r) {
      if (l < r) {
          int m = l + (r - l) / 2;
          mergeSort(arr, l, m);
          mergeSort(arr, m + 1, r);
          merge(arr, l, m, r);
      }
  }
  
  private static void merge(int[] arr, int l, int m, int r) {
      int n1 = m - l + 1;
      int n2 = r - m;
  
      int[] L = Arrays.copyOfRange(arr, l, m + 1);
      int[] R = Arrays.copyOfRange(arr, m + 1, r + 1);
  
      int i = 0, j = 0;
      int k = l;
      while (i < n1 && j < n2) {
          if (L[i] <= R[j]) {
              arr[k] = L[i];
              i++;
          } else {
              arr[k] = R[j];
              j++;
          }
          k++;
      }
  
      while (i < n1) {
          arr[k] = L[i];
          i++;
          k++;
      }
  
      while (j < n2) {
          arr[k] = R[j];
          j++;
          k++;
      }
  }
  

6. 快速排序（Quick Sort）

• 原理：同样采用分治法，选择一个“基准”元素，将数组分为小于基准和大于基准的两部分，然后递归地对这两部分进行排序。
• 优点：平均时间复杂度为O(n log n)，在实际应用中效率很高。
• 缺点：最坏情况下退化为O(n^2)，且递归深度较大时可能导致栈溢出。
• 稳定性：不稳定。

  public static void quickSort(int[] arr, int low, int high) {
      if (low < high) {
          int pi = partition(arr, low, high);
          quickSort(arr, low, pi - 1);
          quickSort(arr, pi + 1, high);
      }
  }
  
  private static int partition(int[] arr, int low, int high) {
      int pivot = arr[high];
      int i = low - 1;
      for (int j = low; j < high; j++) {
          if (arr[j] < pivot) {
              i++;
              // 交换arr[i]和arr[j]
              int temp = arr[i];
              arr[i] = arr[j];
              arr[j] = temp;
          }
      }
      // 交换arr[i+1]和arr[high]
      int temp = arr[i + 1];
      arr[i + 1] = arr[high];
      arr[high] = temp;
      return i + 1;
  }
  

7. 堆排序（Heap Sort）

• 原理：首先构建一个最大堆或最小堆，然后逐步移除堆顶元素并重新调整堆，以达到排序效果。
• 优点：时间复杂度为O(n log n)，不需要额外的存储空间。
• 缺点：稳定性较差，且实现相对复杂。
• 稳定性：不稳定。

  public static void heapSort(int[] arr) {
      int n = arr.length;
  
      for (int i = n / 2 - 1; i >= 0; i--) {
          heapify(arr, n, i);
      }
  
      for (int i = n - 1; i > 0; i--) {
          // 设置
          int temp = arr[0];
          arr[0] = arr[i];
          arr[i] = temp;
  
          heapify(arr, i, 0);
      }
  }
  
  private static void heapify(int[] arr, int n, int i) {
      int largest = i; 
      int left = 2 * i + 1; // left = 2*i + 1
      int right = 2 * i + 2; // right = 2*i + 2
  
      if (left < n && arr[left] > arr[largest]) {
          largest = left;
      }
  
      if (right < n && arr[right] > arr[largest]) {
          largest = right;
      }
  
      if (largest != i) {
          int swap = arr[i];
          arr[i] = arr[largest];
          arr[largest] = swap;
  
          heapify(arr, n, largest);
      }
  }
  

8. 计数排序（Counting Sort）

• 原理：适用于一定范围内的整数排序，通过统计每个数值出现的次数来排序。
• 优点：时间复杂度为O(n+k)，对于数据范围较小的情况非常高效。
• 缺点：只适用于整数排序，且数据范围受限。
• 稳定性：稳定。

  public static void countingSort(int[] arr) {
      int max = Arrays.stream(arr).max().getAsInt();
      int[] count = new int[max + 1];
      for (int num : arr) {
          count[num]++;
      }
      int index = 0;
      for (int i = 0; i < count.length; i++) {
          while (count[i] > 0) {
              arr[index++] = i;
              count[i]--;
          }
      }
  }
  

选择排序算法时，应考虑数据的特性、数据量的大小、对时间效率和空间效率的要求，以及是否需要稳定排序等因素。