java二維數組的排序

Ⅰ java中二維數組排序的問題

文章
java數組排序2009年09月12日 星期六 下午 12:55import java.util.Random;

/**
* 排序測試類
*
* 排序演算法的分類如下：
* 1.插入排序（直接插入排序、折半插入排序、希爾排序）；
* 2.交換排序（冒泡泡排序、快速排序）；
* 3.選擇排序（直接選擇排序、堆排序）；
* 4.歸並排序；
* 5.基數排序。
*
* 關於排序方法的選擇：
* (1)若n較小(如n≤50)，可採用直接插入或直接選擇排序。
* 當記錄規模較小時，直接插入排序較好；否則因為直接選擇移動的記錄數少於直接插人，應選直接選擇排序為宜。
* (2)若文件初始狀態基本有序(指正序)，則應選用直接插人、冒泡或隨機的快速排序為宜；
* (3)若n較大，則應採用時間復雜度為O(nlgn)的排序方法：快速排序、堆排序或歸並排序。
*
* @author WangRuifeng
*/
public class SortTest {

/**
* 初始化測試數組的方法
* @return 一個初始化好的數組
*/
public int[] createArray() {
Random random = new Random();
int[] array = new int[10];
for (int i = 0; i < 10; i++) {
array[i] = random.nextInt(100) - random.nextInt(100);//生成兩個隨機數相減，保證生成的數中有負數
}
System.out.println("==========原始序列==========");
printArray(array);
return array;
}

/**
* 列印數組中的元素到控制台
* @param source
*/
public void printArray(int[] source) {
for (int i : source) {
System.out.print(i + " ");
}
System.out.println();
}

/**
* 交換數組中指定的兩元素的位置
* @param source
* @param x
* @param y
*/
private void swap(int[] source, int x, int y) {
int temp = source[x];
source[x] = source[y];
source[y] = temp;
}

/**
* 冒泡排序----交換排序的一種
* 方法：相鄰兩元素進行比較，如有需要則進行交換，每完成一次循環就將最大元素排在最後（如從小到大排序），下一次循環是將其他的數進行類似操作。
* 性能：比較次數O(n^2),n^2/2；交換次數O(n^2),n^2/4
*
* @param source 要排序的數組
* @param sortType 排序類型
* @return
*/
public void bubbleSort(int[] source, String sortType) {
if (sortType.equals("asc")) { //正排序，從小排到大
for (int i = source.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (source[j] > source[j + 1]) {
swap(source, j, j + 1);
}
}
}
} else if (sortType.equals("desc")) { //倒排序，從大排到小
for (int i = source.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (source[j] < source[j + 1]) {
swap(source, j, j + 1);
}
}
}
} else {
System.out.println("您輸入的排序類型錯誤！");
}
printArray(source);//輸出冒泡排序後的數組值
}

/**
* 直接選擇排序法----選擇排序的一種
* 方法：每一趟從待排序的數據元素中選出最小（或最大）的一個元素， 順序放在已排好序的數列的最後，直到全部待排序的數據元素排完。
* 性能：比較次數O(n^2),n^2/2
* 交換次數O(n),n
* 交換次數比冒泡排序少多了，由於交換所需CPU時間比比較所需的CUP時間多，所以選擇排序比冒泡排序快。
* 但是N比較大時，比較所需的CPU時間佔主要地位，所以這時的性能和冒泡排序差不太多，但毫無疑問肯定要快些。
*
* @param source 要排序的數組
* @param sortType 排序類型
* @return
*/
public void selectSort(int[] source, String sortType) {

if (sortType.equals("asc")) { //正排序，從小排到大
for (int i = 0; i < source.length; i++) {
for (int j = i + 1; j < source.length; j++) {
if (source[i] > source[j]) {
swap(source, i, j);
}
}
}
} else if (sortType.equals("desc")) { //倒排序，從大排到小
for (int i = 0; i < source.length; i++) {
for (int j = i + 1; j < source.length; j++) {
if (source[i] < source[j]) {
swap(source, i, j);
}
}
}
} else {
System.out.println("您輸入的排序類型錯誤！");
}
printArray(source);//輸出直接選擇排序後的數組值
}

/**
* 插入排序
* 方法：將一個記錄插入到已排好序的有序表（有可能是空表）中,從而得到一個新的記錄數增1的有序表。
* 性能：比較次數O(n^2),n^2/4
* 復制次數O(n),n^2/4
* 比較次數是前兩者的一般，而復制所需的CPU時間較交換少，所以性能上比冒泡排序提高一倍多，而比選擇排序也要快。
*
* @param source 要排序的數組
* @param sortType 排序類型
*/
public void insertSort(int[] source, String sortType) {
if (sortType.equals("asc")) { //正排序，從小排到大
for (int i = 1; i < source.length; i++) {
for (int j = i; (j > 0) && (source[j] < source[j - 1]); j--) {
swap(source, j, j - 1);
}
}
} else if (sortType.equals("desc")) { //倒排序，從大排到小
for (int i = 1; i < source.length; i++) {
for (int j = i; (j > 0) && (source[j] > source[j - 1]); j--) {
swap(source, j, j - 1);
}
}
} else {
System.out.println("您輸入的排序類型錯誤！");
}
printArray(source);//輸出插入排序後的數組值
}

/**
* 反轉數組的方法
* @param source 源數組
*/
public void reverse(int[] source) {

int length = source.length;
int temp = 0;//臨時變數

for (int i = 0; i < length / 2; i++) {
temp = source[i];
source[i] = source[length - 1 - i];
source[length - 1 - i] = temp;
}
printArray(source);//輸出到轉後數組的值
}

/**
* 快速排序
* 快速排序使用分治法（Divide and conquer）策略來把一個序列（list）分為兩個子序列（sub-lists）。
* 步驟為：
* 1. 從數列中挑出一個元素，稱為 "基準"（pivot），
* 2. 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分割之後，該基準是它的最後位置。這個稱為分割（partition）操作。
* 3. 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
* 遞回的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞回下去，但是這個演算法總會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。
* @param source 待排序的數組
* @param low
* @param high
* @see SortTest#qsort(int[], int, int)
* @see SortTest#qsort_desc(int[], int, int)
*/
public void quickSort(int[] source, String sortType) {
if (sortType.equals("asc")) { //正排序，從小排到大
qsort_asc(source, 0, source.length - 1);
} else if (sortType.equals("desc")) { //倒排序，從大排到小
qsort_desc(source, 0, source.length - 1);
} else {
System.out.println("您輸入的排序類型錯誤！");
}
}

/**
* 快速排序的具體實現，排正序
* @param source
* @param low
* @param high
*/
private void qsort_asc(int source[], int low, int high) {
int i, j, x;
if (low < high) { //這個條件用來結束遞歸
i = low;
j = high;
x = source[i];
while (i < j) {
while (i < j && source[j] > x) {
j--; //從右向左找第一個小於x的數
}
if (i < j) {
source[i] = source[j];
i++;
}
while (i < j && source[i] < x) {
i++; //從左向右找第一個大於x的數
}
if (i < j) {
source[j] = source[i];
j--;
}
}
source[i] = x;
qsort_asc(source, low, i - 1);
qsort_asc(source, i + 1, high);
}
}

/**
* 快速排序的具體實現，排倒序
* @param source
* @param low
* @param high
*/
private void qsort_desc(int source[], int low, int high) {
int i, j, x;
if (low < high) { //這個條件用來結束遞歸
i = low;
j = high;
x = source[i];
while (i < j) {
while (i < j && source[j] < x) {
j--; //從右向左找第一個小於x的數
}
if (i < j) {
source[i] = source[j];
i++;
}
while (i < j && source[i] > x) {
i++; //從左向右找第一個大於x的數
}
if (i < j) {
source[j] = source[i];
j--;
}
}
source[i] = x;
qsort_desc(source, low, i - 1);
qsort_desc(source, i + 1, high);
}
}

/**
* 二分法查找
* 查找線性表必須是有序列表
*
* @param source
* @param key
* @return
*/
public int binarySearch(int[] source, int key) {
int low = 0, high = source.length - 1, mid;
while (low <= high) {
mid = (low + high) >>> 1; //相當於mid = (low + high) / 2，但是效率會高些
if (key == source[mid]) {
return mid;
} else if (key < source[mid]) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return -1;
}

public static void main(String[] args) {
SortTest sortTest = new SortTest();

int[] array = sortTest.createArray();

System.out.println("==========冒泡排序後(正序)==========");
sortTest.bubbleSort(array, "asc");
System.out.println("==========冒泡排序後(倒序)==========");
sortTest.bubbleSort(array, "desc");

array = sortTest.createArray();

System.out.println("==========倒轉數組後==========");
sortTest.reverse(array);

array = sortTest.createArray();

System.out.println("==========選擇排序後(正序)==========");
sortTest.selectSort(array, "asc");
System.out.println("==========選擇排序後(倒序)==========");
sortTest.selectSort(array, "desc");

array = sortTest.createArray();

System.out.println("==========插入排序後(正序)==========");
sortTest.insertSort(array, "asc");
System.out.println("==========插入排序後(倒序)==========");
sortTest.insertSort(array, "desc");

array = sortTest.createArray();
System.out.println("==========快速排序後(正序)==========");
sortTest.quickSort(array, "asc");
sortTest.printArray(array);
System.out.println("==========快速排序後(倒序)==========");
sortTest.quickSort(array, "desc");
sortTest.printArray(array);

System.out.println("==========數組二分查找==========");
System.out.println("您要找的數在第" + sortTest.binarySearch(array, 74) + "個位子。（下標從0計算）");
}
}

字元串排序：

public class StringSort {
public static void main(String []args) {
String[] s={"a","b","c","d","m","f"};
for(int i=s.length-1;i>=1;i--){
for(int j=0;j<=i-1;j++) {
if(s[j].compareTo(s[j+1])<0) {
String temp=null;
temp=s[j];
s[j]=s[j+1];
s[j+1]=temp;
}
}
}
for(String a:s){
System.out.print(a+" ");
}
}
}
比較字元串的實質是比較字元串的字母，首字母相同，比較下一個，然後又相同的話，再下一個....所以你可以先用substring();截出第一個字元，然後再比較，相同的再截第二個，.....

hope some help for you

Ⅱ java中怎麼對二維數組的列排序

這個就是可以直接排組的，根據數組的定義來。如a[][]={(1,2),(3,4)......}類似這些

Ⅲ java中怎麼進行二維數組的行排序

比如一個二維int數組 int[][] a={{...},{...},{....},{...}};
進行遍歷的話
//這是第一層遍歷-行遍歷
for(int i=0;i<a.length;i++){
//這是第二層的遍歷-列遍歷

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

}

Ⅳ java：已知我有一個二維數組，直接輸入全部數據，怎麼對數組的每行進行升序排序

書寫完畢，採納即可。

importjava.util.Arrays;
importjava.util.Comparator;
importjava.util.Scanner;

publicclassYuGiOh
{
	/**
	*數組數據都為為1-11的隨機數
	*/
	privatestaticfinalintRANDOM=11;
	privatestaticfinalStringSEP="";
	privatestaticfinalStringEXIT="x";
	privatestaticfinalStringLINE=System.getProperty("line.separator");

	/**
	*隨機生成row行col列數據，用來測試
	*
	*@paramrow
	*int行
	*@paramcol
	*int列
	*@returnrow行col列的隨機數據
	*/
	publicstaticStringproceNums(introw,intcol)
	{
		StringBuilderbuilder=newStringBuilder();
		for(inti=0;i<row;i++)
		{
			for(intj=0;j<col;j++)
			{
				intnum=(int)(Math.random()*RANDOM)+1;
				Stringtmp=num<10?"0"+num:num+"";
				builder.append(tmp+SEP);
			}
			builder.append(LINE);
		}
		returnbuilder.toString();
	}

	publicstaticStringscan()
	{
		System.out.println("一次性復制黏貼所有數值：(輸入"+EXIT+"退出)");
		StringBuilderbuilder=newStringBuilder();
		Scannerscanner=newScanner(System.in);
		while(scanner.hasNextLine())
		{
			Stringline=scanner.nextLine().trim();
			if(EXIT.equals(line))
			{
				break;
			}
			builder.append(line+LINE);
		}
		scanner.close();
		returnbuilder.toString();
	}

	/**
	*對隨機數據以行為單位自動排序
	*
	*@paramnumbers
	*String隨機數據
	*@paramisAsc
	*int1升序-1降序
	*@return每行排序好的隨機數據
	*/
	publicstaticStringsortNums(Stringnumbers,finalintisAsc)
	{
		StringBuilderbuilder=newStringBuilder();
		Scannerscanner=newScanner(numbers);
		while(scanner.hasNextLine())
		{
			Stringline=scanner.nextLine().trim();
			String[]array=line.split("\s+");
			Arrays.sort(array,newComparator<String>()
			{
				@Override
				publicintcompare(Stringo1,Stringo2)
				{
					returnisAsc*o1.compareToIgnoreCase(o2);
				}
			});
			builder.append(Arrays.toString(array).replaceAll("[\[\]\,]","")+LINE);
		}
		scanner.close();
		returnbuilder.toString();
	}

	publicstaticvoidmain(String[]args)
	{
//		Stringnumbers=proceNums(100,5);
//		System.out.println(numbers);
//		System.out.println("-----------------------");
//		System.out.println(sortNums(numbers,1));
		
		Stringnumbers=scan();
		System.out.println(sortNums(numbers,1));
	}
}

Ⅳ java二維數組只對每行的數據進行排序

你可以把二維數組理解成普通的一維數組，只不過這個一維數組的每一個元素又是一個數組。
像遍歷普通數組那樣遍歷二維數組的行，這樣就得到了每一行的數組，然後排序。ok

Ⅵ java 二維數組中裡面的元素從小到大排列（我在線）

你可以先將這個二維數組的數據存在一維數組當中，然後再排序一下，排好序再將數據重新存到ss數組當中。
public static void main(String[] args) throws Exception {
int [][]ss=new int[][]{{23,4,56},{3,12,78,9},{1,21}};
int [][]ret = null;
int[]temp = new int[9];
int index = 0;
for (int i = 0; i < ss.length; i++) {
for (int j = 0; j < ss[i].length; j++) {
temp[index] = ss[i][j];
index++;
}
}
int t;
for (int i = 0; i < temp.length; i++) {
for (int j = 0; j < temp.length; j++) {
if (temp[i] < temp[j]) {
t = temp[i];
temp[i] = temp[j];
temp[j] = t;
}
}
}
int index1 = 0;
for (int i = 0; i < ss.length; i++) {
for (int j = 0; j < ss[i].length; j++) {
ss[i][j] = temp[index1];
index1++;
}
}
for (int i = 0; i < ss.length; i++) {
for (int j = 0; j < ss[i].length; j++) {
System.out.print(ss[i][j] + " ");
}
System.out.println();

}
}
輸出結果：
1 3 4
9 12 21 23
56 78

Ⅶ java二維數組 按某列排序

public class TestSort {
public static void main(String[] args) {
String[][] s = new String[][] { { "01", " 張三", " 男", "28" },
{ "02 ", "李強", " 男", "23" }, { "03 ", "王五", " 男", "26" },
{ "04 ", "李艷 ", "女 ", "25" }, { "05", "張慶", " 男", "22" } };
TestSort ts = new TestSort();
ts.test(s);
ts.display(s);
}

private void display(String[][] s) {
for (int i = 0; i < s.length; i++) {
for (int j = 0; j < s[i].length; j++) {
System.out.print(s[i][j] + " ");
}
System.out.println();
}
}

private void test(String[][] s) {

for (int j = 0; j < s.length ; j++) {
for (int i = 0; i < s.length - 1; i++) {
String[] ss;
if (s[i][3].compareTo(s[i + 1][3]) > 0) {
ss = s[i];
s[i] = s[i + 1];
s[i + 1] = ss;

}
}
}
}

}

Ⅷ Java編程,二維數組排序

並沒有變，只是將二位數組的每行（看成矩陣）作為一維數組進行排序（升序），a[k] （k=0,1,2,3）是每行的首地址

Ⅸ java二維數組選擇排序問題，到了第四個就亂了

你這寫的我表示不能理解:我幫你簡化了你看看吧,我提供了兩種方法,如果一開始你太糾結

我建議你直接使用api比較靠譜,後面學的好了,在回頭專門看這個會很輕松!

1. 方法1就是系統的API,有點就是代碼非常少!

2. 方法2,就是選擇排序,你的要求,不足之處還請指點!

importjava.util.Arrays;
publicclass二維數組排序{
	publicstaticvoidmain(String[]args){
		init();
	}
	//初始化數組!
	privatestaticvoidinit()
	{
		int[][]arr={{10,15,12,13,14,1},{9,8,5,2,7,6},{5,4,3,8,9,10},{25,36,78,69,12,14,25,36}};
		print(arr,"原數組:");
		
		//方法1:api排序!
		sortTest(arr);
		print(arr,"利用API排序");
		
		//方法2:自定義排序!選擇排序!
		custom(arr);
		print(arr,"自定義選擇排序");
	}
	//方法一:利用API排序(代碼簡單)
	privatestaticvoidsortTest(int[][]arr)
	{
		for(inti=0;i<arr.length;i++){
			Arrays.sort(arr[i]);
		}
	}
	//方法二:自定義選擇排序(可以隨意更改排序順序!)
	privatestaticvoidcustom(int[][]arr)
	{
		for(inti=0;i<arr.length;i++){
			for(intx=0;x<arr[i].length-1;x++){
				for(inty=x+1;y<arr[i].length;y++){
					if(arr[i][x]<arr[i][y]){
						swap(arr[i],x,y);
					}
				}
			}
		}
	}
	
	//交換!
	privatestaticvoidswap(int[]arr,intx,inty)
	{
		arr[x]=arr[x]^arr[y];
		arr[y]=arr[x]^arr[y];
		arr[x]=arr[x]^arr[y];
	}

	//列印測試!
	privatestaticvoidprint(int[][]arr,Strings)
	{
		System.out.println(s);
		for(inti=0;i<arr.length;i++){
			for(intj=0;j<arr[i].length;j++){
				System.out.print(arr[i][j]+",");
			}
			System.out.println();
		}
	}
}