2.排序-交换类排序

1. 起泡排序

基本思想

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码如下：

package sort.exchange;


/**
 * 冒泡排序算法
 * 
 * @author king
 *
 */
public class BuddleSort {
	//冒泡
	private static void buddleSort(int[] data){
		int count=1;
		for(int i=0;i<data.length;i++){
			for(int j=1;j<(data.length-i);j++){
				int temp;//定义临时存储的变量
				if(data[j-1]>data[j]){
					//交换两个记录
					temp=data[j];
					data[j]=data[j-1];
					data[j-1]=temp;
				}
			}
			System.out.println("第" + count + "趟排序:");
			for (int k = 0; k < data.length; k++) {
				System.out.print(data[k] + " ");
			}
			System.out.print("\n");
			count++;
		}
	}
	public static void main(String[] args) {
		int[] data= new int[]{10,9,8,7,6,5,4,3,2,1};
		buddleSort(data);
		for (int k = 0; k < data.length; k++) {
			System.out.print(data[k] + " ");
		}
	}
}

运行结果 

第1趟排序:

9 8 7 6 5 4 3 2 1 10 

第2趟排序:

8 7 6 5 4 3 2 1 9 10 

第3趟排序:

7 6 5 4 3 2 1 8 9 10 

第4趟排序:

6 5 4 3 2 1 7 8 9 10 

第5趟排序:

5 4 3 2 1 6 7 8 9 10 

第6趟排序:

4 3 2 1 5 6 7 8 9 10 

第7趟排序:

3 2 1 4 5 6 7 8 9 10 

第8趟排序:

2 1 3 4 5 6 7 8 9 10 

第9趟排序:

1 2 3 4 5 6 7 8 9 10 

第10趟排序:

1 2 3 4 5 6 7 8 9 10 

 

改进的冒泡算法？加个是否交换标志 exchange

 

2. 快速排序

快速排序(Quick Sort)的基本思想是：通过不断比较关键码，以某个记录为界（该记录称为支点），将待排序列分成两部分。其中，一部分满足所有记录的关键码都大于或等于支点记录的关键码，另一部分记录的关键码都小于支点记录的关键码。把以支点记录为界将待排序列按关键码分成两部分的过程，称为一次划分。对各部分不断划分，直到整个序列按关键码有序为止。

 

代码如下：为什么老觉得写出来的代码怪怪的。

package sort.exchange;

/**
 * 快速排序算法
 * 
 * @author king
 */
public class QuickSort {
	
	private static int count = 1;
	//定义两个标志位分别指向待排序数组最低端和最高端
	public static void quickSort(int[] data, int low, int high) {
		int i = low;
		int j = high;
		// 取一个支点,类似于哨兵
		int temp = data[low];
		while (low < high) {
			while (low < high && data[high] >= temp) {//从左向右
				--high;
			}
			data[low] = data[high];
			if (low < high)
				low++;
			while (low < high && data[low] <= temp) {//从右向左
				++low;
			}
			data[high] = data[low];
			if (low < high)
				--high;
		}
		data[low] = temp;//将哨兵插入到最后替换的位置
		System.out.println("第" + count + "趟排序:");
		for (int k = 0; k < data.length; k++) {
			System.out.print(data[k] + " ");
		}
		count++;
		System.out.print("\n");
		// 一趟快速排序实现的效果就是
		// 比哨兵的值大的数据在哨兵的右边
		// 比哨兵的值小的数据在哨兵的左边
		// 然后就递归实现整个数组的排序
		if (i < low - 1) {
			quickSort(data, i, low - 1);
		}
		if (low + 1 < j) {
			quickSort(data, low + 1, j);
		}
	}
	public static void main(String[] args) {
		int[] data = new int[]{10,9,8,7,11,5,4,3,2,1};
		quickSort(data, 0, data.length - 1);
	}
}

 运行结果 ：

 

第1趟排序:

 

1 9 8 7 2 5 4 3 10 11 

 

第2趟排序:

 

1 9 8 7 2 5 4 3 10 11 

 

第3趟排序:

 

1 3 8 7 2 5 4 9 10 11 

 

第4趟排序:

 

1 2 3 7 8 5 4 9 10 11 

 

第5趟排序:

 

1 2 3 4 5 7 8 9 10 11 

 

第6趟排序:

 

1 2 3 4 5 7 8 9 10 11