排序算法一（直接选择，堆排序，冒泡排序和快速排序）

对于一个排序算法来说，一般从如下3个方面衡量算法的优劣：

1.时间复杂度：它主要是分析关键字的比较次数和记录的移动次数

2.空间复杂度：分析排序算法中需要多少辅助内存

3.稳定性：若两个记录A和B的关键字相等，排序前后二者的先后次序没有发生变化就称之为稳定排序

现有的排序算法分为：内部排序和外部排序

内部排序：所有的操作都是在内存中完成的，而外部排序需要借助外部存储器（如磁盘等）

外部排序最常用的方法是多路归并排序，即将原先的文件分解为多个能够一次性装入内存的部分，

分别把每一部分调入内存完成排序，接下来再对多个有序的子文件进行归并排序。

接下来主要介绍内部排序，分为：

选择排序（直接选择和堆排序），交换排序（冒泡和快速），插入排序（直接插入，折半插入和Shell排序），归并排序，基数排序和桶式排序。

本文介绍将介绍选择排序和交换排序

数组元素类DataWrap：flag用来标记相同元素出现的次数，a 表示第一次出现，b表示第二次出现，以此类推，用来测试算法的稳定性

package sort_lyf;

public class DataWrap implements Comparable<DataWrap> {
	int data;
	String flag;
	public DataWrap(int data,String flag){
		this.data = data;
		this.flag = flag;
	}
	public String toString(){
		return data+flag;
	}
	public static void swap(DataWrap[] data, int i, int j) {
		DataWrap temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}
	@Override
	public int compareTo(DataWrap datawrap) {
		return this.data > datawrap.data ? 1:(this.data == datawrap.data? 0:-1);
	}
}

算法的接口类：ISort(采用策略模式)

package sort_lyf;

public interface ISort {
	public void sort(DataWrap[] data);
}

算法的实现类：

package sort_lyf;
/**
 * @author liyafang 直接选择排序：
 * 程序将记录定位在第一个数据上，拿第一个数据和后边的数据依次比较，
 * 如果第一个数据大于后边的数据，发生交换，这样第一趟下来，就选出
 * 最小的一个元素了，它被排在了第一位，然后在定位第二个数据。
 */
public class DirectSelectSort implements ISort {
	public  void sort(DataWrap[] data) {
		System.out.println("开始进入直接选择排序：");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength - 1; i++) {// 外层循环需要遍历到倒数第二个元素
			for (int j = i + 1; j < arrayLength; j++) {// 内层循环需要遍历到倒数第一元素
				if (data[i].compareTo(data[j]) > 0) {
					DataWrap.swap(data, i, j);
				}
			}
			System.out.println(java.util.Arrays.toString(data));
		}
		// 存在的问题：在每趟比较过程中，程序一旦发现某个数据比第一
		// 位的数据小，立即交换他们，这增加了交换次数，导致算法效率低下。
	}
}

排序之前：
[21a, 30a, 49, 30b, 16, 9a, 9b, 21b]
开始进入直接选择排序：
[9a, 30a, 49, 30b, 21a, 16, 9b, 21b]
[9a, 9b, 49, 30b, 30a, 21a, 16, 21b]
[9a, 9b, 16, 49, 30a, 30b, 21a, 21b]
[9a, 9b, 16, 21a, 49, 30b, 30a, 21b]
[9a, 9b, 16, 21a, 21b, 49, 30a, 30b]
[9a, 9b, 16, 21a, 21b, 30a, 49, 30b]
[9a, 9b, 16, 21a, 21b, 30a, 30b, 49]
排序之后：
[9a, 9b, 16, 21a, 21b, 30a, 30b, 49]


package sort_lyf;
/**
 * @author liyafang 优化后的直接选择排序算法：
 * 用一个变量记录本趟最小元素的索引，每趟选择
 * 只发生一次交换
 */
public class DirectSelectSortOptimized implements ISort {
	// 
	public void sort(DataWrap[] data) {
		System.out.println("开始进入优化版的直接选择排序：");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength - 1; i++) {
			int minIndex = i;// 永远保留本躺比较中最小值的索引
			for (int j = i + 1; j < arrayLength; j++) {
				if (data[minIndex].compareTo(data[j]) > 0) {
					minIndex = j;
				}
			}
			if (minIndex != i) {
				DataWrap.swap(data, i, minIndex);
			}
			System.out.println(java.util.Arrays.toString(data));
		}
	}
	// 小结：对于直接选择排序，假如有n项数据，数据交换的次数最多有n-1次
	// 比较次数较多，时间复杂度为O(n*n),空间效率很高为O(1);是不稳定排序。
}
排序之前：
[21a, 30a, 49, 30b, 16, 9a, 9b, 21b]
开始进入优化版的直接选择排序：
[9a, 30a, 49, 30b, 16, 21a, 9b, 21b]
[9a, 9b, 49, 30b, 16, 21a, 30a, 21b]
[9a, 9b, 16, 30b, 49, 21a, 30a, 21b]
[9a, 9b, 16, 21a, 49, 30b, 30a, 21b]
[9a, 9b, 16, 21a, 21b, 30b, 30a, 49]
[9a, 9b, 16, 21a, 21b, 30b, 30a, 49]
[9a, 9b, 16, 21a, 21b, 30b, 30a, 49]
排序之后：
[9a, 9b, 16, 21a, 21b, 30b, 30a, 49]



package sort_lyf;
/**
 * @author liyafang 堆排序：
 * 对于一棵顺序结构的完全二叉树而言，对于索引为k的节点，它的两个子节点的索引分别为2k+1，2k+2，反过来，对于
 * 节点为k的，父节点为(k-1)/2.堆排序的步骤就是重复一下两个步骤：1.建堆   2.拿堆的根节点和最后一个节点交换。
 * 对于包含n个元素的数组，堆排序需要n-1次建堆，建堆从最后一个非叶节点开始，因为只要保证每个非叶子节点的值大
 * 于等于其左右子节点的值。每次建堆的作用就是选出最大值（注意大堆排出来的是升序），实际上也属于选择排序，只
 * 不过堆排序可以通过树形结构保存部分比较结果，可减少比较次数。
 */
public class HeapSort implements ISort {
	public void sort(DataWrap[] data) {
		System.out.println("开始进入堆排序");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength; i++) {
			buildMaxHeap(data, arrayLength - 1 - i);// 每次建堆完成之后，堆顶元素为第i+1大元素
			DataWrap.swap(data, 0, arrayLength - 1 - i);// 交换堆顶和arrayLength - 1
														// - i元素
			// 交换完成重新再次对其余元素建堆
			System.out.println(java.util.Arrays.toString(data));
		}
	}

	// 对data数组从0到lastIndex建最大堆，选出0到lastIndex索引范围内的最大元素（堆顶元素）
	private void buildMaxHeap(DataWrap[] data, int lastIndex) {
		for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
			int comparingIndex = i;// 当前正在判断的节点
			while ((2 * comparingIndex + 1) <= lastIndex) {// 如果当先节点的左子节点还存在
				int biggerIndex = 2 * comparingIndex + 1;// 左子节点的索引
				if (biggerIndex < lastIndex) {// 如果右子节点存在
					if (data[biggerIndex].compareTo(data[biggerIndex + 1]) < 0) {
						biggerIndex++;
					}
				}
				if (data[comparingIndex].compareTo(data[biggerIndex]) < 0) {
					DataWrap.swap(data, comparingIndex, biggerIndex);
					// 继续判断发生交换的子节点（biggerIndex）是否大于其左右子节点
					comparingIndex = biggerIndex;
				} else {
					break;
				}
			}
		}
	}
	// 小结：对于堆排序算法而言，需要进行n-1次建堆，每次建堆耗时logN，
	// 则时间效率为O(N*logN),空间效率很高为O(1),不稳定排序。
}
排序之前：
[21a, 30a, 49, 30b, 16, 9a, 9b, 21b]
开始进入堆排序
[21b, 30a, 21a, 30b, 16, 9a, 9b, 49]
[9b, 30b, 21a, 21b, 16, 9a, 30a, 49]
[9a, 21b, 21a, 9b, 16, 30b, 30a, 49]
[9a, 16, 21a, 9b, 21b, 30b, 30a, 49]
[9b, 16, 9a, 21a, 21b, 30b, 30a, 49]
[9a, 9b, 16, 21a, 21b, 30b, 30a, 49]
[9b, 9a, 16, 21a, 21b, 30b, 30a, 49]
[9b, 9a, 16, 21a, 21b, 30b, 30a, 49]
排序之后：
[9b, 9a, 16, 21a, 21b, 30b, 30a, 49]
package sort_lyf;

/**
 * @author liyafang 优化版的冒泡法： 
 * 依次比较0和1，1和2，2和3，n-2和n-1的值，如果前者大，就交换
 * 经过第一趟，最大的元素排到了最后，然后进行第二趟... 一旦一
 * 趟冒泡没有发生交换，即可提前结束排序。
 */
public class BubbleSortOptimized implements ISort {
	public void sort(DataWrap[] data) {
		System.out.println("开始进入改进版冒泡排序：");
		int arrayLength = data.length;
		int count = 0;
		boolean IsSwap = false;
		for (int i = 0; i < arrayLength; i++) {
			for (int j = 0; j < arrayLength - 1 - i; j++) {
				if (data[j].compareTo(data[j + 1]) > 0) {
					DataWrap.swap(data, j, j + 1);
					IsSwap = true;
					count++;
				}
			}
			if (!IsSwap) {// 如果某趟没有发生交换，则表明已处于有序状态
				break;
			}
			System.out.println(java.util.Arrays.toString(data));
		}
		System.out.println("总的交换次数：" + count);
	}
	/**
	 * 冒泡排序而言的时间效率是不确定的：最好的情况下，初始数据序列已经处于有序的状态
	 * 执行一趟冒泡即可，做n-1次比较，无需进行任何交换；但在最坏情况下，初始数据序列
	 * 处于完全逆序，算法执行n-1躺冒泡，第i趟做了n-i次比较，执行n-i-1次对象交换，
	 * 此时交换总次数为n(n-1)/2；算法空间效率很高，为O(1)； 属于稳定排序；
	 */
}
排序之前：
[21a, 30a, 49, 30b, 16, 9a, 9b, 21b]
开始进入改进版冒泡排序：
[21a, 30a, 30b, 16, 9a, 9b, 21b, 49]
[21a, 30a, 16, 9a, 9b, 21b, 30b, 49]
[21a, 16, 9a, 9b, 21b, 30a, 30b, 49]
[16, 9a, 9b, 21a, 21b, 30a, 30b, 49]
[9a, 9b, 16, 21a, 21b, 30a, 30b, 49]
[9a, 9b, 16, 21a, 21b, 30a, 30b, 49]
[9a, 9b, 16, 21a, 21b, 30a, 30b, 49]
[9a, 9b, 16, 21a, 21b, 30a, 30b, 49]
总的交换次数：18
排序之后：
[9a, 9b, 16, 21a, 21b, 30a, 30b, 49]



package sort_lyf;
/**
 * @author liyafang
 */
public class QuickSort implements ISort{
	public  void sort(DataWrap[] data) {
		System.out.println("开始进入快速排序：");
		subSort(data, 0, data.length - 1);
		System.out.println(java.util.Arrays.toString(data));
	}

	public  void subSort(DataWrap[] data, int start, int end) {
		if (start < end) {
			DataWrap base = data[start];
			// 定一个变量leftIndex，从左边第一个索引开始
			int leftIndex = start;
			// 定一个变量rightIndex，从右边第一个索引开始
			int rightIndex = end + 1;
			// 此处三个while循环用的非常秒，注意体会！
			while (true) {
				// 找出大于分界值的元素的索引，并用leftIndex记录它
				while (leftIndex < end
						&& (data[++leftIndex].compareTo(base) <= 0))
					;
				// 找出小于分界值的元素的索引，并用rightIndex记录它
				while (rightIndex > start
						&& (data[--rightIndex].compareTo(base) >= 0))
					;
				// 如果i<j,交换i、j两处索引的元素
				if (leftIndex < rightIndex) {
					DataWrap.swap(data, leftIndex, rightIndex);
				} else {
					break;// 重复执行以上步骤，直到leftIndex>=rightIndex,
				}
			}
			// 最后将分界值和rightIndex索引处的元素交换即可
			DataWrap.swap(data, start, rightIndex);
			// 递归左子序列
			subSort(data, start, rightIndex - 1);
			// 递归右子序列
			subSort(data, rightIndex + 1, end);
		}
	}
	/**
	 * 快速排序的时间效率很好，因为它每趟能确定的元素呈指数增长。 
	 * 快速排序需要使用递归，而递归使用栈，因此它的空间效率为O(logN)。
	 * 快速排序包含跳跃式交换，因此是不稳定的排序。
	 */
}
排序之前：
[21a, 30a, 49, 30b, 16, 9a, 9b, 21b]
开始进入快速排序：
[9a, 9b, 16, 21a, 21b, 30b, 30a, 49]
排序之后：
[9a, 9b, 16, 21a, 21b, 30b, 30a, 49]



Main函数：
package sort_lyf;

public class Test {
	public static void main(String args[]) {
		//a 代表该元素第一次出现  代表该元素第二次出现，主要是为了测试排序是否稳定
		DataWrap[] data = { new DataWrap(21, "a"), new DataWrap(30, "a"),
				new DataWrap(49, ""), new DataWrap(30, "b"),
				new DataWrap(16, ""), new DataWrap(9, "a"),
				new DataWrap(9, "b"), new DataWrap(21, "b"), };
		/*
		 * DataWrap[] data = { new DataWrap(10, "a"), new DataWrap(9, "a"), new
		 * DataWrap(8, ""), new DataWrap(7, "b"), new DataWrap(6, ""), new
		 * DataWrap(5, "a"), new DataWrap(4, "b"), new DataWrap(3, "b"), new
		 * DataWrap(2, "b"), new DataWrap(1, "b")};
		 */
		/*
		 * DataWrap[] data = { new DataWrap(1, "a"), new DataWrap(2, "a"), new
		 * DataWrap(3, ""), new DataWrap(4, "b"), new DataWrap(5, ""), new
		 * DataWrap(6, "a"), new DataWrap(7, "b"), new DataWrap(8, "b"), new
		 * DataWrap(9, "b"), new DataWrap(10, "b")};
		 */
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		/*ISort lyf = new DirectSelectSort();
		lyf.sort(data);
		ISort lyf = new DirectSelectSortOptimized();
		lyf.sort(data);
		ISort lyf = new HeapSort();
		lyf.sort(data);
		ISort lyf = new BubbleSortOptimized();
		lyf.sort(data);*/
		ISort lyf = new QuickSort();
		lyf.sort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}