排序算法

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

package com.java;
import java.util.Arrays;

public class Sort {
    public static void main(String[] args) {
        int[] array = {15, 5, 3, 9, 4, 82, 35, 45, 7, 11};
        System.out.print("排序前的数组：");
        System.out.println(Arrays.toString(array));

        quickSort(array,0,array.length-1);
        //InsertSort(array);
        //SelectSort(array);
        System.out.print("排序后的数组：");
        System.out.println(Arrays.toString(array));
    }

    /**
     * 快速排序基本原理：（以升序为例）
     * 1、首先在数组中选择一个基准点（一般选取数组中的第一个元素），
     * 2、然后分别从数组的两端扫描数组，设两个指示标志（low指向起始位置，high指向末尾)，
     * 首先从后半部分开始，如果发现有元素比该基准点的值小，就交换low和high位置的值，
     * 然后从前半部分开始扫秒，发现有元素大于基准点的值，就交换low和high位置的值，如此往复循环，直到low>=high,
     * 然后把基准点的值放到high这个位置。这样一次排序就完成了，此时左分区的值都小于基准点，右分区的值都大于基准点。
     * 3、然后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组排序完成。
     *
     * 平均时间复杂度为O(n*logn)
     */
    public static void quickSort(int[] arr, int low, int high) {
        if (arr == null || low > high) {
            return;
        }
        int p = partition(arr, low, high);
        quickSort(arr, low, p - 1);
        quickSort(arr, p + 1, high);
    }
    public static int partition(int[] arr, int low, int high) {
        int key = arr[low];
        while (low < high) {
            while (arr[high] >= key && low < high) {
                high--;
            }
            arr[low] = arr[high];
            while (arr[low] <= key && low < high) {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[high] = key;
        return high;
    }

    /**
     * 选择排序基本原理：（以升序为例）
     * 1、从第一个元素开始，分别与后面的元素相比较，找到最小的元素与第一个元素交换位置；
     * 2、从第二个元素开始，分别与后面的元素相比较，找到剩余元素中最小的元素，与第二个元素交换；
     * 3、重复上述步骤，直到所有的元素都排成由小到大为止。
     * 时间复杂度为O(n*n)
     */
    public static void SelectSort(int[] a) {
        if (a == null || a.length <= 0) {
            return;
        }
        for (int i = 0; i < a.length - 1; i++) {
            int min = i; /* 将当前下标定义为最小值下标 */

            for (int j = i + 1; j < a.length; j++) {
                if (a[min] > a[j]) { /* 如果有小于当前最小值的关键字 */
                    min = j; /* 将此关键字的下标赋值给min */
                }
            }
            if (i != min) {/* 若min不等于i，说明找到最小值，交换 */
                int tmp = a[min];
                a[min] = a[i];
                a[i] = tmp;
            }
        }
    }

    /**
     * 插入排序基本原理：（以升序为例）
     * 1、从第一个元素开始，该元素可以认为已经被排序。
     * 2、取出下一个元素，在已经排序的元素序列中从后向前扫描。
     * 3、如果该元素（已排序）大于新元素，则将该元素移到下一位置。
     * 4、重复步骤3，直到找到已排序的元素小于新元素的位置。
     * 5、将新元素插入到该位置。
     * 6、重复步骤2。
     *
     * 时间复杂度为O(n*n)
     */
    public static void InsertSort(int[] arr) {
        if (arr == null || arr.length <= 0) {
            return;
        }
        int temp, i, j;
        for (i = 1; i < arr.length; i++) {
            temp = arr[i];
            for (j = i; j > 0 && arr[j - 1] > temp; j--) {
                arr[j] = arr[j - 1];
            }
            arr[j] = temp;
        }
    }
}