几种排序算法

冒泡排序

public static void sortPlus(int[] arr){
    if(arr != null && arr.length > 1){
        for(int i = 0; i < arr.length - 1; i++){
            // 初始化一个布尔值
            boolean flag = true;
            for(int j = 0; j < arr.length - i - 1 ; j++){
                if(arr[j] > arr[j+1]){
                    // 调换
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    // 改变flag
                    flag = false;
                }
            }
            if(flag){
                break;
            }
        }
    }
}

选择排序

public static void sort(int[] arr){
    for(int i = 0; i < arr.length - 1 ; i++){
        int min = i; // 遍历的区间最小的值
        for (int j = i + 1; j < arr.length ;j++){
             if(arr[j] < arr[min]){
                 // 找到当前遍历区间最小的值的索引
                 min = j;
             }
        }
        if(min != i){
            // 发生了调换
            int temp =  arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
        }
    }
}

快速排序

public static void QuickSort(int a[], int low ,int high) 
{
	if(low<high) 
	{ //判断是否满足排序条件，递归的终止条件
		int i = low, j = high;   
		int x = a[low];    
		while(i<j) 
		{
			while(i<j && a[j] >= x) j--;  
			
			if(i<j) a[i++] = a[j];   
			
			while(i<j && a[i] <= x) i++; 
			
			if(i<j) a[j--] = a[i];
		}
		a[i] = x;   
		QuickSort(a, low ,i-1); 
		QuickSort(a, i+1 ,high);
	}
}

希尔排序

public static void ShellSort(int a[],int n)
{
    for(int gap=n/2;gap>0;gap/=2)
    for(int i=gap;i<n;i+=gap)
    {
    	int end=a[i];
    	int j=i-gap;
    	while(j>=0&&a[j]>end)
    	{
    		a[j+gap]=a[j];
    		j-=gap;
        }
	a[j+gap]=end;
   }
}

堆排序

public class HeapSort {
	private static int[] sort = { 23, 45, 12, 56, 32, 78, 1, 3, 90, 678, 2, 4, 8, 92, 67, 49 };

	public static void main(String[] args) {
		buildMaxHeapify(sort);
		heapSort(sort);
		
		System.out.println(Arrays.toString(sort));
	}
	
	/**
	 * 由于是大顶堆，数组的第一个元素是整个数组中的最大值
	 * 让其与数组中最后一个元素交换，并调用maxHeapify方法使大顶堆恢复平衡
	 * @param data
	 */
	private static void heapSort(int[] data) {
		int size = data.length;
		for (int i = size - 1; i >= 1; i--) {
			swap(data, 0, i);
			maxHeapify(data, --size, 0);
		}
	}

	/**
	 * 用给定的数组由下至上创建大顶堆
	 */
	private static void buildMaxHeapify(int[] data) {
		// 由完全二叉树的性质可得：在数组中，叶节点的下标从{n/2(向下取整)}开始
		for (int i = data.length / 2 - 1; i >= 0; i--) {
			maxHeapify(data, data.length, i);
		}
	}

	private static void maxHeapify(int[] data, int heapSize, int index) {
		//获取当前节点的左右孩子
		int left = getChildLeftIndex(index);
		int right = getChildRightIndex(index);

		
		int largest = index;
		if (left < heapSize && data[index] < data[left])
			largest = left;
		if (right < heapSize && data[largest] < data[right])
			largest = right;
		
		if (largest != index) {
			swap(data, index, largest);
			maxHeapify(data, heapSize, largest);
		}
	}

	private static void swap(int[] data, int a, int b) {
		int temp = data[a];
		data[a] = data[b];
		data[b] = temp;
	}

	
	private static int getChildLeftIndex(int current) {
		//左移一位相当于将原数扩大二倍
		return (current << 1) + 1;
	}

	private static int getChildRightIndex(int current) {
		//左移一位相当于将原数扩大二倍
		return (current << 1) + 2;
	}
}