对如下数组排序 {12,1,23,24,235,237,231,571,575,57} 排序规则如下:先找第一位，比较大的，如果相同，接着按第二位找，找第二位比较大的，依次类推，进行排序

package test.sort;

public class Test1 {
    //对如下数组排序 {12,1,23,24,235,237,231,571,575,57}
    //排序规则如下:先找第一位，比较大的，如果相同，接着按第二位找，找第二位比较大的，依次类推，进行排序
    //如 571,575,57  排序后 为 575，571, 57
    //算法;先按第一位排序得到  571，575，57，再按第二位排序,比较时需判断第一位是否相同，如果相同，可以交换，如果不同，则不交换，因为第一位是优先排序的，
    //得到 571，575，57，
    //再按第三位排序得到 575，571, 57 注意：第三位没有视为 -1
    public static void main(String[] args) {
        int[] dataArray = new int[]{12,1,23,24,235,237,231,571,575,57};
        //获取最大位数
        int maxSize = getMaxSize(dataArray);
        
        System.out.println("maxSize:"+maxSize);
        
        //转化成String类型二维数组
        
        String[][] datas = getTwoDimensionalArray(maxSize,dataArray);
        //排序前打印
        System.out.println("排序前打印");
        printTwoDimensionalArray(datas);
        
        for(int i=0; i<maxSize; i++){
            
            paixu(i,datas);
        }
        System.out.println("--------------------------------------");
        //排序后打印
        System.out.println("排序后打印");
        printTwoDimensionalArray(datas);
    }
    /**
     * 功能：对二维数组中按某一列进行排序
     * @param sortArrayIndex
     * @param sortArray
     */
    public static void paixu(int sortArrayIndex, String[][] sortArray){
        //采用冒泡法对某一列排序
        //首先需要比较次数为 sortArray.length-1次，因为每次比较都会沉底一个 索引从 1开始
        //然后对应每一次沉底的比较次数为 第一次：sortArray.length-1次，第二次:sortArray.length-2次
        //得出第n次：sortArray.length-n次 ,索引从0开始的话，就得是 <
        //然后对比 正在比较的两个数，比较大的排在前面
        
        for(int compareCount = 1; compareCount <= sortArray.length -1; compareCount++){
            for(int n=0; n<sortArray.length - compareCount; n ++){
                //判断前一个和当前是否相等，如果相等，则调换
                
                //如果不等则不动
                int nAll = Integer.valueOf(sortArray[n][sortArrayIndex]);
                int n1All = Integer.valueOf(sortArray[n+1][sortArrayIndex]);
                
                if(nAll < n1All){
                    if(sortArrayIndex>0){
                        if(Integer.valueOf(sortArray[n][sortArrayIndex-1])
                                == Integer.valueOf(sortArray[n+1][sortArrayIndex-1])){
                            
                            String[] temp = sortArray[n];
                            sortArray[n] = sortArray[n+1];
                            sortArray[n+1] = temp;
                        }
                    }else{
                        String[] temp = sortArray[n];
                        sortArray[n] = sortArray[n+1];
                        sortArray[n+1] = temp;
                    }
                }
            }
            
        }
        
    }
    public static int getMaxSize(int[] sortArray){
        int maxSize = 0;
        for(int i=0; i<sortArray.length; i++){
            int currentSize = 0;
            int data = sortArray[i];
            do{
                data = data/10;
                currentSize ++;
            }while(data >= 10);
            
            if(data > 0){
                currentSize ++;
            }
            if(currentSize > maxSize){
                maxSize = currentSize;
            }
        }
        
        return maxSize;
    }
    
    //转化成String类型二维数组
    public static String[][] getTwoDimensionalArray(int maxSize,int[] dataArray){
        String[] dataStrArray = new String[dataArray.length];
        for(int i =0;i<dataArray.length;i++){
            dataStrArray[i] = String.valueOf(dataArray[i]);
        }
        
        String[][] datas = new String[dataArray.length][maxSize];
        for(int i=0; i<dataStrArray.length; i++ ){
            String currentStr = dataStrArray[i];
            for(int j=0; j<maxSize;j++){//最大size
                if(dataStrArray[i].length()>= j+1){
                    datas[i][j] = String.valueOf(currentStr.charAt(j));
                }else{
                    datas[i][j] = "-1";
                }
            }
        }
        return datas;
    }
    public static void printTwoDimensionalArray(String[][] datas){
        for(int i=0;i<datas.length;i++){
            for(int j=0;j<datas[i].length; j++){
                if(datas[i][j] != "-1"){
                    System.out.print(datas[i][j]);
                }
            }
            System.out.println();
        }
    }
}