排序算法

冒泡排序

用[2,8,6,1]做例子
2和8作比较，左小又大，下一个循环；
8和6作比较，左大右小，替换值后的数组[2,6,8,1]
8和1做比较，左大右小，替换值后的数组[2,6,1,8]
依次循环

	public static void majorityElement(int[] arr){
        for(int i = 0;i<arr.length;i++){
            for(int z=0;z<arr.length-i-1;z++){
                if(arr[z] > arr[z+1]){
                    int temp = arr[z];
                    arr[z] = arr[z+1];
                    arr[z+1] = temp;
                }
            }
        }
    }

选择排序

类似冒泡排序，只是冒泡排序每次找到小的值都替换，而选择排序会找到最小的再去替换

	public static void majorityElement(int[] arr){
        for(int i = 0;i<arr.length;i++){
            int t = i;
            for(int z=i;z<arr.length;z++){
                if(arr[z] < arr[t]){
                    t = z;
                }
            }
            int temp = arr[i];
            arr[i] = arr[t];
            arr[t] = temp;

        }
    }

插入排序

数组分为两个部分，第一个部分为排好序的数组，后面的为待排序的数组
拿出待排序的每一个数，去和前面排好序的数组值比较，直接插入。
用[2,8,6,1]做例子
[2]为已经排好的部分，用8去比较，大于2，将8赋值给原数组8的位置
[2，8]为已经排好的部分，用6去比较，6小于8，8移动到6的位置，6大于2，直接将6赋值给原数组8的位置
[2,6,8]为已经排好的部分，用1去比较，1小于8，8移动到1的位置，1小于6，6移动到8的位置，1小于2，2移动到6的位置，最后变为[1,2,6,8]
赋值时都是按照原数组去移动赋值的

	public static void majorityElement(int[] arr){
        for(int i = 1;i<arr.length;i++){
            int x = i-1,temp = arr[i];
            while(x >= 0 && temp < arr[x]){
                arr[x+1] = arr[x];
                x--;
            }
            arr[x+1] = temp;
        }
    }

快速排序

用[2,8,6,1]做例子
2作为基准值，从右向左找出小于基准值的数字,判断1小于基准值，换位置后数组变为[1,8,6,1]
2作为基准值，从左向右找出大于基准值的数字,判断8大于基准值，换位置后数组变为[1,8,6,8]
此时小于2的都在左边，大于2的都在右边，将基准值替换到数组中[1,2,6,8]

	public static void main(String[] args) {
		int[] arr = {6,3,5,7,9,5,4,1,2};
        quickSort(arr,0,arr.length-1);
        System.out.println();
    }

    public static void quickSort(int[] arr,int low,int high){
        if(low >= high){
            return ;
        }
        int l = low;
        int r = high;
        int tmp  = arr[low];//基准值
        while(l < r){

			//从右向左找出小于基准值的数字
            while(l < r && arr[r] >= tmp){
                r--;
            }
            arr[l] = arr[r];
            //从左向右找出大于基准值的数字
            while(l < r && arr[l] <= tmp){
                l++;
            }
            arr[r] = arr[l];
        }
        arr[l] = tmp;
        majorityElement(arr,low,r-1);
        majorityElement(arr,r+1,high);
    }

网上看了一篇排序算法不错的文章，纪录一下