交换排序-（冒泡、快速排序）

import java.util.Arrays;
/**
 * 交换排序：分为冒泡和快速
 * @author mk
 *
 */
public class ExchangeSort
{
/**
* 冒泡排序：0与1交换，1与2交换..n-2与n-1交换，最大值排在最后，最多经过n-1交换即可完成排序

* 期间后对于有序的不再交换，提高了效率，空间效率O(1)，稳定的

* 快速排序：时间效率很好，因为每趟能确定的元素呈指数增长，快速排序需要使用递归，空间效率O（log2N）

* 快速排序包含跳跃式交换，不是稳定的排序

* @param datas
*/
public static void sortBubble(DataWrap [] datas)
{
for(int i=0; i<datas.length-1; i++)
{
boolean flag = false;
for(int j=i+1; j<datas.length; j++)
{
if(datas[i].compareTo(datas[j]) > 0) 
{
swap(datas, i, j);
flag = true;
}
}
if(!flag) break; // 没有交换则是有序状态
System.out.println("第 "+i+" 趟排序后：" + Arrays.toString(datas));
}
}
// 快速排序
public static void sortQuick(DataWrap [] datas)
{
subsortQuick(datas, 0, datas.length-1);
}
private static void subsortQuick(DataWrap [] datas, int start , int end)
{
if(start < end)
{// 需要排序
DataWrap base = datas[start];// 以第一个元素作为分界值
int i = start , j = end + 1;// 从左边搜索大于分界值，从右边搜索小于分界值
while(true)
{
while(i < end && datas[++i].compareTo(base) <= 0);
while(j > start && datas[--j].compareTo(base) >=0);
if(i<j)
swap(datas, i, j);
else
break;
}
swap(datas, start, j);
subsortQuick(datas, start,j-1);// 递归左子序列
subsortQuick(datas, j+1, end);// 递归右子序列
}
}

private static void swap(DataWrap [] datas, int i, int j)
{
DataWrap tmp = datas[i];
datas[i] = datas[j];
datas[j] = tmp;
}

public static void main(String[] args)
{
DataWrap[] dws = { new DataWrap(10, ""), new DataWrap(5, ""),
new DataWrap(8, ""), new DataWrap(3, ""),new DataWrap(14, "") };
System.out.println("排序前：" + Arrays.toString(dws));
sortBubble(dws);
System.out.println("排序后：" + Arrays.toString(dws));
/**
* 测试结果
* 排序前：[10, 5, 8, 3, 14]
* 第 0 趟排序后：[3, 10, 8, 5, 14]
* 第 1 趟排序后：[3, 5, 10, 8, 14]
* 第 2 趟排序后：[3, 5, 8, 10, 14] 不再交换经过三轮排序就ok了 提高了效率
* 排序后：[3, 5, 8, 10, 14]
*/
dws = new DataWrap[]{ new DataWrap(5, ""), new DataWrap(2, ""),
new DataWrap(7, ""), new DataWrap(-2, ""),
new DataWrap(9, ""),new DataWrap(0, ""),new DataWrap(-9, "")};
System.out.println("排序前：" + Arrays.toString(dws));
sortQuick(dws);
System.out.println("排序后：" + Arrays.toString(dws));
/**
* 排序前：[5, 2, 7, -2, 9, 0, -9]
* 排序后：[-9, -2, 0, 2, 5, 7, 9]
*/
}

}