几种排序方式

排序方式（后期还会添加）

冒泡排序

public class Bubbling {
    public static void BubblingSort(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }
        for (int end = arr.length - 1;end > 0;end--){
            for (int i = 0;i < end;i++){
                if (arr[i] > arr[i+1]){
                    swap(arr, i ,i +1);
                }
            }
        }
    }
    public static void swap(int[] arr,int i,int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

选择排序：

public class Choose {
    public static  void select(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }
        for (int i = 0;i < arr.length - 1;i++){
            int minIndex = i;
            for (int j = i + 1;j < arr.length;j++){
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            swap(arr,i,minIndex);
        }
    }
    public static void swap(int[] arr,int i,int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

插入排序：

private static int[] insertSort(int[] arr) {
	int temp;
    for (int i=1;i<arr.length;i++){
        //待排元素小于有序序列的最后一个元素时，向前插入
        if (arr[i]<arr[i-1]){
            temp = arr[i];
            for (int j=i;j>=0;j--){
                if (j>0 && arr[j-1]>temp) {
                    arr[j]=arr[j-1];
                }else {
                    arr[j]=temp;
                    break;
                }
            }
        }
    }
    return arr;
}

快速排序：

private static int[] quickSort(int[] arr, int low, int high) {
		if (low < high) {
			int middle = getMiddle(arr, low, high);
			//对左子序列进行排序
			quickSort(arr, low, middle - 1);
			//对右子序列进行排序
			quickSort(arr, middle + 1, high);
		}
		return arr;
}
private static int getMiddle(int[] arr, int low, int high) {
	int temp = arr[low];
	while (low < high) {
		while (low < high && temp <= arr[high]) {
			high--;
		}
		arr[low] = arr[high];
           while (low < high && temp >= arr[low]) {
                low++;
           }
           arr[high] = arr[low];	
	}
	arr[low] = temp;
	return low;
}

堆排序：

 public static void heapSort(int[] arr) {
        //构造大根堆
        heapInsert(arr);
        int size = arr.length;
        while (size > 1) {
            //固定最大值
            swap(arr, 0, size - 1);
            size--;
            //构造大根堆
            heapify(arr, 0, size);
        }
    }
    public static void heapInsert(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            //当前索引
            int currentIndex = i;
            //父结点索引
            int fatherIndex = (currentIndex - 1) / 2;
            //如果当前插入的值大于其父结点的值,则交换值，并且将索引指向父结点
            //然后继续和上面的父结点值比较，直到不大于父结点，则退出循环
            while (arr[currentIndex] > arr[fatherIndex]) {
                swap(arr, currentIndex, fatherIndex);
                currentIndex = fatherIndex;
                fatherIndex = (currentIndex - 1) / 2;
            }
        }
    }
//剩余的数构造成大根堆
public static void heapify(int[] arr, int index, int size) {
    int left = 2 * index + 1;
    int right = 2 * index + 2;
    while (left < size) {
        int largestIndex;
        if (arr[left] < arr[right] && right < size) {
            largestIndex = right;
        } else {
            largestIndex = left;
        }
        //比较父结点的值与孩子中较大的值，并确定最大值的索引
        if (arr[index] > arr[largestIndex]) {
            largestIndex = index;
        }
        //为大根堆时
        if (index == largestIndex) {
            break;
        }
        swap(arr, largestIndex, index);
        index = largestIndex;
        left = 2 * index + 1;
        right = 2 * index + 2;
    }

}
//交换数组中两个元素的值
public static void swap(int[] arr, int i, int j) {
     int temp = arr[i];
     arr[i] = arr[j];
     arr[j] = temp;
}