/**
 * 排序算法总结
 *
 *
 * @author bobo
 * @date 2014-7-22 
 *
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arr = {50,38,87,42,757,45,100,4,78};
        //insertSort(arr);//插入排序
        //selectSort(arr);//选择排序
        //bubbleSort(arr);//冒泡排序
        //shellSort(arr);//希尔排序
        //quickSort(arr);//快速排序
        baseSort(arr);//基数排序
        
        showArr(arr);
        
    }
    
    /**
     * 基数排序
     *
     *
     * @param arr 数组
     */
    public static void baseSort(int[] arr)
    {
        int length = arr.length;
        int[][] tong = new int[10][length];
        
        //根据位来循环，个位开始
        for (int pos = 1; pos <= 10; pos++)
        {
            for (int j = 0; j < length; j++)
            {
                //当前元素
                int curData = arr[j];
                
                //找出对应位的值
                int rate = (int) Math.pow(10, pos - 1);
                int curPosNum = (curData / rate) % 10;
                
                //对第二维赋值
                for (int k = 0; k < length; k++)
                {
                    //对应k列的值
                    int curColumnNum = tong[curPosNum][k];
                    
                    //如果为0，说明没有放置数据
                    if (0 == curColumnNum)
                    {
                        tong[curPosNum][k] = curData;
                        break;
                    }
                }
            }
            
            //收集放置好的数据到排序数组
            for (int i = 0, j = 0; i < 10; i++)
            {
                for (int k = 0; k < tong[i].length; k++)
                {
                    if (tong[i][k] > 0)
                    {
                        arr[j++] = tong[i][k];
                    }
                }
            }
            tong = new int[10][length];//排完一次后重置
        }
        
    }

    /**
     * 快速排序
     *
     *
     * @param arr 数组
     */
    public static void quickSort(int[] arr)
    {
        //快速排序是一个递归方法，从0作为低起点，arr.length-1作为高起点
        qSort(arr, 0, arr.length -1);
        
    }

    private static void qSort(int[] arr, int low, int high)
    {
        if (low < high)
        {
            int centerIndex = partenArr(arr, low, high);
            qSort(arr, low, centerIndex - 1);//对前半部分排序
            qSort(arr, centerIndex + 1, high);//对后半部分排序
        }
        
    }

    private static int partenArr(int[] arr, int low, int high)
    {
        int temp;
        temp = arr[low];
        while (low < high)
        {
            //从后往前找，找出后半部分第一个小于中间值的位置，进行交换
            while (low < high && arr[high] >= temp)
            {
                high--;
            }
            swap(arr, low, high);
            
            //从前往后找，找出前半部分第一个大于中间值得位置，进行交换
            while (low < high && arr[low] <= temp)
            {
                low++;
            }
            swap(arr, low, high);
        }
        return low;
    }

    /**
     * 希尔排序
     * 划分步长，分别进行插入排序
     *
     *
     * @param arr 数组
     */
    public static void shellSort(int[] arr)
    {
        int i, j, gap, temp, k;
        for (gap = arr.length / 2; gap > 0; gap /= 2)
        {
            for (i = 0; i < gap; i++)
            {
                for (j = i + gap; j < arr.length; j += gap)
                {
                    if (arr[j] < arr[j - gap])
                    {
                        temp = arr[j];
                        for (k = j - gap; k >= 0 && arr[k] > temp; k -= gap)
                        {
                            arr[k + gap] = arr[k];
                        }
                        arr[k + gap] = temp;
                    }
                }
                
            }
            
        }
    }

    /**
     * 冒泡排序
     * 循环length-1次，从后往前比较，如果后一个小于前一个，进行交换
     *
     * @param arr 数组
     */
    public static void bubbleSort(int[] arr)
    {
        int i, j;
        boolean flag = true;//如果没有交换，退出循环
        for (i = 1; i < arr.length && flag; i++)
        {
            flag = false;
            for (j = arr.length - 1; j >= i; j--)
            {
                if (arr[j - 1] > arr[j])
                {
                    flag = true;
                    swap(arr, j - 1, j);
                }
            }
        }
    }

    /**
     * 选择排序
     * 循环length-1次，拿某个位置的数与后面的所有比较
     *
     *
     * @param arr 数组
     */
    public static void selectSort(int[] arr)
    {
        int i, j;
        //外循环从第一个开始到倒数第二个结束
        for (i = 0; i < arr.length - 1; i++)
        {
            //内循环从第二个开始到最后一个结束
            for (j = i + 1; j < arr.length; j++)
            {
                if (arr[i] > arr[j])
                {
                    swap(arr, i, j);
                }
            }
        }
    }

    /**
     * 插入排序
     * 循环length-1次,如果【i-1】>【i】的数,需要交换位置，比较是从后往前比较
     *
     * @param arr 数组
     */
    public static void insertSort(int[] arr)
    {
        int i, j, temp;
        //从第二个开始，到最后一个结束
        for (i = 1; i < arr.length; i++)
        {
            //如果前一个大于后一个
            if (arr[i] < arr[i - 1])
            {
                temp = arr[i];//中间变量
                for (j = i - 1; j >= 0 && arr[j] > temp; j--)
                {
                    arr[j + 1] = arr[j];
                }
                //此时j--了，到了正确插入的位置
                arr[j + 1] = temp;
            }
            
        }
        
    }
    
    /**
     * 交换两个值的位置
     *
     *
     * @param arr 数组
     * @param i 下标
     * @param j 下标
     */
    private static void swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    /**
     * 显示数组
     *
     *
     * @param arr 数组
     */
    private static void showArr(int[] arr)
    {
        for (int i = 0; i < arr.length; i++)
        {
            if (i == arr.length - 1)
            {
                System.out.print(arr[i]);
            }
            else
            {
                System.out.print(arr[i] + ",");
            }
            
        }
    }
}