数据结构与算法学习——冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

　　冒泡排序算法的运作如下:

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

冒泡排序的过程图：

package com.ydh.sort;

public class BubbleSort {

	/**
	 * 实现冒泡排序
	 * @param args
	 * @author Administrator
	 */
	
	/* 冒泡排序的思想：一次比较两个元素，如果顺序颠倒，则交换，否则，继续比较下一组数据 */
	
	public static void main(String[] args) {
		
		int[] sort = new int[]{12,33,1,45,23,68,44,24,100,88,98,59};
		
		for(int i=0;i<sort.length-1;i++)//需要sort.length-1次排序
		{
			//比较sort（0-n-1）区间，这个范围是逐渐减小的
			for(int j=0;j<sort.length-1-i;j++)
			{
				//如果相邻的两个元素的顺序颠倒，则交换
				if(sort[j] < sort[j+1])
				{
					int temp = sort[j];
					
					sort[j] = sort[j+1];
					
					sort[j+1] = temp;
				}
			}
			
			System.out.print("第" + (i + 1) + "次排序结果：");
			
			for(int a = 0; a < sort.length; a++){
                System.out.print(sort[a] + "\t");
            }
            System.out.println("");
        
		}
			System.out.print("最终排序结果：");
		    for(int a = 0; a < sort.length; a++)
		    {
		           System.out.print(sort[a] + "\t");
		     }
		
		
		
	}

}

第1次排序结果：33	12	45	23	68	44	24	100	88	98	59	1	
第2次排序结果：33	45	23	68	44	24	100	88	98	59	12	1	
第3次排序结果：45	33	68	44	24	100	88	98	59	23	12	1	
第4次排序结果：45	68	44	33	100	88	98	59	24	23	12	1	
第5次排序结果：68	45	44	100	88	98	59	33	24	23	12	1	
第6次排序结果：68	45	100	88	98	59	44	33	24	23	12	1	
第7次排序结果：68	100	88	98	59	45	44	33	24	23	12	1	
第8次排序结果：100	88	98	68	59	45	44	33	24	23	12	1	
第9次排序结果：100	98	88	68	59	45	44	33	24	23	12	1	
第10次排序结果：100	98	88	68	59	45	44	33	24	23	12	1	
第11次排序结果：100	98	88	68	59	45	44	33	24	23	12	1	
最终排序结果：100	98	88	68	59	45	44	33	24	23	12	1	

总结：冒泡排序原来学的是c++的版本。冒泡的思想就是总的有n条数据，比较的次数是n-1次，最后一个肯定是最小的(按从大到小的顺序排列的)，如果相邻的sort[j]<sort[j+1],则交换两者。

思想:它是交换式排序算法的一种.将小的值"浮"到上面,将大的值"沈"到底部的一种排序方法.n个元素的排序将进行n-1轮循环,在每一轮排序中相邻的元素进行比较,如果左边的小于或等于右边的,将保持原位置不变,如果左边的大于右边的,将这两个右边的元素的位置交换.
称定性:稳定的
时间复杂度:O(n²)