排序算法

1. 堆排序

public class HeapSort {
    public static void main(String[] args) {
        int [] tree={2,5,3,1,10,4};
        int n=6;
       // heap(tree,6,0);
        heap_sort(tree,6);

        for (int i=0;i<n;i++){
            System.out.println(tree[i]);
        }


    }
  //交换
   public static void swap(int [] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    //调整堆,如果最大值互换了，堆结构会变化，调整一下。
    //n代码数组长度，i代表第i个结点数
    public static void heap (int []tree,int n,int i){
        if (i>=n){
            return;
        }
        int c1=2*i+1;
        int c2=2*i+2;
        int max=i;
        if(c1<n &&tree[c1]>tree[max]){
            max=c1;
        }
        if (c2<n &&tree[c2]>tree[max]){
            max=c2;
        }
        if (max!=i){
            swap(tree,max,i);
            heap(tree,n,max);
        }
    }

    //建堆
    // 从最后一个节点往前做调整
    public static void build_heap(int []tree,int n){

        int last_node=n-1;
        int parent=(last_node-1)/2;

        for (int i=parent;i>=0;i--){
            heap(tree,n,i);
        }

    }
    //堆排
    public static void heap_sort(int tree[],int n){
        build_heap(tree,n);
        for (int i=n-1;i>=0;i--){
            swap(tree,i,0);
            heap(tree,i,0);
        }
    }
}

2. 快排

public class QuickSort {
    public static void main(String[] args) {
        //定义数组
        int[] arr={6,3,7,9,5,1,4,8};
        //调用方法，进行快速排序
        quickSort(arr,0,arr.length-1);
        //遍历数组
        for (int i=0;i<arr.length;i++){
            System.out.println(arr[i]+" ");
        }

    }
    public static void quickSort(int[]arr,int left,int right){
        //进行判断，如果左边索引比右边的索引大，是不合法的，直接使用return结束
        if (left>right){
            return;
        }
        //定义变量保存基准数
        int base=arr[left];
        //定义变量i,指向最左边
        int i=left;
        //定义变量j,指向最右边
        int j=right;
        //当i和j不相等的时候，在循环中进行检索。
        while(i!=j){
            //j从右向左检索比基准数小的，如果检索到比基准数小的就停下
            //如果检索到比基准数大的或者相等的，就继续检索
            while(arr[j]>=base&&i<j){
                j--;//j从右往左移动
            }
            //i从左向右检索比基准数大的，如果检索到比基准数大的就停下
            //如果检索到比基准数小的或者相等的，就继续检索
            while(arr[i]<=base&&i<j){
                i++;//i从左往右移动
            }
            //代码走到这里，i停下了，j也停下了。然后交换i和j位置的元素。
            int temp=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
        }
        //如果上面的while循环的条件不成立，就会跳出这个循环，往下执行。
        //如果这个条件不成立说明i和j相遇了
        //如果i和j相遇了，就交换基准数这个元素和相遇位置的元素

        //把相遇位置的元素赋值给基准数这个位置的元素
        arr[left]=arr[i];
        //把基准数赋值给相遇位置的元素
        arr[i]=base;

        //基准数在这里就归位了，左边的数字都比他小，右边的数字都比他大。
        //排基准数的左边
        quickSort(arr,left,i-1);
        //排基准数的右边
        quickSort(arr,j+1,right);
    }
}

3. 归并排序

public class mergeSort {
    public static void main(String[] args) {
        int [] arr={2,9,8,10,4,9,6,3};
        int L=0;
        int R=7;
        mergeSort(arr,L,R);
        for (int i=0;i<=R;i++){
            System.out.println(arr[i]);
        }

    }
    //合并，前提是两个已经排好序的数组。
    public  static void merge(int [] arr,int L,int M,int R){
        int leftSize=M-L;
        int rightSize=R-M+1;
       int [] left=new int[leftSize];
       int [] right=new int[rightSize];

       //1.填充左边的子数组
        for(int i=L;i<M;i++){
            left[i-L]=arr[i];
        }
        //2.填充右边的子数组
        for(int i=M;i<=R;i++){
            right[i-M]=arr[i];
        }
        //3.合并数组
        int i=0,j=0,k=L;
        while ( i<leftSize&&j<rightSize){
            if (left[i]<right[j]){
                arr[k]=left[i];
                i++;
                k++;
            }else{
                arr[k]=right[j];
                j++;
                k++;
            }
        }
        while (i<leftSize){
            arr[k]=left[i];
            i++;
            k++;
        }
        while (j<rightSize){
            arr[k]=right[j];
            j++;
            k++;
        }


    }

    //分治
    public static void mergeSort(int [] arr,int L,int R){
        if (L==R){
            return;
        }else{
            int M=(L+R)/2;
            mergeSort(arr,L,M);
            mergeSort(arr,M+1,R);
            merge(arr,L,M+1,R);
        }
    }
}