Java数据结构--简单排序

Java数据结构–简单排序

简单排序是最基本的三种排序方式，包括了冒泡排序、选择排序、插入排序；其中，优化插入排序之后得到了希尔排序。

代码架构

简单排序可通过三个方法都能够很好地实现代码运行，当然也能够直接在一个方法内部构建完毕，多个方法体会看起来更有层次感，简单易懂。

函数名	意义
sort(Comparable[] a)	sort函数用来排列数组A中数据，也是整个的核心代码块。
greater(Comparable v, Comparable w)	greater函数能够比较其中元素的值，返回boolean类型结构来判断。
exch(Comparable[] a, int i, int j)	exch函数能够交换数组中两个数据的下标位置。

1.冒泡排序

每轮排序将最大数据检索（比较相邻元素，大的排后）出来并排至最后端，例如：

根据冒泡排序规则，建立两个循环，即可完成，代码如下：

    /*
	 * 对数组A中数据进行排序
	 */
	public static void sort(Comparable[] a) {
		for (int i = a.length - 1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				if (greater(a[j], a[j + 1])) {
					exch(a, j, j + 1);
				}
			}
		}
	}

	/*
	 * 比较v元素是否大于w元素
	 */
	public static boolean greater(Comparable v, Comparable w) {
		return v.compareTo(w) > 0;
	}

	/*
	 * 交换元素在数组中的位置
	 */
	public static void exch(Comparable[] a, int i, int j) {
		Comparable num;
		num = a[i];
		a[i] = a[j];
		a[j] = num;
	}

上面代码在最好情况下时间复杂度为：O(n),最坏情况下为O(n²),平均为O(n²)

2.选择排序

每轮寻找最小处索引，交换第一个与最小处索引位置，例如：

定义一个参数来存储最小值索引，完成与前端索引进行交换

    /*
	 * 对数组A中数据进行排序
	 */
	public static void sort(Comparable[] a) {
		for (int i = 0; i <= a.length - 2; i++) {
			int index = i;
			for (int j = i + 1; j <= a.length - 1; j++) {
				if (greater(a[index], a[j])) {
					index = j;
				}
			}
			exch(a, i, index);
		}
	}

	/*
	 * 比较v元素是否大于w元素
	 */
	public static boolean greater(Comparable v, Comparable w) {
		return v.compareTo(w) > 0;
	}

	/*
	 * 交换元素在数组中的位置
	 */
	public static void exch(Comparable[] a, int i, int j) {
		Comparable num;
		num = a[i];
		a[i] = a[j];
		a[j] = num;
	}

上面代码在最好情况下时间复杂度为：O(n²),最坏情况下为O(n²),平均为O(n²)

3.插入排序

插入排序则是将整个数组分为两部分，已排序和未排序，每轮将一个元素往前放置合适位置，例如：

代码编写思路：围绕三个方法进行整体排序，主要运行方法放置双层循环，外循环表示每次进入排序，内循环将排序数据放置相对应的位置。

    /*
	 * 对数组A中数据进行排序
	 */
	public static void sort(Comparable[] a) {
		for (int i = 1; i < a.length; i++) {
			for (int j = i - 1; j >= 0; j--) {
				if (greater(a[j], a[j + 1])) {
					exch(a, j + 1, j);
				} else {
					break;
				}
			}
		}
	}

	/*
	 * 比较v元素是否大于w元素
	 */
	public static boolean greater(Comparable v, Comparable w) {
		return v.compareTo(w) > 0;
	}

	/*
	 * 交换元素在数组中的位置
	 */
	public static void exch(Comparable[] a, int i, int j) {
		Comparable num;
		num = a[i];
		a[i] = a[j];
		a[j] = num;
	}

上面代码在最好情况下时间复杂度为：O(n²),最坏情况下为O(n²),平均为O(n²)