Simple Sort Algorithm -- BubbleSort

一、冒泡排序

核心：冒泡，持续比较相邻元素，大的挪到后面，因此大的会逐步往后挪，故称之为冒泡。

　　

　　复杂度分析：平均情况与最坏情况均为 O(n²)，使用了 temp 作为临时交换变量，空间复杂度为 O(1)。

二、编程实现

　　实现方式一：　　

package sort;

public class BubbleSort {
    /**
     * 冒泡排序，持续比较相邻元素，大的挪到后面，因此大的会逐步往后挪，故称之为冒泡。
     * 复杂度分析：平均情况与最坏情况均为 O(n^2), 使用了 temp 作为临时交换变量，空间复杂度为 O(1).
     */
    public static void main(String[] args) {
        int[] unsortedArray = new int[]{6, 5, 3, 1, 8, 7, 2, 4} ;
        bubbleSort(unsortedArray) ;
        System.out.println("After sort: ");
        for (int item : unsortedArray) {
            System.out.print(item + " ");
        }
    }
    
    public static void bubbleSort(int[] array){
        int len = array.length ;
        for (int i = 0; i < len; i++) {
            for (int item : array) {
                System.out.print(item + " ");
            }
            System.out.println();
            for (int j = 1; j < len-i; j++) {  // 表示循环比较次数，后面的额数据都是排好序的了
                if (array[j-1] > array[j]) {
                    int temp = array[j-1] ;
                    array[j-1] = array[j];
                    array[j] = temp ;
                }
            }
        }
    }
}

　　实现方式二：

　　定义一个类，作为存储数组，并进行排序。

package bubbleSort;

public class ArrayBub 
{
    private long[] a ;                // ref to Array a
    private int nElems ;            // number of data items
    
    public ArrayBub(int max){        // constructor
        a = new long[max] ;            // create the array
        nElems = 0 ;                // no items yet
    }
    
    public void insert(long value){    // put element into array
        a[nElems] = value ;            // insert it
        nElems++ ;                    // increment size
    }
    
    public void display(){            // display array contents
        for (int i = 0; i < nElems; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }
    
    public void bubbleSort(){
        int out , in ;
        for (out = nElems-1; out > 1; out--) {// outer loop (backward)
            for(in = 0; in < out; in++){      // inner loop (forward)
                if(a[in] > a[in+1]){
                    swap(in,in+1);              // swap them
                }
            }
        }
    }

    private void swap(int one, int two) {
        long temp = a[one] ;
        a[one] = a[two] ;
        a[two] = temp ;        
    }
}

　　定义一个主程序入口main函数

package bubbleSort;

public class BubbleSort 
{
	public static void main(String[] args) {
		int maxSize = 100 ;				// array size		
		ArrayBub arr  ;					// reference to array
		arr = new ArrayBub(maxSize) ;	// create the array
		
		arr.insert(6);
		arr.insert(5);
		arr.insert(3);
		arr.insert(1);
		arr.insert(8);
		arr.insert(7);
		arr.insert(2);
		arr.insert(4);
		
		arr.display();					// display items
							
		arr.bubbleSort();				// bubble sort them
				
		arr.display();					// display items again		
	}
}

　　

　　第25~34行代码，这个算法的思路是将最小的数据项放在数组的开始（下标为0），将最大的数据项放在数组的最后（下标为nElems-1）。外层for循环的计数器out从数组的最后开始，即out等于nElems-1，每经过一次循环out-1.下标大于out的数据项都已经是排好序的了。变量out在每完成一次内部循环（计数器为in）后，就左移一位，因此算法就不在处理那些已经排好序的数据了。

　　内层for循环计数器in从数组的最开始算起，即in=0，每完成一次内部循环体加1，当它等于out时就结束一次循环。在内层for循环体中，数组下标为in和in+1的两个数据项进行比较，如果下标为in的数据项大于下标为in+1的数据项，则交换两个数据项。