几个常见的排序算法

package com.rails;

import java.util.Arrays;

/**
 * @author: noob
 * @description : 冒泡排序 选择排序 插入排序（和冒泡排序有点像） 快速排序 基数排序
 * @Date : 17:36 2018/04/19
 */

public class sort {
    public static void main(String[] args) {
        Integer[] s = {1, 6, 4, 34, 32, 45, 43, 26, 17};
        s = CockTailSort(s);
        System.out.print(Arrays.toString(s));
    }

    /// <summary>
    /// 鸡尾酒排序
    static Integer[] CockTailSort(Integer[] list) {
        //判断是否已经排序了
        Boolean isSorted = false;
        //因为是双向比较，所以比较次数为原来数组的1/2次即可。
        for (Integer i = 1; i <= list.length / 2; i++) {
            //从前到后的排序 (升序)
            /**冒泡排序的活动空间由一边向另一边主键缩小，此处的活动返回由两边向中间缩小*/
            for (Integer m = i - 1; m < list.length - i; m++) {
                //如果前面大于后面，则进行交换
                if (list[m] > list[m + 1]) {
                    Integer temp = list[m];
                    list[m] = list[m + 1];
                    list[m + 1] = temp;
                    isSorted = true;
                }
            }
            //从后到前的排序（降序）
            for (Integer n = list.length - i - 1; n > i; n--) {
                //如果前面大于后面，则进行交换
                if (list[n - 1] > list[n]) {
                    Integer temp = list[n];
                    list[n] = list[n - 1];
                    list[n - 1] = temp;
                    isSorted = true;
                }
            }
            //当不再有排序，提前退出
            if (!isSorted)
                System.out.println(Arrays.toString(list));
            break;
        }
        return list;
    }

    public static Integer[] insert_sort(Integer array[]) {
        Integer temp;
        for (Integer i = 0; i < array.length - 1; i++) {
            for (Integer j = i + 1; j > 0; j--) {
                if (array[j] < array[j - 1]) {
                    temp = array[j - 1];
                    array[j - 1] = array[j];
                    array[j] = temp;
                } else {
                    break;
                }
            }
        }
        return array;
    }

    /**
     * 二
     * 选择排序。
     */
    public static Integer[] select_sort(Integer array[], Integer lenth) {
        for (Integer i = 0; i < lenth - 1; i++) {
            Integer minIndex = i;
            for (Integer j = i + 1; j < lenth; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                Integer temp = array[i];
                array[i] = array[minIndex];
                array[minIndex] = temp;
            }
        }
        return array;
    }

    /**
     * 选择排序改进
     */
    public static Integer[] Bselect_sort(Integer array[]) {
        for (Integer i = 0; i < array.length - 1; i++) {
            Integer temp = array[i];
            for (Integer j = i + 1; j < array.length; j++) {
                if (array[j] < temp) {
                    array[i] = array[j];
                    array[j] = temp;
                    temp = array[i];
                }
            }
        }
        return array;
    }

    /**
     * 一、
     * 冒泡排序  两两比较 循环n次进行数组排序
     * 优化：设置标志位判断数据是否已经排序完成。
     */
    public static Integer[] BubbleSort(Integer[] arr) {
        Integer temp;//临时变量
        boolean flag = true;
        for (Integer i = 0; i < arr.length - 1; i++) {   //表示趟数，一共arr.length-1次。
            flag = true;
            for (Integer j = arr.length - 1; j > i; j--) {//此处使用j>i 因为第一次冒泡已经找到最小的数，并且控制不会数组越界
                if (arr[j] < arr[j - 1]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                    flag = false;
                }
                if (flag) {
                    break;
                }
            }
        }
        return arr;
    }

    /**
     * 改造冒泡排序
     */
    public static Integer[] SBubbleSort(Integer[] arr) {
        Integer temp;//临时变量
        for (Integer i = 0; i < arr.length - 1; i++) {   //表示趟数，一共arr.length-1次。
            for (Integer j = 0; j < arr.length - i - 1; j++) {//
                if (i == 0) {
                    System.out.println(j);
                }
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }

    /**
     * 插入排序 将需要排序的数据一个个测插入到新的数组中
     */
    static Integer[] sier_sort(Integer[] unsorted) {
        Integer[] temp = new Integer[unsorted.length];
        temp[0] = unsorted[0];//将第一个数据直接复制到新数组
        /**控制第一个循环，从1开始,循环提取数据*/
        for (Integer a = 1; a < unsorted.length; a++) {
            /**将原数组中提取的数据循环 和新数组的数据比较 直到遇到比他大的数，将数据插入到新数组*/
            for (Integer v = 0; v < temp.length; v++) {
                if (temp[v] != null && unsorted[a] < temp[v]) {
                    temp = insertArray(temp, v, unsorted[a]);
                    break;
                } else if (temp[v] == null) {
                    temp = insertArray(temp, v, unsorted[a]);
                    break;
                }
            }

        }
        return temp;
    }

    /**
     * 希尔排序使用 将一个数插入到原数组的指定位置并且返回新的数组
     */
    static Integer[] insertArray(Integer[] begin, Integer index, Integer num) {
        Integer[] end = new Integer[begin.length];
        if (begin.length - 1 >= index) {
            for (Integer i = 0; i < end.length; i++)
                if (i < index) {
                    end[i] = begin[i];
                } else if (i == index) {
                    end[index] = num;
                } else {
                    end[i] = begin[i - 1];
                }
        }
        return end;
    }

    /**
     * 地精排序
     */
    static Integer[] gnome_sort(Integer[] unsorted) {
        Integer i = 0;
        while (i < unsorted.length - 1) {
            if (unsorted[i] <= unsorted[i + 1]) {
                i++;
            } else {
                Integer tmp = unsorted[i];
                unsorted[i] = unsorted[i + 1];
                unsorted[i + 1] = tmp;
                i--;
            }
        }
        return unsorted;
    }

}