Java实现冒泡排序，改进冒泡排序，选择排序

排序的算法有很多种，除了经典的算法，也有很多与时共进的算法。但是掌握传统的算法，是每一位学习者的要求。

 

冒泡排序也是从起点开始依次比较两个数，直到数组待比较序列的末端，每次比较将最大或者是最小的放在最后面。

经过上诉过程，直到待比较序列只剩下一个时，就结束了。冒泡排序算法可以是稳定的，只要将条件设置为不包含等于。

所谓稳定性就是，数组中，相同的数经过排序过后相对次序不发生变化。意思就是比较之前在前面的比较之后还在前面。

所有例子，为了准确性，在验证过程中使用10组随机数列。

 

实例代码：

验证（后面的例子中省略）：

public class SortConfirmation {
	public static void main(String[] args) {
		for(int x=0;x<5;x++){
			int []a=new int[10];
			for (int i = 0; i < a.length; i++) {
				a[i]=(int)(1+Math.random()*30);
			}
			new Sort().BubbleSort(a);
		}
	}
}

冒泡排序：

	/*
	 * 冒泡排序
	 * 下面的例子是从小到大排序
	 */
	public  void  BubbleSort(int x[]) {
		for (int i = 0; i < x.length; i++) {
			for (int j = 0; j < x.length-i-1; j++) {
				if(x[j]>x[j+1]){
					Swap(x, j, j+1);
				}
			}
		}
		
		System.out.print("冒泡排序： ");
		System.out.println(Arrays.toString(x));
	}

用到的Swap方法(后面的例子中省略):

	public void Swap (int x[],int i,int j) {
		int temp=x[i];
		x[i]=x[j];
		x[j]=temp;
	}

运行结果：

冒泡排序： [2, 4, 8, 11, 19, 20, 25, 26, 27, 30]
冒泡排序： [1, 5, 5, 8, 9, 17, 20, 25, 29, 30]
冒泡排序： [1, 2, 4, 7, 12, 18, 18, 20, 20, 28]
冒泡排序： [8, 10, 15, 18, 23, 25, 27, 27, 27, 30]
冒泡排序： [5, 7, 10, 11, 13, 15, 26, 27, 29, 30]

冒泡排序算是平时很常用的一类排序，但是还有一种排序叫做鸡尾酒排序，是冒泡排序的改进版。因为冒泡排序每次遍历待排序序列只能比较出该序列中最大或者是最小的，但是鸡尾酒排序在比较了最大的之后紧接着方向比较最小的。效率稍微比普通冒泡好一些。同冒泡排序一样，可以是稳定的，原因相同。

鸡尾酒排序：

	/**
	 * 鸡尾酒排序
	 * 在冒泡排序基础上改进，比冒泡排序效率高一些
	 * @param x
	 */
	public void CocktailSort(int x[]) {
		int m=0;
		int n=x.length;
		//一次while循环，比较两次，从小到大比较，选出最大的；从大到小比较，选出最小的
		while (m<n) {
			for (int i = m; i <n-1; i++) {
				if (x[i]>x[i+1]) {
					Swap(x, i, i+1);
				}
			}
			n--;
			for (int j = n; j>m; j--) {
				if(x[j]<x[j-1]){
					Swap(x, j, j-1);
				}
			}
			m++;
		}
		
		System.out.print("鸡尾酒排序: ");
		System.out.println(Arrays.toString(x));
	}

运行结果：

鸡尾酒排序: [2, 4, 4, 4, 5, 7, 10, 19, 20, 27]
鸡尾酒排序: [1, 4, 5, 7, 9, 9, 11, 13, 15, 25]
鸡尾酒排序: [5, 6, 7, 10, 10, 11, 11, 11, 15, 21]
鸡尾酒排序: [2, 5, 7, 9, 18, 18, 24, 28, 28, 30]
鸡尾酒排序: [2, 3, 4, 5, 10, 12, 21, 23, 29, 30]

还有一种很常用的就是选择排序了。选择排序就是从待排序序列第一位开始，依次比较整个待排序序列，选出最大或者是最小的。

/**
	 * 选择排序
	 * 每次从比较序列里面选取最小的放在上次比较结果的后面
	 * 其实稳定性就是指的序列中相同的数排序之前的相对位置和排序之后的相对位置，如果一致，则稳定，反之则不稳定
	 * @param x
	 */
	public void SelectSort(int x[]) {
		for (int i = 0; i < x.length-1; i++) {
			for (int j = i+1; j < x.length; j++) {
				if(x[i]>x[j]){
					Swap(x, i, j);
				}
			}
		}
		
		System.out.print("选择排序： ");
		for (int i = 0; i < x.length; i++) {
			System.out.print(x[i]+" ");
		}
		System.out.println();
	}

运行结果：

选择排序： 3 4 9 10 10 11 19 21 22 30 
选择排序： 2 6 11 18 19 21 22 25 27 27 
选择排序： 2 3 3 11 13 13 17 17 23 25 
选择排序： 4 6 9 13 14 15 19 22 23 24 
选择排序： 4 4 8 8 15 15 16 20 26 29 

除了以上排序方法之外，还有插入排序，二分查找插入排序，希尔排序，归并排序，堆栈排序，以及效率很高的快速排序等等。

 

如果以上内容有什么问题，欢迎各位大佬指出。