数据结构与算法学习之简单排序-----冒泡排序

冒泡排序，顾名思义，通过类似于一个泡泡从低处走到高处的过程来实现排序。以递增排序为例，排序过程中，每一趟从序列的初始位置向后，通过两两比较，将一个较大的数移动到序列的后方，下一趟继续从初始位置开始，重复操作，每一趟区别与前一趟的是此趟只需要对后端有序序列除外的数据进行比较，用通俗点的话来形容就是：每一趟都在剩下的胖子里面找个瘦子

举例说明，无序序列：9，5，3，6，7，1，2，排序的详细过程如下：

 

第零趟： 9   5   3  6  7  1  2 

第一趟：❶  9>5故 5  9  3  6  7  1  2

                ❷  9>3故 5  3  9  6  7  1  2

                ❸  9>6故 5  3  6  9  7  1  2

                ❹  9>7故 5  3  6  7  9  1  2

                ❺  9>1故 5  3  6  7  1  9  2

                ❻  9>2故 5  3  6  7  1  2  9  至此第一趟排序结束，最大的数9被找出并放到了最后

第二趟：❶  5>3故 3  5  6  7  1  2  9

                ❷  5<6故3  5  6  7  1  2  9

                ❸  6<7故3  5  6  7  1  2  9

                ❹  7>1故3  5  6  1  7  2  9

                ❺  7>2故3  5  6  1  2  7  9  至此第二趟排序结束，第二大的数7被找出     

第三趟：❶  3<5故 3  5  6  1  2  7  9 

                ❷  5<6故3  5  6  1  2  7  9

                ❸ 6>1故3  5  1  6  2  7  9

                ❹  6>2故3  5  1  2  6  7  9   至此第三趟排序结束，第三大的数6被找出

第四趟：❶  3<5故 3  5  1  2  6  7  9

                ❷  5>1故3  1  5  2  6  7  9

                ❸  5>2故3  1  2  5  6  7  9  至此第四趟排序结束，第四大的数5被找出

第五趟：❶  3>1故 1  3  2 5  6  7  9

                ❷  3>2故1  2  3  5  6  7  9  至此第五趟排序结束，第五大的数3被找出

 

至此，冒泡排序已结束，可以发现，每一趟排序需要进行的比较次数较上次少1。

 

以下为用java语言对冒泡排序的具体实现：

/**
 * 冒泡排序
 * @author rain
 *
 */
class Elements {
	private Long[] arr;
	private int count;

	public Elements(int max) {
		arr = new Long[max];
		count = 0;
	}

	// --------------------------
	public void insert(long value) {
		count++;
		arr[count-1] = value;
		
	}

	// ------------------------------
	public void display() {
		for (int i = 0; i < count; i++) {
			System.out.print(arr[i] + " ");
		}
	}

	// --------------------------------
	public void bubbleSort() {
		long k;
		for (int j = count-1 ; j >= 0; j--) {
			for (int i = 0; i < j; i++) {
				if (arr[i] > arr[i + 1]) {
					k = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = k;
				}
			}
		}
	}
}

public class BubbleSortTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Elements elems = new Elements(10);
		elems.insert(9); 

		elems.insert(5);
		elems.insert(3);
		elems.insert(6);
		elems.insert(7);
		elems.insert(1);
		elems.insert(2);
				
		elems.display();
		elems.bubbleSort();
		System.out.println("");
		elems.display();
	}

}

通过数组存储待排序的数据序列，关于冒泡排序与其他排序相比的效率问题，将在学完排序之后进行统一的对比。

由于是重新开始学习，基础不好，难免很多纰漏，期待与大家一起学习和探讨！