堆排序与快速排序-优快云博客

堆排序要从小到大输出，用大根堆：

例
在这里插入图片描述 k
堆排序的思想
堆排序可以说是选择排序的改进版，它可以减少在选择排序中的比较次数，进而减少排序的时间。

时间复杂度为O(nlogn)

不稳定

空间复杂度：O(1)

例如有如下一组数据

68,98,52,32,17,19,14,32
1
把它转化成二叉树：
在这里插入图片描述好kkklvkk,,,,代码

package javapaixu;

import java.util.Arrays;

public class Dui {
    public static void adjust(int[] array,int start,int end) {
    	int tmp = array[start];
    	for(int i = 2*start+1;i <= end;i = 2*i+1) {
    		//找到左右孩子的最大值    i   最大值下标
    		if(i < end && array[i] < array[i+1]) {//保证有右孩子
    			i++;
    		}
    		
    		if(array[i] > tmp) {
    			array[start] = array[i];
    			start = i;
    		}
    		
    		if(array[i] < tmp) {
    			break;
    		}
    	}
    	array[start] = tmp;
    }
    
    public static void heapSort(int[] array) {
        if(array == null || array.length == 0) {
            return;
        }
    	for(int i = (array.length-1-1)/2;i >= 0;i--) {
    		adjust(array,i,array.length-1);
    	}
    	//最后一个值和根节点交换
    	int tmp = 0;
    	for(int j = 0;j < array.length-1;j++) {
    		tmp = array[0];
    		array[0] = array[array.length-1-j];
    		array[array.length-1-j] = tmp;
    		//只需要调整最大的数就好了，因为其他的子树已经是大根堆了
    		adjust(array,0,array.length-1-1-j);
    	}
    }
	public static void main(String[] args) {
		int[] array = {68,98,52,32,17,19,14,32};
		heapSort(array);
		System.out.println(Arrays.toString(array));
}

}

快速排序
快速排序就是分割交换的排序方法，是目前公认的最佳排序方法，在最快以及平均情况下，时间复杂度为O(nlogn)。最坏情况（数据本身就有序）就是每次挑中的基准值不是最大就是最小，其时间复杂度为O(n^2);不稳定，在最差情况下的空间复杂度为O(n),而最佳情况下为O(nlogn)。快速排序法是平均运行时间最快的排序法。

快速排序的思想：它的原理和冒泡排序一样，都是用交换的方式，不过它会现在数据中找一个基准，把小于这个基准的数据放在左边，大于基准的放在右边。再以同样的方式处理两边的数据。

现定义两个下标，low和high分别指向第一个和最后一个，low从前往后走，high从后往前走，一般第一次以第一个元素为基准，把小于这个基准的数据放在左边，大于基准的放在右边，比较完一趟，确定了选的基准的有序位置，且基准左边的都比基准小，右边的都比基准大，然后在再这个有序元素进行两边同样的比较，直至所有的元素位置都确定了就排序完了。

public class TestDemo6 {
    public static void main(String[] args) {
        int[] array = {20,1,9,56,25,32,87,45,12,69,54,19};
        System.out.println(Arrays.toString(array));
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * 快速排序
     * @param array
     */
    private static void quickSort(int[] array) {
        if(array == null || array.length == 0) {
            return;
        }
        sort(array,0,array.length-1);
    }

    /**
     * 递归的排序数据
     * @param array
     * @param start
     * @param end
     */
    private static void sort(int[] array,int start,int end) {
        int par = partion(array,start,end);
        if(par > start+1) {  //排序左边
            sort(array,start,par-1);
        }
        if(par < end-1) {  //排序右边
            sort(array,par+1,end);
        }
    }


    /**
     * 一趟快排
     * 确定一个基准，把小于基准的数据移到前面去，大于基准的移到后面，确定基准的位置
     * @param array
     * @param low
     * @param high
     * @return
     */
    public static int partion(int[] array,int low,int high) {
        int temp = array[low];  //以第一个元素为基准，基准值赋值给temp
        while(low < high) {
            //从后往前，大于基准的数据不管，小于基准的移动到前面去
            while(low < high && array[high] > temp) {
                --high;
            }
            /*
             * 出了上面循环，high指针肯定指向它找到的后面的第一个小于基准的数据
             * 把该数据移到到前面
             */
            array[low] = array[high];

            //从前往后，小于基准的数据不管，大于基准的移动到后面去
            while(low < high && array[low] <= temp) {
                ++low;
            }
            /*
             * 出了上面循环，low指针肯定指向它找到的前面的第一个大于于基准的数据
             * 把该数据移到到后面
             */
            array[high] = array[low];
        }
        /*
         *最后出来，low和high指针在同一位置，都指向基准应该放置的位置
         * 小于它的都在前面，大于它的都在后面
         */
        array[low] = temp;
        /*
         *把基准最后的位置返回出去，基准的位置已经确定，即基准已经有序
         *后面分别在这个基准位置两边重复上面的操作，用以排序当前基准两
         *边的数据
         */
        return low;
    }
}