排序相关算法

Sort

bubble sort

public static void bubbleSort(int[] list){
        int i,j;
        for(i=0;i<list.length-1;i++){
            for(j=list.length-2;j>=i;j--){
                if(list[j]>list[j+1]) swap(list, j, j+1);//内层循环一次，把最小的元素排到首位
            }
        }
    }

heap sort

public static void heapSort(int[] list){
        int length = list.length;
        int[] list2 = new int[list.length+1];
        //构建数组，使得数组编号和对应的大顶堆编号相同
        for(int i=1;i<list2.length;i++){
            list2[i] = list[i-1];
        }
        从大顶堆编号一半开始调整数组，即保证每次调用heapAdjust函数，调整一个非叶子节点，保证这个非叶子节点作为根节点的树为大顶堆，总共调用length/2次。
        for(int i=length/2;i>0;i--){
            heapAdjust(list2, i, length);
        }

        将调整好的大顶堆第一个与最后一个交换，再次调整大顶堆前i-1位。
        for(int i=length;i>1;i--){
            swap(list2, 1, i);
            heapAdjust(list2, 1, i-1);
        }

        for(int i=0;i<length;i++){
            list[i] = list2[i+1];
        }



    }
    private static void heapAdjust(int[] list,int m,int n){
    //temp节点暂时保存待调整的m节点，循环找到m节点应该插入的位置，将最大节点插入m原来的位置，将m插入新位置。
        int j,temp;
        temp = list[m];
        for(j=2*m;j<=n;j*=2){
            if(j<n && list[j+1]>list[j]) j++;
            if(temp>=list[j]) break;
            list[m] = list[j];
            m = j;
        }
        list[m] = temp;
    }

quick sort

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

    private static void qSort(int[] list,int m,int n){
        int pivot;
        if(m<n){
            pivot = partition(list, m, n);
            qSort(list, m, pivot-1);
            qSort(list, pivot+1, n);
        }
    }

    private static int partition(int[] list,int m,int n){
        int pivotkey = list[m];
        while(m<n){
            while(m<n && list[n]>pivotkey) n--;
            swap(list, m, n);
            while(m<n && list[m]<pivotkey) m++;
            swap(list, m, n);
        }
        return m;
    }