Sorting Algorithms Overview

 

　　Time Complexity of an algorithm is usually estimated as the asymptotic number of elementary operations with respect to an input size. When it comes to comparison-based sorting algorithms, the so-called elementary operation is usually referred to the comparison of key values.

1. Comparison-Based Sorting Algorithms

　　Comparison-based sorting algorithms have a lower bound of time complexity as O(n*log n). Here I shall provide a Java program involving following sorting algorithms:
　　(1)  Selection Sort:  unstable and of quadratic time complexity

　　(2)  Insertion Sort:  stable and of quadratic time complexity

　　(3)  Binary Insertion Sort:  stable and of O(n*log n) time complexity in terms of comparisons

　　(4)  Quick Sort:  unstable and of O(n*log n) average time as long as pivot is randomly chosen

　　(5)  Merge Sort:  stable and of O(n*log n) worst-case time complexity

　　(6)  Heap Sort:  unstable and of O(n*log n) worst-case time complexity

class Array<T extends Comparable> {
    private T[] items;        // data of array items
    private int len;            // current length
    private int size;           // size of space
    
    public Array(int size) {
        if (size<=0) {
            throw new RuntimeException("Illegal Initial Size");
        } else {
            this.size = size;
            items = (T[]) new Comparable[size];
        }
    }
    public void append(T item) {
        // Insert a new item in items[len]
        if (len==size) {
            doubleSize();
        }
        items[len++] = item;
    }
    private void doubleSize() {
        // Double the space size when it's filled up
        if ((size<<1)<0) {
            throw new RuntimeException("Size Expansion Failed");
        } else {
            T[] tmp = items;
            items = (T[]) new Comparable[size<<1];
            for (int i=0;i<len;i++) {
                items[i] = tmp[i];
            }
            size <<= 1;
        }
    }
    public void selectSort() {
        // Implement Selection Sort Algorithm
        for (int i=0;i<len-1;i++) {
            int idx = i;
            T key = items[idx];
            for (int j=i+1;j<len;j++) {
                if (items[j].compareTo(key)<0) {
                    idx = j;
                    key = items[idx];
                }
            }
            items[idx] = items[i];
            items[i] = key;
        }
    }
    public void insertSort() {
        // Implement Insertion Sort Algorithm
        for (int i=1;i<len;i++) {
            T key = items[i];
            int j = i-1;
            for (;j>=0&&items[j].compareTo(key)>0;j--) {
                items[j+1] = items[j];
            }
            items[j+1] = key;
        }
    }
    public void binInsSort() {
        // Implement Binary Insertion Sort
        for (int i=1;i<len;i++) {
            T key = items[i];
            int pos = binSrch(0,i-1,key);
            for (int j=i;j>pos;j--) {
                items[j] = items[j-1];
            }
            items[pos] = key;
        }
    }
    private int binSrch(int p,int r,T key) {
        //   Search for the position to insert key in itmes[p...r]
        //   Precondition:        items[p...r] is a sorted array
        //   Postcondition:    the position of  the least item larger than
        //               key in items[p...r] if it exists, otherwise return r+1
        if (p==r)  {
            if (items[p].compareTo(key)<=0) {
                return p+1;
            } else {
                return p;
            }
        } else  {
            int q = (p+r)/2;
            if (items[q+1].compareTo(key)>0) {
                return binSrch(p,q,key);
            } else {
                return binSrch(q+1,r,key);
            }
        }
    }
    public void quickSort() {
        //    Implement Quick Sort Algorithm
        genRandPerm();
        qsort(0,len-1);
    }
    private void genRandPerm() {
        // Perturb items into a random permutation
        Random rand = new Random();
        for (int i=0;i<len-1;i++) {
            int idx = i+rand.nextInt(len-i);
            T tmp = items[idx];
            items[idx] = items[i];
            items[i] = tmp;
        }
    }
    private void qsort(int p,int r) {
        // Divide & Conquer for quick sort
        if (p<r) {
            int q = partition(p,r);
            qsort(p,q-1);
            qsort(q+1,r);
        }
    }
    private int partition(int p,int r) {
        // Partition items[p...r] for qsort procedure
        //  Precondition:        items[p...r] is a random permutation
        //  Postcondition:    items[q+1...r] are larger than items[q]
        //        items[p...q-1] are smaller than or equal to items[q]
        //        pivot index q is returned
        T key = items[r];
        int i = p-1;
        for (int j=p;j<r;j++) {
            //    Loop Invariant:    items[i...j-1] are larger than key
            //          items[p...i-1] are smaller than or equal to key
            if (items[j].compareTo(key)<=0) {
                i = i+1;
                T tmp = items[i];
                items[i] = items[j];
                items[j] = tmp;
            }
        }
        items[r] = items[i+1];
        items[i+1] = key;
        return i+1;
    }
    public void mergeSort() {
        // Implement Merge Sort Algorithm
        T[] tmp = (T[]) new Comparable[len];
        msort(tmp,0,len-1);
    }
    private void msort(T[] tmp,int p,int r) {
        // Divide & Conquer for merge sort
        if (p<r) {
            int q = ((p+r)>>1);
            msort(tmp,p,q);
            msort(tmp,q+1,r);
            merge(tmp,p,q,r);
        }
    }
    private void merge(T[] tmp,int p,int q,int r) {
        // Merge items[p...q] and items[q+1...r] into a whole
        //  Precondition:        items[p...q] and items[q+1....r] are sorted
        //  Postcondition:    items[p...r] is sorted
        for (int i=p;i<=r;i++) {
            tmp[i] = items[i];
        }
        int i = p, j = q+1, k = p;
        while (i<=q&&j<=r)  {
            //    both left[] and right[] haven't run out
            if (tmp[i].compareTo(tmp[j])<0) {
                items[k++] = tmp[i++];
            } else {
                items[k++] = tmp[j++];
            }
        }
        while (i<=q) {
            // only left[] hasn't run out
            items[k++] = tmp[i++];
        }
        while (j<=r) {
            // only right[] hasn't run out
            items[k++] = tmp[j++];
        }
    }
    public void heapsort() {
        // Implement Heap Sort Algorithm
        for (int i=((len-3)>>1);i>=0;i--) {
            // build a max-heap
            sift_down(len,i);
        }
        int n = len;
        for (int i=len-1;i>0;i--) {
            // extract the max item
            T tmp = items[0];
            items[0] = items[i];
            items[i] = tmp;
            sift_down(--n,0);
        }
    }
    public void sift_down(int n,int i) {
        // MAX_HEAPIFY from items[i] given n is the heap size
        int j = (i<<1)+1, k = (i<<1)+2, idx = i;
        if (j<n) {
            if (items[idx].compareTo(items[j])<0) {
                idx = j;
            }
            if (k<n&&items[idx].compareTo(items[k])<0) {
                idx = k;
            }
            if (idx>i) {
                T tmp = items[i];
                items[i] = items[idx];
                items[idx] = tmp;
                sift_down(n,idx);
            }
        }
    }
    public void display() {
        // Display the array items on the console
        if (len>0) {
            System.out.print(items[0]);
            for (int i=1;i<len;i++) {
                System.out.print(" "+items[i]);
            }
        }
        System.out.println();
    }
    
}

 

2. Counting Sort

　　Since Counting Sort is not based on comparisons, its time complexity has no lower bound as those mentioned above. As an integer sorting algorithm, counting sort takes O(N) time, where N is the range of the input integers (MAX - MIN).

　　Talk is cheap, show you my code.  ╮(￣.￣)╭

    public static void countSort(int[] arr) {
        int n = arr.length;
                int min = arr[0], max = arr[0];
        for (int i=1;i<n;i++) {
            // Determine the minimum and maximum values
            if (min>arr[i]) {
                min = arr[i];
            } else if (max<arr[i]){
                max = arr[i];
            }
        }
        max -= min;
        int[] cnt = new int[max+1];
        for (int i=0;i<n;i++) {
            // Count the frequency of each value in arr[]
            cnt[arr[i]-min]++;
        }
        for (int i=1;i<=max;i++) {
            // Determine the starting position of each value
            cnt[i] += cnt[i-1];
        }
        int pos = 0;
        for (int i=0;i<=max;i++) {
            // Put the values in their proper positions
            while (cnt[i]>pos) {
                arr[pos++] = i+min;
            }
        }
    }

 

3. Applications of Sorting Algorithms

　　We can apply the sorting algorithms described above to many other problems. For instance, we can select a certain Order Statistic of an integer array by drawing on the partition method in Quick Sort:

    public static int select(int[] arr,int idx) {
        // Determine the idxth Order Statistic in arr[]
        // Precondition: 1<=idx<=arr.length
        // Postcondition: the value desired is returned
        int n = arr.length;
        int[] tmp = new int[n];
        for (int i=0;i<n;i++) {
            tmp[i] = arr[i];
        }
        return selectHelp(tmp,0,n-1,idx);
    }
    private static int selectHelp(int[] arr,int p,int r,int idx) {
        // Determine the idxth Order Statistic among arr[p...r]
        // Precondition: 1<=idx<=r+1-p (p<=r)
        // Postcondition: the value desired is returned
        if (p==r) {
            return arr[p];
        } 
        int key = arr[r];
        int q = p;
        for (int j=p;j<r;j++) {
            // arr[p...q-1]<=key<arr[q...j]
            if (arr[j]<=key) {
                int tmp = arr[q];
                arr[q] = arr[j];
                arr[j] = tmp;
                q++;
            }
        }
        arr[r] = arr[q];
        arr[q] = key;
        if (idx<=q-p) {
            return selectHelp(arr,p,q-1,idx);
        } else {
            return selectHelp(arr,q,r,idx+p-q);
        }
    }

 

　　Another example is that we use the merge method in Merge Sort to count the number of inversions in a given integer array:

    public static int invNum(int[] arr) {
        int n = arr.length;
        int[] tmp = new int[n];
        for (int i=0;i<n;i++) {
            tmp[i] = arr[i];
        }
        int[] left = new int[(n-1)/2+2];
        int[] right = new int[n/2+1];
        return invNumHelp(tmp,0,n-1,left,right);
    }
    private static int invNumHelp(int[] arr,int p,int r,int[] left,int[] right) {
        // Determine the number of inversions in arr[p...r]
        //        and meanwhile turn it into increasing order
        if (p==r) {
            return 0;
        } 
        int q = ((p+r)>>1), val = 0;
        // solve subproblems recursively
        val += invNumHelp(arr,p,q,left,right);
        val += invNumHelp(arr,q+1,r,left,right);
        // copy arr[] to left[] and right[]
        for (int i=p;i<=q;i++) {
            left[i-p] = arr[i];
        }
        for (int i=q+1;i<=r;i++) {
            right[i-q-1] = arr[i];
        }
        // set sentinels in left[] and right[]
        left[q+1-p] = (1<<31)-1;
        right[r-q] = (1<<31)-1;
        // count inversions across left and right
        for (int i=0,j=0,k=p;k<=r;k++) {
            if (left[i]>right[j]) {
                arr[k] = right[j++];
                val += (q+1-p-i);
            } else {
                arr[k] = left[i++];
            }
        }
        return val;
    }

 

　　As a matter of fact, Quick Sort is a Divide-and-Conquer Algorithm that solves the problem in a top-down way, while Merge Sort adopts a bottom-up approach instead.

References:

　　1. Cormen, T. H. et al. Introduction to Algorithms [M] .  北京：机械工业出版社, 2006-09