算法复习2——堆排序与快速排序

1 堆排序

步骤（以升序排列为例，排序结束后数组末尾为最大值）：

• 从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1），从左至右，从下至上进行调整，最终将一个无序序列构造成一个大根堆，此时序列头就是最大值。
• 将堆顶元素与末尾元素进行交换，使末尾元素最大,即将最大元素"沉"到数组末端。然后继续调整堆；再将堆顶元素与次末尾元素交换，得到第二大元素;如此反复进行交换、重建、交换。

import java.util.ArrayList;
import java.util.Arrays;

public class HeapSort {
    public static void main(String[] args){
        int []arr = {7,6,7,11,5,12,3,0,1};
        System.out.println("排序前："+ Arrays.toString(arr));
        sort(arr);
        System.out.println("排序后："+Arrays.toString(arr));
    }

    public static void sort(int[] array){
        //1.构建大顶堆
        //从第一个非叶子节点开始，从左至右，从下到上调整
        for(int i=array.length/2-1;i>=0;i--){
            adjustHeap(array,i,array.length);
        }
        //2.反复交换堆顶和末尾元素，最终完成排序
        for(int i=array.length-1;i>0;i--){
            swap(array,0,i);
            adjustHeap(array,0,i);
        }
    }

    //调整大顶堆
    //len表示调整到数组的第几个元素，比如第n轮交换，说明是倒数第n个元素与顶部交换，那么len=array.length-n
    public static void adjustHeap(int[] array,int index,int len){
        int temp=array[index];
        for(int i=index*2+1;i<len;i++){ //从左子节点开始调整
            //如果存在左右子节点，选择左右子节点中值较大的点
            if(i+1<len && array[i]<array[i+1])
                i++;
            if(array[i]>temp){
                array[index]=array[i];//此处只将子节点的值赋值给父节点，并不是交换
                index=i; ////index调整到换下来的子节点的位置，继续看子结构有没有出现混乱
            }else
                break;
        }
        array[index]=temp; //将temp值放到最终的位置
    }

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

2 快速排序

重点：

• public static void quickSort(int[] array,int left,int right){}方法
• 每次先右指针左移，保证了最后l,r相遇以后所对应的值，一定是小于参照点的值的，因此直接交换参照点与该点即可。

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int[] array = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void quickSort(int[] array){
        quickSort(array,0,array.length-1);
    }

    public static void quickSort(int[] array,int left,int right){
        if(left>right)
            return;
        int temp=array[left];
        int l=left,r=right;
        while(l<r){
            //每次先右指针左移，保证了最后l,r相遇时一定指向<temp的值，这样最后与array[left]交换以后一定是左边小右边大。
            while(array[r]>=temp && l<r)
                r--;
            while(array[l]<=temp && l<r) {
                l++;
            }
            if(l<r){//做一次判断
                swap(array,l,r);
            }
        }
        array[left]=array[l];
        array[l]=temp;

        //递归调用
        quickSort(array,left,l-1);
        quickSort(array,l+1,right);
    }

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