面试常见的排序问题

1. 各排序算法的复杂度

排序方法	平均时间	最坏情况	辅助内存
简单排序	${O(n^2)}$	${O(n^2)}$	${O(1)}$
快速排序	${O(n\log n)}$	${O(n^2)}$	${O(\log n)}$
堆排序	${O(n\log n)}$	${O(n\log n)}$	${O(1)}$
归并排序	${O(n\log n)}$	${O(n \log n)}$	${O(n)}$
基数排序	${O(d(n+rd))}$	${O(d(n+rd))}$	${O(rd)}$

package 算法和数据结构;

//排序算法，面试中最常见的是快排，其次是堆排序，此外还有桶排序，归并排序，插入排序，冒泡排序。
//下面依次实现最常见的集中排序。

public class Sort {
    public void swap(int[] A,int a, int b) {
        int temp = A[a];
        A[a] = A[b];
        A[b] = temp;

    }
    //快速排序,时间复杂度O(n*log(n))
    public void quickSort(int[] A, int l, int r) {
        if(l<r) {
            int p = partition(A,l,r);
            quickSort(A,l,p-1);
            quickSort(A,p+1,r);
        }

    }

    public int partition(int[] A, int l, int r) {
        int tmp = A[r];
        int p = l-1;
        for(int i=l; i<r;i++) {
            if(A[i]<=tmp) {
                p++;
                swap(A,p,i);
            }
        }
        p++;
        swap(A,p,r);
        return p;
    }

    //堆排序， 首先对数组中所有的元素建立一个最小堆，然后依次推出栈顶的元素（最小的），重新建堆。直到堆中的元素为空。
    //堆排序为原位排序，空间复杂度小，时间复杂度为O(n log n);
    //  构建最小堆。
    //  选择顶，并与第0位置元素交换
    //  由于步骤2的的交换可能破环了最大堆的性质，第0不再是最大元素，需要调用maxHeap调整堆(沉降法)，如果需要重复步骤2
    public void heapSort(int[] array) {  
            if (array == null || array.length <= 1) {  
                return;  
            }  

            buildMaxHeap(array);  

            for (int i = array.length - 1; i >= 1; i--) {  
                swap(array, 0, i);  

                maxHeap(array, i, 0);  
            }  
        }  

        private void buildMaxHeap(int[] array) {  
            if (array == null || array.length <= 1) {  
                return;  
            }  

            int half = array.length / 2;  
            for (int i = half; i >= 0; i--) {  
                maxHeap(array, array.length, i);  
            }  
        }  

        private void maxHeap(int[] array, int heapSize, int index) {  
            int left = index * 2 + 1;  
            int right = index * 2 + 2;  

            int largest = index;  
            if (left < heapSize && array[left] > array[index]) {  
                largest = left;  
            }  

            if (right < heapSize && array[right] > array[largest]) {  
                largest = right;  
            }  

            if (index != largest) {  
                swap(array, index, largest);  

                maxHeap(array, heapSize, largest);  
            }  
        }  
    //归并排序，时间复杂度O(NlogN)
    public void mergeSort(int[] A,int l,int r) {
        if(l>=r) return; 
            int m = l + (r-l)/2;
            mergeSort(A,l,m);
            mergeSort(A,m+1,r);
            merge(A,l,m,r);

    }

    public void merge(int[] A, int l, int mid, int r) {
        int[] B = new int[A.length];
        int s = l;
        int m = mid+1;
        int k = l;//数组标志位
        while(s<=mid && m<=r) {
            if(A[s]<=A[m]) {
                B[k++] = A[s++];
            } else{
                B[k++] = A[m++];
            }
        }
        while(s<=mid) {
            B[k++] = A[s++];
        }
        while(m<=r) {
            B[k++] = A[m++];
        }

        for(int i=l;i<=r;i++) {
            A[i] = B[i];
        }
    }

    //冒泡法排序时间复杂度为O(n^2)
    public void bubbleSort(int[] A) {
        int len = A.length;
        for(int i=0; i<len;i++) {
            for(int j=len-1; j>i; j--) {
                if(A[i]>A[j]){
                    int tmp = A[i];
                    A[i] = A[j];
                    A[j] = tmp;
                }
            }
        }
    }

    //插入排序
    public void insertSort(int[] A) {
        int len = A.length;
        int j;
        for(int i=0;i<len;i++){
            int tmp = A[i];
            for(j = i; j > 0 && tmp < A[j-1]; j--)   
                A[j] = A[j-1];   
            A[j] = tmp;
        }
    }




    public static void main(String[] args) {
        int[] A = {49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};

        for(int i:A) {
            System.out.print(i+" ");
        }
        System.out.println();
        Sort sort = new Sort();
        sort.heapSort(A);
        for(int i:A) {
            System.out.print(i + " ");
        }
    }

}