数组的排序

冒泡排序

简单来说，冒泡排序就是重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

public static void selectSort (int array[]) {
    for (int i = 0;i < array.length - 1; i ++) {//一共n-1趟
        for (int j = 0;j < array.length-1-i;j ++) {//第i+1时，要比较多少次
            if (array[j] < array[i]) {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;//交换array[j]与array[j+1]
            }
        }
    }
}

选择排序

将最 小/大 的数交换到待排序序列的最前面。

首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置（如果第一个元素就是最小元素那么就和自己交换）。在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。这种方法叫做选择排序，因为它在不断地选择剩余元素之中的最小者。

public static void countSort(){
        int[] arr={8,5,9,2,7,4,6,1,3,10,-3,-2,-10};
        int min=arr[0];
        int max=arr[0];
        for(int i=0;i<arr.length;i++){//O(n)
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<min){
                min=arr[i];
            }
        }
        int[] nums=new int[max-min+1];
        int offset=min;
        for(int i=0;i<arr.length;i++){//O(n)
            nums[arr[i]-offset]++;
        }
        int index=0;
        for(int i=0;i<nums.length;i++){//O(m)
            if(nums[i]!=0){
                for(int j=0;j<nums[i];j++){
                    arr[index++]=i+offset;
                }
            }
        }
        show(arr);
    }

插入排序

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

public class InsertionSort {
    public static void insertionSort(int[] arr){
        if (arr==null || arr.length<2){
            return;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j=i-1;j>=0&&arr[j]>arr[j+1];j--){
                swap(arr,j,j+1);
            }
        }
    }
 
    private static void swap(int[] arr, int j, int i) {
        int temp=arr[j];
        arr[j]=arr[i];
        arr[i]=temp;
    }
}

计数排序

一句话总结：开辟额外空间，统计每个元素的数量。
计数排序是一种不基于比较的排序算法，主要思想是计算出待排序序列的最大值 maxValue 与 最小值 minValue，开辟一个长度为 maxValue - minValue + 1 的额外空间，统计待排序序列中每个元素的数量，记录在额外空间中，最后遍历一遍额外空间，按照顺序把每个元素赋值到原始序列中。

public static void countingSort(int[] arr){
	if(arr == null || arr.length < 2){
		return;
	}
    int maxValue = Integer.MIN_VALUE;
	int minValue = Integer.MAX_VALUE;
    // 找出最大值与最小值
	for(int i = 0; i < arr.length; i++){
		if(arr[i] > maxValue) maxValue = arr[i];
		else if(arr[i] < minValue) minValue = arr[i];
	}
	// 初始化计数数组
	int[] counter = new int[maxValue - minValue + 1];
	for(int i = 0; i < arr.length; i++){
		counter[arr[i] - minValue]++;
	}
	// 计算每个元素的位置
	for(int i = 0; i < counter.length - 1; i++){
		counter[i + 1] += counter[i];
	}
	// 初始化一个新的数组存放排序后的元素
	int[] ans = new int[arr.length];
	for(int i = arr.length - 1; i >= 0; i--) {
		ans[counter[arr[i] - minValue] - 1] = arr[i];
		counter[arr[i] - minValue]--;
	}
	//将排序结果赋值到原始数组中
	for(int i = 0; i < arr.length; i++){
		arr[i] = ans[i];
	}
}

冒泡，选择，插入三个排序都是根据数据之间的大小关系进行比较排序的
计数 基数 桶 都是根据数据本身的特性比较 与大小无关的排序
这些排序只针对整数，是一个典型的牺牲空间换时间的排序