排序算法

Posted 2021-01-07 weijuanran

java实现快速排序、插入排序、选择排序

  1 package com.java;
  2 import java.util.Arrays;
  3 
  4 public class Sort {
  5     public static void main(String[] args) {
  6         int[] array = {15, 5, 3, 9, 4, 82, 35, 45, 7, 11};
  7         System.out.print("排序前的数组：");
  8         System.out.println(Arrays.toString(array));
  9 
 10         quickSort(array,0,array.length-1);
 11         //InsertSort(array);
 12         //SelectSort(array);
 13         System.out.print("排序后的数组：");
 14         System.out.println(Arrays.toString(array));
 15     }
 16 
 17     /**
 18      * 快速排序基本原理：（以升序为例）
 19      * 1、首先在数组中选择一个基准点（一般选取数组中的第一个元素），
 20      * 2、然后分别从数组的两端扫描数组，设两个指示标志（low指向起始位置，high指向末尾)，
 21      * 首先从后半部分开始，如果发现有元素比该基准点的值小，就交换low和high位置的值，
 22      * 然后从前半部分开始扫秒，发现有元素大于基准点的值，就交换low和high位置的值，如此往复循环，直到low>=high,
 23      * 然后把基准点的值放到high这个位置。这样一次排序就完成了，此时左分区的值都小于基准点，右分区的值都大于基准点。
 24      * 3、然后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组排序完成。
 25      *
 26      * 平均时间复杂度为O(n*logn)
 27      */
 28     public static void quickSort(int[] arr, int low, int high) {
 29         if (arr == null || low > high) {
 30             return;
 31         }
 32         int p = partition(arr, low, high);
 33         quickSort(arr, low, p - 1);
 34         quickSort(arr, p + 1, high);
 35     }
 36     public static int partition(int[] arr, int low, int high) {
 37         int key = arr[low];
 38         while (low < high) {
 39             while (arr[high] >= key && low < high) {
 40                 high--;
 41             }
 42             arr[low] = arr[high];
 43             while (arr[low] <= key && low < high) {
 44                 low++;
 45             }
 46             arr[high] = arr[low];
 47         }
 48         arr[high] = key;
 49         return high;
 50     }
 51 
 52     /**
 53      * 选择排序基本原理：（以升序为例）
 54      * 1、从第一个元素开始，分别与后面的元素相比较，找到最小的元素与第一个元素交换位置；
 55      * 2、从第二个元素开始，分别与后面的元素相比较，找到剩余元素中最小的元素，与第二个元素交换；
 56      * 3、重复上述步骤，直到所有的元素都排成由小到大为止。
 57      * 时间复杂度为O(n*n)
 58      */
 59     public static void SelectSort(int[] a) {
 60         if (a == null || a.length <= 0) {
 61             return;
 62         }
 63         for (int i = 0; i < a.length - 1; i++) {
 64             int min = i; /* 将当前下标定义为最小值下标 */
 65 
 66             for (int j = i + 1; j < a.length; j++) {
 67                 if (a[min] > a[j]) { /* 如果有小于当前最小值的关键字 */
 68                     min = j; /* 将此关键字的下标赋值给min */
 69                 }
 70             }
 71             if (i != min) {/* 若min不等于i，说明找到最小值，交换 */
 72                 int tmp = a[min];
 73                 a[min] = a[i];
 74                 a[i] = tmp;
 75             }
 76         }
 77     }
 78 
 79     /**
 80      * 插入排序基本原理：（以升序为例）
 81      * 1、从第一个元素开始，该元素可以认为已经被排序。
 82      * 2、取出下一个元素，在已经排序的元素序列中从后向前扫描。
 83      * 3、如果该元素（已排序）大于新元素，则将该元素移到下一位置。
 84      * 4、重复步骤3，直到找到已排序的元素小于新元素的位置。
 85      * 5、将新元素插入到该位置。
 86      * 6、重复步骤2。
 87      *
 88      * 时间复杂度为O(n*n)
 89      */
 90     public static void InsertSort(int[] arr) {
 91         if (arr == null || arr.length <= 0) {
 92             return;
 93         }
 94         int temp, i, j;
 95         for (i = 1; i < arr.length; i++) {
 96             temp = arr[i];
 97             for (j = i; j > 0 && arr[j - 1] > temp; j--) {
 98                 arr[j] = arr[j - 1];
 99             }
100             arr[j] = temp;
101         }
102     }
103 }