常用排序算法Notes-----------JAVA实现

常用排序算法—插入排序，选择排序，交换排序，归并排序，基数排序

排序算法可归类为以下几类：

1. 插入排序：
   直接插入排序（DirectInsertSort）；
   二分法排序（BinarySort）；
   希尔排序（ShellSort）；
2. 选择排序：
   直接选择排序（SelectSort）；
   堆排序（HeapSort）；
3. 交换排序：
   冒泡排序（bubbleSort）；
   快速排序（QuickSort）；
4. 归并排序（MergeSort）；
5. 基数排序（radixSort）；

现在来看看这些算法的基本思想和具体实现方法：

import java.util.ArrayList;
import java.util.List;

public class MyAlroithmTest {
    public static void main(String[] args) {
        int[] a = {2, 5, 7, 9, 11, 587, 96311, 3, 55, 43, 21};
        System.out.println("Before Sort the Array is:");
        for (int arr : a
                ) {
            System.out.print(arr + " ");
        }
        System.out.println();

//        DericetInsertSort(a);
//        BinarySort(a);
//        shellSort(a);
//        selectSort(a);
//        bubbleSort(a);
//        QuickSort(a);
        radixSort(a);

        System.out.println("After Sort the Array is:");
        for (int arr : a
                ) {
            System.out.print(arr + " ");
        }
    }

//    InsertSort

    /**
     * DericetInsertSort
     * 思想：    每一趟将待排序元素，按照顺序码大小插入到已排好序的元素序列中
     *
     * @param arr 需要进行排序的数组
     */
    public static void DericetInsertSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int temp = arr[i];
            int j;
            for (j = i - 1; j >= 0; j--) {
                if (arr[j] > temp) {                    // 如果 “arr[j+1] < temp”则排序记录为降序
                    arr[j + 1] = arr[j];
                } else {
                    break;
                }
            }
            arr[j + 1] = temp;
        }
    }

    /**
     * 二分法排序（折半排序）BinarySort
     * 思想:  每趟将待排记录与已排好序序列中的中间数进行比较，
     * 大于中间数则在右边继续找，小于则在左边继续找，直到找到正确位置。
     * 

     * Notes: ------->    外层循环为每一趟找位置，内层循环做交换；
     * 再判断  lo != i ,就 arr[lo] = temp;
     *
     * @param arr 待排序数组
     */
    public static void BinarySort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int lo = 0;
            int hi = i - 1;
            int temp = arr[i];
            int j;
            //    find position
            while (lo <= hi) {
                int mid = (lo + hi) / 2;
                if (arr[mid] < temp) {
                    lo = mid + 1;
                } else {
                    hi = mid - 1;
                }
            }
            for (j = i - 1; j >= lo; j--) {
//                exchange position
                arr[j + 1] = arr[j];
            }
            if (lo != i) {
                arr[lo] = temp;
            }
        }
    }

    /**
     * 希尔排序shellSort：
     * 思想：是直接插入排序的改进版。进行增量式间隔分组排序；
     * 先取一个小于n的整数h1作为第一个增量，把待排记录分成h1个组。所有距离为h1的倍数的记录放在同一个组中。
     * 在各组内先进行直接插入排序；然后取第二个增量h2进行再次排序；直到全部记录排序完成。
     *
     * @param arr
     */
    public static void shellSort(int[] arr) {
        int h = 1;
        while (h <= arr.length / 3) {
            h = h * 3 - 1;
        }
        while (h > 0) {
            for (int i = h; i < arr.length; i += h) {
                int temp = arr[i];
                int j;
                for (j = i - h; j >= 0; j -= h) {
                    if (arr[j] > temp) {
                        arr[j + h] = arr[j];
                    } else {
                        break;
                    }
                }
                arr[j + h] = temp;
            }
            h = (h - 1) / 3;
        }
    }

//    SelectSort

    /**
     * 直接选择排序
     * 思想：第i趟排序选出数组元素中第i小的数，放到第i个位置上
     *
     * @param arr 待排序数组
     */
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int min = arr[i];
            int n = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < min) {
                    min = arr[j];
                    n = j;
                }
            }
            arr[n] = arr[i];            // 把原本第i个位置上面的数放去本趟最小数的位置
            arr[i] = min;               // 把本趟最小数min  放去第i个位置
        }
    }

//    Exchange Sort

    /**
     * 冒泡排序（bubbleSort）
     * 思想：每一趟 将相邻两个数做比较，把大的数往下沉（往后移），小的数往上浮（往前移）--->  [即相邻数之间做交换]；
     * 一共进行arr.length-1-i趟，  多减一个i  是因为之前已经将大数往后移了，无需重复再比较一次；
     *
     * @param arr 待排序数组
     */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
    }

    /**
     * 快速排序（QuickSort）
     * 思想： 选一个基准数（一般是待排序列的第一个or最后一个），
     * 每趟排序中，将其他数与这个基准数相比较，小的放左边，大的放右边； 然后再递归的进行排序，直到序列全部有序。
     *
     * @param arr 待排序列
     */
    public static void QuickSort(int[] arr) {
        if (arr.length > 0) {
            qSort(arr, 0, arr.length - 1);
        }
    }

    public static void qSort(int[] arr, int lo, int hi) {
        if (lo < hi) {          // 不加这个判断，递归无法退出，会导致堆栈溢出异常
            int Q = getQ(arr, lo, hi);
            qSort(arr, 0, Q);
            qSort(arr, Q + 1, hi);
        }
    }

    public static int getQ(int[] arr, int lo, int hi) {
        int temp = arr[lo];             //  基准元素

        while (lo < hi) {
            //从后往前找，找到比基准元素小的数，放到当前基准元素的位置上
            while (lo < hi && arr[hi] >= temp) {
                hi--;
            }
            arr[lo] = arr[hi];
            // 再从前开始找，找到比基准元素大的元素，放到上一个移动的数的位置上面去
            while (lo < hi && arr[lo] <= temp) {
                lo++;
            }
            arr[hi] = arr[lo];
        }
        arr[lo] = temp;         // 将之前用临时数保存的基准数，放去现在的lo指针所指位置
        return lo;
    }


//    基数排序

    /**
     * 基数排序（radixSort）
     * 基本思想：
     *
     * @param arr 待排序序列
     */
    public static void radixSort(int[] arr) {
        //  首先找到序列中的最大数
        int max = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        // 获取最大数的位数
        int times = 0;
        while (max > 0) {
            max = max / 10;
            times++;
        }
        //建立一个共10行的二维list，其中每行（1个list）分别用于装包含从0-9共十个数字的元素
        List list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            ArrayList list1 = new ArrayList();
            list.add(list1);
        }
        // 进行times次分配和收集
        for (int i = 0; i < times; i++) {
            //  分配
            for (int j=0;jint x = arr[j] % (int)Math.pow(10,i+1)/(int)Math.pow(10,i);
                ArrayList list2 = list.get(x);
                list2.add(arr[j]);
                list.set(x,list2);
            }
            // 收集
            int num=0;
            for (int j=0;j<10;j++){
                while (list.get(j).size()>0){
                    ArrayList list3 = list.get(j);
                    arr[num] = list3.get(0);
                    list3.remove(0);
                    num++;
                }
            }
        }
    }

}