JAVA实现常用排序算法

package com.example.xj.myapplication;

/**
 * 测试算法
 * Created by xj on 2018/4/4.
 */

public class Algorithm {


    public static void main(String[] args) {
        int[] A = new int[]{11, 3, 7, 9, 5, 14};
//        cocktailSort(A);//快速

//        selectionSort(A);//选择

//        insertSort(A);//插入

        quickSort(A, 0, A.length - 1);//快速排序

        for (int i : A) {
            System.out.print(i + ",");
        }
    }

    /**
     * 冒泡排序
     * 平均时间复杂度 ---- O(n^2)
     *
     * @param src
     * @return
     */
    public static void cocktailSort(int[] src) {
        for (int i = 0; i < src.length - 1; i++) {
            for (int j = 0; j < src.length - 1 - i; j++) {
                //每执行一次将最大值放到最后一位
                if (src[j] > src[j + 1]) {
                    swap(src, j, j + 1);
                }
                for (int k = 0; k < src.length; k++) {
                    if (k < src.length - 1) {
                        System.out.print(src[k] + " , ");
                    } else {
                        System.out.print(src[k] + "\n");
                    }
                }
            }
        }//for
    }

    /**
     * 选择排序
     * 平均时间复杂度 ---- O(n^2)
     *
     * @param src
     * @return
     */
    public static void selectionSort(int[] src) {
        for (int i = 0; i < src.length - 1; i++) {
            int min = i;//最小数值下标
            for (int j = i + 1; j < src.length; j++) {
                if (src[min] > src[j]) {
                    min = j;//标记最小下标
                }
            }
            swap(src, i, min);
            for (int k = 0; k < src.length; k++) {
                if (k < src.length - 1) {
                    System.out.print(src[k] + " , ");
                } else {
                    System.out.print(src[k] + "\n");
                }
            }
        }
    }

    /**
     * 插入排序
     * 平均时间复杂度 ---- O(n^2)
     *
     * @param src
     * @return
     */
    public static void insertSort(int[] src) {
        //假设左侧元素均有序
        for (int i = 1; i < src.length; i++) {
            int temp = src[i];//取下一个元素
            int j = i - 1;
            while (j >= 0 && temp < src[j]) {
                src[j + 1] = src[j];//比该元素大的全部往右移
                j--;
            }
            src[j + 1] = temp;//直到发现比该元素小的值

            for (int k = 0; k < src.length; k++) {
                if (k < src.length - 1) {
                    System.out.print(src[k] + " , ");
                } else {
                    System.out.print(src[k] + "\n");
                }
            }
        }
    }

    /**
     * 快速排序
     * 平均时间复杂度 ---- O(nlogn)
     *
     * @param src
     * @return
     */
    public static void quickSort(int[] src, int low, int high) {
        if (low > high) {
            return;
        }

        int i = low;
        int j = high;
        int temp = src[low];//基准位
        while (i < j) {
            while (i < j && src[j] >= temp) {
                j--;//找到第一个比基准小的值，标记
            }
            while (i < j && src[j] <= temp) {
                i++;//找到第一个比基准小的值
            }

            if (i < j) {
                swap(src, i, j);
            }
        }//while
        src[low] = src[i];
        src[i] = temp;

        quickSort(src, low, j - 1);//递归调用对左侧进行排序
        quickSort(src, j + 1, high);//右侧排序
    }


    /**
     * 交换元素
     * @param A
     * @param i
     * @param j
     */
    public static void swap(int[] A, int i, int j) {
        int temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }

}