Java学习笔记之排序

Java学习笔记之排序

排序：计算机程序设计过程中的一项重要操作，其功能是指一个数据元素集合或序列重新排列成一个按数据元素某个数据项值有序的序列。

排序码：排序依据的数据项。

稳定排序（不稳定排序）：排序前后相同关键码的相对位置不变（发生改变）。

直接插入排序：n个待排序分为有序表和无序表，开始有序表中只有一个元素，排序过程中依次把无序表中的元素插入到有序表中，形成新的有序表和无序表。这种排序的效率为O（n^2），并且是稳定的。

希尔排序：将整个待排序元素序列分割成若干个子序列（由相隔某个增量的元素组成）分别进行直接插入排序，待整个序列中的元素基本有序（增量足够小），再对全体元素进行一次直接插入排序。时间复杂性为O（nlog2(n)）与O（n^2）之间。希尔排序是不稳定的。

冒泡排序：通过对待排序序列从前向后，依次比较相邻元素的排序码，若发现逆序则交换，使排序码较大的元素逐渐从前部移向后部。时间复杂性为O（n^2），是稳定的。

下面附上代码：

public class BubbleSort {
	private static void bubbleSrot(int[] data) {
//		int[] array = new int[data.length];
		for (int i = 0; i < data.length - 1; i++) {
			for (int j = 0; j < data.length - i - 1; j++) {
				if (data[j] > data[j+1]) {
					int temp;
					temp = data[j];
					data[j] = data[j+1]; 
					data[j+1] = temp;
				}
			}
		}
//		for (int i = 0; i < data.length; i++) {
//			System.out.print(data[i] + ",");
//		}
	}
	public static void main(String[] args) {
		int[] data = {65,43,67,23,43,66,88,11,22,12};
		System.out.println("初始数据");
		System.out.println(java.util.Arrays.toString(data));
//		for (int i = 0; i < data.length; i++) {
//			System.out.print(data[i]+",");
//		}
		System.out.println();
		BubbleSort.bubbleSrot(data);
		System.out.println("排序之后的数据");
//		for (int i = 0; i < data.length; i++) {
//			System.out.print(data[i]+",");
//		}
		System.out.println(java.util.Arrays.toString(data));
	}
	
}

快速排序：任取待排序序列中的某个元素作为标准，通过一次划分，将待排元素分为左右两个子序列，左子序列元素的排序码均小于基准元素的排序码，右子序列的排序码则大于或等于基准元素的排序码，然后分别对两个子序列继续进行划分，直至每一个序列中只有一个元素为止。

下面给出代码：

public class QuickSort {
	private static void exchange(int[] data,int min,int max) {
		int temp = data[min];
		data[min] = data[max];
		data[max] = temp;
	}
	private static void oneSort(int[] data,int min,int max) {
		if(min < max) {
			int temp = data[min];
			int low = min;
			int high = max;
			//一次划分
			while(true) {
				while(low < max && data[++low] - temp <= 0)
					;
//				while(high > min && data[high--] - temp >= 0) 
//					;
				//上面这条语句为什么行不通
				while(high > min && data[high] - temp >= 0) {
					high--;
				}
				if (low < high) {
					exchange(data, low, high);
				}else {
					exchange(data, min, high);
					break;
				}
			}
//			exchange(data, min, high);
			//将表拆分,这里为什么是high????
			oneSort(data, min, high - 1);
			oneSort(data, high + 1, max);
		}
	}
	private static void quickSort(int[] data) {
		oneSort(data, 0, data.length - 1);
	}
	public static void main(String[] args) {
		int[] data = {65,43,67,23,43,66,88,11,22,12};
		System.out.println("初始数据");
//		for (int i = 0; i < data.length; i++) {
//			System.out.print(data[i]+",");
//		}
		System.out.println(java.util.Arrays.toString(data));
		System.out.println("排序之后");
		quickSort(data);
		System.out.println(java.util.Arrays.toString(data));
	}
}

归并排序：基本思想为：将两个有序表合并成为一个有序表。将一个无序表拆分至最小一个单元的表，然后对其进行排序与合并。

实现代码：

public class MergeSort {
	public static void main(String[] args) {
		int[] data = {43,3,2,33,23,56,43,44,45,55,66};
		mergeSort(data);
		System.out.println(java.util.Arrays.toString(data));
	}
	private static void mergeSort(int[] data) {
		sort(data,0,data.length - 1);
	}
	//拆分再合并,这里需要考虑到两个单元的数组不需要拆分了
	private static void sort(int[] data, int min, int max) {
		if (min < max) {
			int center = (min + max)/2;
			sort(data,min,center);
			sort(data,center + 1,max);
			merge(data,min,center,max);
		}
	}
	//对有序数组合并，新数组依然有序，可以通过三个点确定两个数组
	private static void merge(int[] data,int min,int center,int max) {
		int[] temp = new int[max - min + 1];
		//比较大小
		int i = 0;
		int j = min;
		int k = (center + 1);
		while(i < temp.length && j <= center && k <= max) {
			if (data[j] > data[k]) {
				temp[i] = data[k];
				k++;
				i++;
			}else {
				temp[i] = data[j];
				j++;
				i++;
			}
		}
		if (j > center) {
			while(k <= max) {
				temp[i] = data[k];
				k++;
				i++;
			}
		}else {
			while(j <= center) {
				temp[i] = data[j];
				j++;
				i++;
			}
		}
		for (int i2 = 0; i2 < temp.length; i2++) {
			data[min + i2] = temp[i2];
		}
	}
}