Java--数组排序算法

程序常用的排序方法有冒泡排序、选择排序和快速排序等

除sort()方法外：

一、冒泡排序

public class bubbleSort {
    public static void main(String[] args) {
    	int arr[] = new int[] {67,89,29,18,79,83};
    	bubbleSort sorter = new bubbleSort();
    	sorter.sort(arr);
    }
    
    public void sort(int[] array) {
    	int length = array.length;
    	for(int i=1;i<length;i++) {
    		for(int j=0;j<length-i;j++) {
    			if(array[j]>array[j+1]) {
    				int temp = array[j];
    				array[j] = array[j+1];
    				array[j+1] = temp;
    			}
    		}
    	}
    	showArray(array);
    }

    public void showArray(int[] array) {
    	for(int x:array) {
    		System.out.println(x);
    	}
    }
}

输出结果为：

代码解析：每经过一轮j的for循环，都能保证把当前参与循环的元素（即j循环的循环条件，即索引在length-i之前的元素）中最大的放第（length-i）位上，从第（length-i-1）位往前的元素都不能保证按大小顺序排列，需要再不断经过i的循环，来重复上述过程，以达到每次循环中的最大元素都在（length-i）位上，最终整个数列都是按从小到大顺序排列的

（个人认为还有一种类似的“下降冒泡排序法”，代码类似，为：

public class bubbleSort {
    public static void main(String[] args) {
    	int arr[] = new int[] {67,89,29,18,79,83};
    	bubbleSort sorter = new bubbleSort();
    	sorter.sort(arr);
    }
    
    public void sort(int[] array) {
    	int length = array.length;
    	for(int i=1;i<length;i++) {
    		for(int j=i;j>0;j--) {
    			if(array[j]>=array[j-1]) {
    				break;
    			}
    			if(array[j]<array[j-1]) {
    				int temp = array[j];
    				array[j] = array[j-1];
    				array[j-1] = temp;
    			}
    		}
    	}
    	showArray(array);
    }
    
    public void showArray(int[] array) {
    	for(int x:array) {
    		System.out.println(x);
    	}
    }
}

，输出结果相同

代码解析：每次i循环，索引在i之前的元素参与当前的j循环，每次循环能保证当前参与循环的i+1个元素（即j循环的循环条件）都按大小顺序排列，因为上一次的i循环能保证除参与当前循环的最后一个元素外，前面的元素已经按大小顺序排列，则当[j]已经大于[j-1]时，就已经可以跳出当前的j循环，进行下一次i循环）

二、直接选择排序

为选择排序的一种

public class selectSort {
	public static void main(String[] args) {
		int arr[] = new int[] {20,19,67,89,27,89,19,93};
		selectSort sorter = new selectSort();
		sorter.sort(arr);
	}
	
	public void sort(int[] array) {
		int length = array.length;
		for(int i=0;i<length;i++) {
			int index = 0;
			for(int j=1;j<length-i;j++) {
				if(array[index]<array[j]) {
					index = j;
				}
			}
			int temp = array[length-i-1];
			array[length-i-1] = array[index];
			array[index] = temp;
		}
		showArray(array);
	}
	
	public void showArray(int[] array) {
		for(int x:array) {
			System.out.println(x);
		}
	}
}

相比冒泡排序算法，选择排序算法最大的不同是，比起每次直接交换元素，它选择在每次循环过程中仅交换元素的索引值，在每次循环的最后，索引处元素即为最大元素，再将该元素一次性与第（length-i）位元素交换。元素交换次数少，效率高。

输出结果为：

三、反转排序（以相反顺序重新排列数组）

public class reverseSort {
	public static void main(String[] args) {
		int arr[] = new int[] {20,19,67,89,27,89,19,93};
		reverseSort sorter = new reverseSort();
		sorter.sort(arr);
	}
	
	public void sort(int[] array) {
		int length=array.length;
		for(int i=0;i<length/2;i++) {
			int temp = array[i];
			array[i] = array[length-i-1];
			array[length-i-1] = temp;
		}
		showArray(array);
	}
	
	public void showArray(int[] array) {
		for(int x:array) {
			System.out.println(x);
		}
	}

}

不多说，和上学期cpp期末考试题一样。就是注意是交换array[length-i-1]