二维数组的排序

Question

呵呵惭愧，java里的list我还没学呢，值知道c的链表。

Answer 1

1、可以将二维数组转为list，然后排序
2、也可以直接进行排序，只是循环里面的条件改一下。
                int[][] a={{1,3,4,5,3,6,7},{3,4,6,5},{9,3,5,6,7,8,4},{1,3},{2,3,4,56,3555,4}};
for(int i=0;i<a.length;i++)
{
for(int j=0;j<a[i].length;j++)
{
//你的排序算法
}
}

Answer 2

楼上正解!用length这个属性解决

Answer 3

用这个length属性无法控制列的排列。行的排列的时候可以用length属性。列排列的时候好像无法控制的。不知道你的思路是怎么样的。

Answer 4

下面这个是针对整齐的数组的排列，这种情况行数和列数是固定的，访问不会越界，但是参差不齐的二维数组，行可以用
a[i].length来控制，但是，列访问就不好控制了。a[i].length也只能得到各行的长度。package Class ;
class TestDoubleDimension 
{
public static void main(String[] args) 
{
int[][] a={{1,2,3,4},{5,6,1,-9},{3,30,-89,36},{7,3,98,0},{1,0,0,0}} ;
PrintoutDoubleDimension(a) ;
System.out.println("**************************************") ;
PrintoutDimensionH(a) ;
System.out.println("**************************************") ;
PrintoutDimensionL(a) ;
System.out.println("**************************************") ;
SortDoubleDimension(a) ;
System.out.println("**************************************") ;
PrintoutDoubleDimension(a) ; }


public static void PrintoutDimensionH(int[][] a)
{
  for (int i=0;i<4 ;i++ )
System.out.print(a[1][i]+"\t");
  System.out.print("\n") ; }
public static void PrintoutDimensionL(int[][] a)
{
  for (int i=0;i<5 ;i++ )
System.out.print(a[i][1]+"\t");
  System.out.print("\n") ; }
public static void PrintoutDoubleDimension(int[][] a)
{
  for (int i=0;i<5 ;i++ )
{for(int j=0;j<4;j++)
System.out.print(a[i][j]+"\t");
System.out.print("\n");
}
} public static void SortDoubleDimension(int[][] a)
{
int Hangshu =5 ;
int Lieshu =4 ;
for (int Hanghao =0;Hanghao<Hangshu ;Hanghao++ )
{
for (int k=0;k<Lieshu-1 ;k++ )
{for (int n=k+1;n<Lieshu ;n++ )
  {
if(a[Hanghao][k]<a[Hanghao][n])
  {
int temp =a[Hanghao][k] ;
a[Hanghao][k]=a[Hanghao][n] ;
a[Hanghao][n]=temp ;
  }
  }
}
}
for (int i =0;i<Lieshu ;i++ )
{
for (int k=0;k<Hangshu-1 ;k++ )
for (int n=k+1;n<Hangshu ;n++ )
  {

if(a[k][i]<a[n][i])
  {
int temp =a[k][i] ;
a[k][i]=a[n][i] ;
a[n][i]=temp ;
  }
  }

}
}
}
/*程序心得：对于二维数组a[5][4]
一，a[1][i]表示第2行的各个元素：for (int i=0;i<4 ;i++ )
System.out.print(a[1][i]+"\t");
a[i][1]表示第2列的各个元素：for (int i=0;i<5 ;i++ )
System.out.print(a[i][1]+"\t");二，基于“一”的事实，我们可以将二维数组独立出来作为两个一维数组类处理
如a[0][i]:去便利第1行的各个元素：for (int i=0;i<4 ;i++ )
     System.out.print(a[0][i]+"\t");
如a[i][0]:去便利第1列的各个元素：for (int i=0;i<5 ;i++ )
 System.out.print(a[i][0]+"\t");
三，对于二维数组的排序可以将其独立出来作为一维数组各个处理排序
 先排序行：
int h =5 ;
int l =4 ;
for (int i =0;i<h ;i++ )//i作为行号，针对每一行作为一个一维数组处理
{
for (int k=0;k<l-1 ;k++ )//针对每一行作为一个一维数组处理。
{for (int n=k+1;n<l ;n++ )
  {
if(a[i][k]<a[i][n])
  {
int temp =a[i][k] ;
a[i][k]=a[i][n] ;
a[i][n]=temp ;
  }
  }
}
} 再排序列：
for (int i =0;i<l ;i++ )//i作为列号，针对每一列作为一个一维数组处理。
{
for (int k=0;k<h-1 ;k++ )//针对每一列作为一个一维数组处理。
{for (int n=k+1;n<h ;n++ )
  {
if(a[k][i]<a[n][i])
  {
int temp =a[k][i] ;
a[k][i]=a[n][i] ;
a[n][i]=temp ;
  }
  }
}
}思想总结：
将二维数组的每一行当做一个一维数组处理：a[0][HangHao]
在外层家变量HangHao控制行号for (int HangHao =0;HangHao<Hangshu ;HangHao++ )
{
//一维数组的处理语句。
}
每一列当做一个一维数组处理: a[LieHao][0]
在外层家变量LieHao控制行号for (int LieHao =0;LieHao<Hangshu ;LieHao++ )
{
//一维数组的处理语句。
}
*/

Answer 5

import java.util.Arrays;public class Main {
public static void main(String[] args) {
int[][] a={{1,3,4,5,3,6,7},{3,4,6,5},{9,3,5,6,7,8,4},{1,3},{2,3,4,56,3555,4}};
for(int i=0;i<a.length;i++){
Arrays.sort(a[i]);
}
//只是输出了二维数组中第一个数组的值，结果为1,3,3,4,5,6,7
for(int i=0;i<a[0].length;i++)
System.out.print(a[0][i]+"\t");
}
}

Answer 6

直接循环    Arrays.sort(a[i])

Answer 7

大神回复果然性情啊，叫我情何以堪！
比如  int[][] a={{3,4,6,5},{9,3,5,6,7,8,4},{1,3}}这个数组
我要它排序后的结果是：1,3,3,3,4,4,5,5,6,6,7,8,9

Answer 8

谢谢大神们的提醒，通过引入一维数组的方式再导入的方法实现了参差不齐的数组的排序，谢谢~！
/**
程序功能：借助一个数组缓存来给参差不齐的二维数组进行排序
思路：
1：将二维数组逐个出入一个一维数组中
2：排序该一维数组
3：再将这个一维数组元素逐个导入二维数组中*/
package Practiseday08Class ;
class  TestSortDoubleArray
{
public static void main(String[] args) 
{
int[][] arr = {{1,2,-6,-4,3},{-58,34,1,3,5},{8,-3},{2,7,98,123,98,234,987}};
sop(arr);
System.out.println("*********************************************************") ;
srotDoubleArray(arr);
sop(arr);
} public static void srotDoubleArray(int[][] arr)
{

int sum = 0 ;
for(int i=0;i<4;i++)
sum+=arr[i].length ;
int[] cache = new int[sum] ;
int index = 0 ;
for(int i=0;i<4;i++)//将二维数组元素转存到一个一维数组中
for(int j=0;j<arr[i].length;j++)
cache[index++]=arr[i][j] ; for (int i=0;i<cache.length-1 ;i++ )//排序所得一维数组
{for (int j=i+1;j<cache.length;j++)
if(cache[i]>cache[j])
{
int temp = cache[i] ;
cache[i] = cache[j] ;
cache[j] = temp ;
}
}
//现在再将排序到的一维数组重新导入二维数组中
int m = 0 ;
for(int n=0;n<4;n++)//该二维数组有4行已知。
for(int k=0;k<arr[n].length;k++)//每行的元素个数。
arr[n][k] = cache[m++] ;

 }
public static void sop(int[][] arr)
{for(int i=0;i<4;i++)
{
for(int j=0;j<arr[i].length;j++)
System.out.print(arr[i][j]+"\t");
System.out.print("\n");
}
}

}D:\wfjava\Practiseday08soc>java Practiseday08Class.TestSortDoubleArray
1       2       -6      -4      3
-58     34      1       3       5
8       -3
2       7       98      123     98      234     987
*********************************************************
-58     -6      -4      -3      1
1       2       2       3       3
5       7
8       34      98      98      123     234     987D:\wfjava\Practiseday08soc>