二维数组按指定的列排序问题

 写一个 Java 程序，实现对一个规则二维数组按 指定的列 进行排序？
     a为二维数组，sortCols是要按第几列排序，sortord 用于指定排序方式 
     你可以约定 true 为升序，false 为降序 
     必要的时候可以补充其它方法，然后在 sortIntArrays 中调用 
     要求排序后，不能破坏原有的数据结构！ 
     如  { 12, 34, 68, 32, 9, 12, 545 } 不论排到了第几个，这个小数组中的数据是不能变化的 
     换言之就是根据某个数排序，比如 34 ，该小数组的其他的数据跟着一起变动 
     
    public void sortIntArrays( int[][] a , String sortCols , boolean sortord ) 
    {
         //补充代码
    }
    
    int array[][] = new int[][] {    
                                 { 12, 34, 68, 32, 9, 12, 545 },    
                                 { 34, 72, 82, 57, 56, 0, 213 },    
                                 { 12, 34, 68, 32, 21, 945, 23 },    
                                 { 91, 10, 3, 2354, 73, 34, 18 },    
                                 { 12, 83, 189, 26, 27, 98, 33 },    
                                 { 47, 23, 889, 24, 899, 23, 657 },    
                                 { 12, 34, 68, 343, 878, 235, 768 },    
                                 { 12, 34, 98, 56, 78, 12, 546 },    
                                 { 26, 78, 2365, 78, 34, 256, 873 }  
                          };  
    对于以上数组，按照最后一列排序(升序)后的结果为：
    { 91, 10, 3, 2354, 73, 34, 18 }
    { 12, 34, 68, 32, 21, 945, 23 }
    { 12, 83, 189, 26, 27, 98, 33 }
    { 34, 72, 82, 57, 56, 0, 213 }
    { 12, 34, 68, 32, 9, 12, 545 }
    { 12, 34, 98, 56, 78, 12, 546 }
    { 47, 23, 889, 24, 899, 23, 657 }
    { 12, 34, 68, 343, 878, 235, 768 }
    { 26, 78, 2365, 78, 34, 256, 873 }

解决方案 »

  1.   


    package javaoop;
    import java.util.Arrays;public class TestPaiXun2Wei { public static void main(String[] args) {
    int array[][] = new int[][] { { 12, 34, 68, 32, 9, 12, 545 },
    { 34, 72, 82, 57, 56, 0, 213 },
    { 12, 34, 68, 32, 21, 945, 23 },
    { 91, 10, 3, 2354, 73, 34, 18 }, 
    { 12, 83, 189, 26, 27, 98, 33 },
    { 47, 23, 889, 24, 899, 23, 657 },
    { 12, 34, 68, 343, 878, 235, 768 },
    { 12, 34, 98, 56, 78, 12, 546 },
    { 26, 78, 2365, 78, 34, 256, 873 } 
    };
    PaiXun2Wei a =new PaiXun2Wei();
    a.sortIntArrays(array, "0", true);
    }}class PaiXun2Wei {
    // 主方法
    public void sortIntArrays(int[][] a, String sortCols, boolean sortord) {
    if (sortord == true) {// 升序
    this.up(a, sortCols);

    } else if (sortord == false) {// 降序
    this.down(a, sortCols);
    }
    }

    // 上升排序（由小到大）
    public void up(int[][] a, String sortCols) {
    int[][]aa={};//用来存放排序后的a[][]
    int[] b = {};// 存放需要排序列的数组
    int[] c ={};// 存放b[]升序后的数组
    int[] z = {};// 存放排序后数组元素原来所在数组的下标
    for (int i = 0; i < 9; i++) {//提取需要排序的一列存到b[]
    b[i] = a[i][Integer.parseInt(sortCols)];
    }
    for(int i=0;i<b.length;i++){//复制b[]
    c[i]=b[i];
    }
    Arrays.sort(c);// 升序排列    为了得到排序后元素 排序前的下标z[]
    for (int i = 0;i<c.length; i++) {
    for (int j = 0;j<c.length; j++) {
    if (c[i] == b[j]) {
    z[i] = j;
    b[j] =-999999;
    break;
    } else {
    continue;
    }
    }
    }
    for(int i=0;i<a.length;i++){//建立aa[][]存放排序后的a[][] 并打印
    for(int j=0;j<a[0].length;j++){
    aa[i][j]=a[z[i]][j];//利用z[]下标数组排序
    System.out.print(aa[i][j]+"\t");
    }
    System.out.println();
    }

    } // 下降排序（由大到小）
    public void down(int[][] a, String sortCols) {
    int[][]aa={};
    int[] z = {};// 存放排序后数组元素原来所在数组的下标
    int[] b = {};// 存放需要排序列的数组
    int[] d ={};// 存放b[]升序后的数组
    int[] c ={};// 存放b[]降序后的数组
    for (int i = 0; i < 9; i++) {
    b[i] = a[i][Integer.parseInt(sortCols)];
    }
    for(int i=0;i<b.length;i++){
    d[i]=b[i];
    }
    Arrays.sort(d);// 升序排列
    for (int i = 0,j = c.length - 1; i < c.length; i++,j--) {// 升序变降序
    c[i]=d[j];
    }
    for (int i = 0;i<c.length; i++) {
    for (int j = 0;j<c.length; j++) {
    if (c[i] == b[j]) {
    z[i] = j;
    b[j] =-999999;
    break;
    } else {
    continue;
    }
    }
    }
    for(int i=0;i<a.length;i++){
    for(int j=0;j<a[0].length;j++){
    aa[i][j]=a[z[i]][j];
    System.out.print(aa[i][j]+"\t");
    }
    System.out.println();
    }
    }}
    这是我写的  报错哦！新手求帮忙！
    java.lang.UnsupportedClassVersionError:javaoop/TestPaiXun2Wei : Unsupported major.minor version 51.0
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClassCond(ClassLoader.java:631)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:615)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:141)
    at java.net.URLClassLoader.defineClass(URLClassLoader.java:283)
    at java.net.URLClassLoader.access$000(URLClassLoader.java:58)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:197)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:247)
    Exception in thread "main" 
      

  2.   

    根据楼主的代码自己写了下import java.util.*;public class xuanzhe { public static void main(String[] args) {

    Map<String,int[]> m = new HashMap<String,int[]>();
    int array[][] = new int[][] { { 12, 34, 68, 32, 9, 12, 545 },
    { 34, 72, 82, 57, 56, 0, 213 },
    { 12, 34, 68, 32, 21, 945, 23 },
    { 91, 10, 3, 2354, 73, 34, 18 },
    { 12, 83, 189, 26, 27, 98, 33 },
    { 47, 23, 889, 24, 899, 23, 657 },
    { 12, 34, 68, 343, 878, 235, 768 },
    { 12, 34, 98, 56, 78, 12, 546 },
    { 26, 78, 2365, 78, 34, 256, 873 } };
    int[] a = new int[array.length];
    for (int n = 0; n < array.length; n++) {
    a[n] = array[n][array[n].length - 1];
    m.put(a[n]+"", array[n]);
    }
    xuanzheSort(a,m);
    } public static void xuanzheSort(int[] a,Map<String,int[]> m) { for (int i = 0; i < a.length; i++) {
    int temp = a[i];
    for (int j = i + 1; j < a.length; j++) {
    int swap = a[j];
    if (temp > a[j]) {
    a[i] = swap;
    a[j] = temp;
    temp = swap;
    }
    }
    int[] d=m.get(temp+"");
    for(int k=0;k<d.length;k++){
    System.out.print(d[k]+" ");

    }
    System.out.println();
    }
    }
    }结果自己发现了问题啊
    输出数组时为[I@de6ced
    想了一下感觉没什么办法能直接输出数组的 所以只能for循环了
    看了楼主的代码也是for写的 不知道有什么办法能直接搞出数组
    代码楼主可以参考下
      

  3.   


    //= =
        public static void main(String[] args) {
            int array[][] = new int[][]{
                {12, 34, 68, 32, 9, 12, 545},
                {34, 72, 82, 57, 56, 0, 213},
                {12, 34, 68, 32, 21, 945, 23},
                {91, 10, 3, 2354, 73, 34, 18},
                {12, 83, 189, 26, 27, 98, 33},
                {47, 23, 889, 24, 899, 23, 657},
                {12, 34, 68, 343, 878, 235, 768},
                {12, 34, 98, 56, 78, 12, 546},
                {26, 78, 2365, 78, 34, 256, 873}
            };
            sortIntArrays(array, 6, true);
            for (int i = 0; i < array.length; i++) {
                for (int j = 0; j < array[0].length; j++) {
                    System.out.print(array[i][j] + "\t");
                }
                System.out.println();
            }
        }    public static void sortIntArrays(int[][] array, final int sortCols, final boolean sortord) {
             java.util.Arrays.sort(array,new java.util.Comparator() {            @Override
                public int compare(Object o1, Object o2) {
                    //长度没sortCols长的排前面
                    if(o1==null&&o2==null)
                        return 0;
                    if(o1==null&&o2!=null)
                        return sortord?1:-1;
                    if(o1!=null&&o2==null)
                        return sortord?-1:1;
                    int[]st1=(int[]) o1;
                    int[]st2=(int[]) o2;
                    if(st1.length<sortCols&&st2.length<sortCols)
                        return 0;
                    if(st1.length<sortCols&&st2.length>=sortCols)
                        return sortord?1:-1;
                    if(st1.length>=sortCols&&st2.length<sortCols)
                        return sortord?-1:1;
                    //如果二个长度都足够
                    return sortord?st1[sortCols]-st2[sortCols]:st2[sortCols]-st1[sortCols];
                }
            });
        }