12.27排序算法

冒泡排序：遍历数组元素，每次将最小或最大的元素与后一位交换，直到当前元素到达数组末端。循环数组长度减一

public class Sort {

    public static void main(String[] args) {
        int[] lis = new int[]{2,667,3,-3,-9,-1,};
        int[] sor = Sort.sor(lis);
        for (int i : sor){
            System.out.println(i);
        }
    }
    public static int[] sor(int[] l){
        int temp = 0;
        for (int i = 0; i < l.length; i++) {
            for (int j = 0 ; j < l.length - 1 - i ; j++){
                if (l[j] > l[j+1]){
                    temp = l[j];
                    l[j] = l[j+1];
                    l[j+1] = temp;
                }
            }
        }
        return l;
    }
}

选择排序：每次找到最大或者最小的元素，将此元素方法数组最前面，下一次继续，注意不用判断已添加元素（因为他已经是除前一个元素最大的了）。

public class test {
    public static void main(String[] args) {
        int[] li = new int[]{28,44,214,3546,75,2,32};
        test test = new test();
        int[] ints = test.selectSort(li);
        for (int i:ints){
            System.out.println(i);
        }
    }
    public int[] selectSort(int[] list){
        for (int j = 0; j < list.length-1; j++) {
            int minIndex = j;
            int min = list[j];
            for (int i = j; i < list.length; i++) {
                if (min > list[i]) {
                    minIndex = i;
                    min = list[i];
                }
            }
            if (minIndex != j){
                list[minIndex] = list[j];
                list[j] = min;
            }
        }
        return list;
    }
}

希尔排序（交换法）：
思路：将排序列表分组，直到不能分组为止。
除外层循环需要两个循环。需要注意分组元素向后移动时，分组前面所有元素都需要判断。

import java.util.Arrays;

public class Xier {
    public static void main(String[] args) {
        int[] list = new int[]{8,9,1,7,2,3,5,4,6,0};
        Xier xier = new Xier();
        int[] ints = xier.shellSort(list);
        System.out.println(Arrays.toString(ints));
    }
    public int[] shellSort(int[] list){
        //将数组分组，直到0为止
        for (int m = list.length/2; m > 0; m/=2) {
            //找到分组后面部分的元素，跟据分组步进找到，比如分为五组，步进为五。分组因为除以二所以第一次元素个数为二。
            // 内层的循环每次只会执行一次。当分组组数不同时，内层循环生效，会依次遍历同一组所有元素
            for (int i = m; i < list.length; i++){
                //遍历分组中所有的元素
                for (int j = i-m; j >= 0; j-=m) {
                    //判断组中元素大小
                    if (list[j+m] < list[j]){
                        //开始交换位置
                        int temp = list[j+m];
                        list[j+m] = list[j];
                        list[j] = temp;
                    }
                }
            }
        }
        System.out.println("第一次" + Arrays.toString(list));
        return null;
    }
}

2希尔排序（）