冒泡排序(+双向)

/**
 * 
 * @author QY
 * 冒泡排序，大体思想是通过与相邻元素的比较和交换来把小的数交换到最前面。
 * 这个过程类似于水泡向上升一样，因此而得名。
 * 举个例子，对5,3,8,6,4这个无序序列进行冒泡排序。
 * 首先从后向前冒泡，4和6比较，把4交换到前面，序列变成5,3,8,4,6。
 * 同理4和8交换，变成5,3,4,8,6,3和4无需交换。
 * 5和3交换，变成3,5,4,8,6,3.这样一次冒泡就完了，把最小的数3排到最前面了。
 * 对剩下的序列依次冒泡就会得到一个有序序列。冒泡排序的时间复杂度为O(n^2)。
 */
public class BubbleSort {
	public static void bubbleSort(int []arr) {
		int[]arrl = arr.clone(); 
		for (int i = 0; i < 2; i++) {
			if (i > 0) {
				for(int s =0;s<arrl.length-1;s++) { 
					for(int j=0;j<arrl.length-s-1;j++) {//-1为了防止溢出
						if(arrl[j]>arrl[j+1]) {
							swap(arrl, j+1, j);
						}
					}    
				}
                /** 双向冒泡
                int length = arr.length/2;
                for(int i = 0;i<length;i++){
                    //正向
                    for(int j = 0;j<length;j++){
                        if(arr[j]>arr[j+1]){
                            swap(arr,j,j+1);
                        }
                    }
                    //反向
                    for(int j = arr.length-1;j>=length ;j--){
                        if(arr[j]<arr[j-1]){
                            swap(arr,j,j-1);
                        }
                    }
                }
                */


				System.out.print("排序后数组：");
			}else{
				System.out.print("排序前数组：");
			}
			
			for(int l =0;l<arrl.length;l++) {
	        	if (l==0) {
					System.out.print("{"+arrl[l]+",");
				} else if (l<arrl.length-1 && l != 0) {
	        		System.out.print(arrl[l]+",");
				}else{
					System.out.println(arrl[l]+"}");
				}
	                }
		}
	}
	public static void swap(int[] arr, int i, int j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

	public static void main(String[] args) {
		int[] array = {32,23,14,56,86,56,78};
		bubbleSort(array);
	}
}

冒泡算法图解 ：

原理 ： 冒泡排序一次只比较两个数字，并且这两个数字是相邻的。 从图上我们可以看到，原数组为{32,23,14,56,86,56,78} 第一次比较首先比较第0位和第一位，并且将结果大的数字往后移动，也就是交换。同理，如果第0位<第1 位，就不进行交换。 就这样，通过n-1次比较后（n为数组长度），就将最大的数字移到了数组的最末端。然后再继续进行第二轮比较，找出第二大的数字，往后以此类推。   冒泡排序 ： 一共需要比较的次数为： (n-1)+(n-2)+(n-3)+·····+1;

时间复杂度 若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数   和记录移动次数  ，均达到最小值：  ， 。 所以，冒泡排序最好的时间复杂度为   。 若初始文件是反序的，需要进行   趟排序。每趟排序要进行    次关键字的比较(1≤i≤n-1)， 且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值： 冒泡排序的最坏时间复杂度为   。   综上，因此冒泡排序总的平均时间复杂度为   。 算法稳定性 冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。