Java基本排序

长度为N的数组升序排序

一，冒泡排序

public class BubbleSort {
	private double[] data;

	public BubbleSort(double[] data) {
		this.data = data;
	}

	public void sort(){
		for(int p = data.length - 1 ; p > 0 ; p--){
			for(int i = 0 ; i < p ; i++){
				if(data[i] > data[i+1] ){
					double tmp = data[i];
					data[i] = data[i+1];
					data[i+1] = tmp;
				}
			}
		}
	}

	public void display(){
		for(int i = 0 ; i < data.length ; i++){
			System.out.print(data[i]+" ");
		}
		System.out.print("\n");
	}

	public static void main(String[] args) {
		double[] data = {Math.random(),Math.random(),Math.random(),Math.random()};
		BubbleSort bubbleSort = new BubbleSort(data);
		bubbleSort.display();
		bubbleSort.sort();
		bubbleSort.display();
	}
}

0.4125010895286405 0.1682061731460387 0.5946448214944792 0.2760597727054087
0.1682061731460387 0.2760597727054087 0.4125010895286405 0.5946448214944792

比较次数：第一次比较N-1次，第二次比较N-2次，总比较次数为(N-1) + (N-2) +...+ 1 = (N-1)*N/2

交换次数：如果数组本身为降序排序，则需交换(N-1)*N/2次，如果数组本身为升序排序，则需交换0次，如果数据是随机的，大约需要交换(N-1)*N/4次

时间复杂度：(N-1)*N/2 + (N-1)*N/4，总得来说为O(N*N)

二，选择排序

public class SelectSort {
	private double[] data;

	public SelectSort(double[] data){
		this.data = data;
	}

	public void sort(){
		for(int i = 0 ; i < data.length ; i++){
			int flag = i;
			for(int j = i + 1 ; j < data.length ; j++){
				if( data[j] < data[flag]){
					flag = j;
				}
			}
			double tmp = data[i];
			data[i] = data[flag];
			data[flag] = tmp;
		}
	}

	public void display(){
		for(int i = 0 ; i < data.length ; i++){
			System.out.print(data[i]+" ");
		}
		System.out.print("\n");
	}

	public static void main(String[] args) {
		double[] data = {Math.random(),Math.random(),Math.random(),Math.random()};
		SelectSort selectSort = new SelectSort(data);
		selectSort.display();
		selectSort.sort();
		selectSort.display();
		}
}

0.8992760265680794 0.36366208723355853 0.5105026583966352 0.27067878126430966
0.27067878126430966 0.36366208723355853 0.5105026583966352 0.8992760265680794

比较次数：第一次比较N-1次，第二次比较N-2次，总比较次数为(N-1) + (N-2) +...+ 1 = (N-1)*N/2

交换次数：如果数组本身为降序排序，则需交换N次，如果数组本身为升序排序，则需交换0次，如果数据是随机的，大约需要交换N/2次

时间复杂度：(N-1)*N/2 + N/2，总得来说为O(N*N)，但是会比冒泡排序快

三，插入排序

public class InsertSort {
	private double[] data;

	public InsertSort(double[] data) {
		this.data = data;
	}

	public void sort(){
		for(int i = 1 ; i < data.length ; i++){
			double tmp = data[i];
			int insertPoint = i;
			while(insertPoint > 0 && data[insertPoint-1] > tmp){
				data[insertPoint] = data[insertPoint-1];
				--insertPoint;
			}
			if(insertPoint < i){
				data[insertPoint] = tmp;
			}
		}
	}

	public void display(){
		for(int i = 0 ; i < data.length ; i++){
			System.out.print(data[i]+" ");
		}
		System.out.print("\n");
	}

	public static void main(String[] args) {
		double[] data = {Math.random(),Math.random(),Math.random(),Math.random()};
		InsertSort insertSort = new InsertSort(data);
		insertSort.display();
		insertSort.sort();
		insertSort.display();
	}
}

0.25855304984386873 0.5035006863323077 0.8986028814892651 0.724194607320699
0.25855304984386873 0.5035006863323077 0.724194607320699 0.8986028814892651

比较次数：第一次比较1次，第二次比较2次，总比较次数为1+2+...+(N-1)= (N-1)*N/2，每一趟排序发现插入点之前，平均只有一半的数据进行了比较，所以总的比较次数为：(N-1)*N/4

交换次数：交换次数小于比较次数，并且插入排序的交换比冒泡排序和选择排序要快

时间复杂度：(N-1)*N/4 + (N-1)*N/4，总得来说为O(N*N)，但是会比选择排序快

如果数组是基本有序的，即每个数据项只需移动1次或不需要移动，那么插入排序的时间复杂度将变为O(N)，这无疑是非常快的

四，表排序：

主要是利用了有序链表的特性，将数组中的所有数据插入到有序链表中，它们将自动按顺序排列，然后再顺次取出链表中的所有数据，把它们放到数组中，数组便排好序了

public class SortedList {
	private class Data{
		private double d;
		private Data next = null;

		Data(double d){
			this.d = d;
		}
	}

	private Data first = null;

	public void insert(double d){
		Data data = new Data(d);
		Data pre = null;
		Data cur = first;
		while(cur != null && (data.d > cur.d)){
			pre = cur;
			cur = cur.next;
		}
		if(pre == null)
			first = data;
		else
			pre.next = data;
		data.next = cur;
	}

	public double deleteFirst() throws Exception{
		if(first == null)
			throw new Exception("empty!");
		Data temp = first;
		first = first.next;
		return temp.d;
	}
}

public class ListSort {
	private double[] data;
	private SortedList sl;

	public ListSort(double[] data){
		this.data = data;
		sl = new SortedList();
	}

	public void sort() throws Exception{
		for(int i = 0 ; i< data.length ; i++){
			sl.insert(data[i]);
		}
		for(int i = 0 ; i< data.length ; i++){
			data[i] = sl.deleteFirst();
		}
	}

	public void display(){
		for(int i = 0 ; i < data.length ; i++){
			System.out.print(data[i]+" ");
		}
		System.out.print("\n");
	}

	public static void main(String[] args) throws Exception{
		double[] data = {Math.random(),Math.random(),Math.random(),Math.random()};
		ListSort ls = new ListSort(data);
		ls.display();
		ls.sort();
		ls.display();
	}
}

0.6379262500544237 0.18329827548195576 0.8408253367598466 0.6213596557610592
0.18329827548195576 0.6213596557610592 0.6379262500544237 0.8408253367598466 

比较次数：将数据插入链表平均需要比较N/2次

交换次数：将数组数据放入链表，再将链表数据放回数组，总共需移动2N次

时间复杂度：N/2 + 2N，总得来说为O(N)

虽然排序速度比上面3种排序方式要快，但是需要大约2倍的内存空间，数组和链表同时存在于内存中