Two ways of doing Counting Sort

问题

Here are my two implementations of Counting Sort

In this implementation which is a very simple one, all I do is count the number of occurrences of the element, and insert as many times as the occurrences in the output array. Implementation 1

public class Simple
{
    static int[] a = {5,6,6,4,4,4,8,8,8,9,4,4,3,3,4};

    public static void main(String[] args)
    {
        fun(a);
        print(a);
    }

    static void fun(int[] a)
    {
        int max = findMax(a);

        int[] temp = new int[max+1];
        for(int i = 0;i<a.length;i++)
        {
            temp[a[i]]++;
        }
        print(temp);

        //print(temp);
        int k = 0;
        for(int i = 0;i<temp.length;i++)
        {
            for(int j = 0;j<temp[i];j++)
                a[k++] = i;
        }
        print(a);
    }

    static int findMax(int[] a)
    {
        int max = a[0];
        for(int i= 1;i<a.length;i++)
        {
            if(a[i] > max)
                max = a[i];
        }
        return max;
    }

    static void print(int[] a)
    {
        for(int i = 0;i<a.length;i++)
            System.out.print(a[i] + " ");
        System.out.println("");
    }
}

Implementation 2 In this implementation which I saw on a lot of places online, you create an array saying how many elements there exists less than or equal to, that element, and then insert the element at that position. Once you insert, you reduce the count of the number of elements that are less than or equal to that element, since you have included that element. By the element, this array turns to all zeros. As you can see this implementation is fairly complex compared to the previous one, and am not sure why this is widely popular online.

public class NotVerySimple {
    public static void main(String[] args) {
    static int[] a = {5,6,6,4,4,4,8,8,8,9,4,4,3,3,4};

        sort(a);
    }

    static void sort(int[] a)
    {
        int min = smallest(a);
        int max = largest(a);

        int[] A = new int[max - min + 1];

        for(int i = 0;i<a.length;i++)
        {
            A[a[i] - min]++; 
        }

        for(int i = 1;i<A.length;i++)
            A[i] = A[i-1] + A[i];

        int[] B = new int[a.length];
        for(int i = 0;i<a.length;i++)
        {
            B[ A[a[i] - min] - 1 ] = a[i];
            A[a[i] - min]--;
        }
        print(B);
    }

    static int smallest(int[] a)
    {
        int ret = a[0];
        for(int i = 1;i<a.length;i++)
        {
            if(a[i] < ret)
                ret = a[i];
        }
        return ret;
    }

    static int largest(int[] a)
    {
        int ret = a[0];
        for(int i = 1;i<a.length;i++)
        {
            if(a[i] > ret)
                ret = a[i];
        }
        return ret;
    }

    static void print(int[] a)
    {
        for(int x : a)
            System.out.print(x+ " ");
    }
}

Are there any advantages of the second complex implementation as compared to the first simple one, which makes it so popular?

来源：https://stackoverflow.com/questions/38175924/two-ways-of-doing-counting-sort

标签

sorting

counting-sort