冒泡排序算法的实现及原理---Java实现

偏执的太偏执、 2022-12-31 15:26 167阅读 0赞

# 冒泡排序 #

## 冒泡排序的原则 ##

假设现在有一个数组 **\[a,b,c,d,e\]**  
**拿到最左边的元素与自己相邻的右边的元素进行比较，如果a>b,则a与b进行交换位置，紧接着，a与c进行比较，如果a>c，则a与c再次交换位置，以此类推，每次循环后将最大的元素冒出。**

现在有一个数组 \[3,1,6,2,5\]，用代码实现冒泡排序，思路如下：

第一次要比较的元素：3,1,6,2,5

*  外层第一次循环：
 *  3与1比较，3和1交换位置，交换后的元素排列为：1,3,6,2,5
 *  3与6比较，3和6不交换位置，但是会进行比较，元素排列为：1,3,6,2,5
 *  6与2比较， 2和6交换位置，交换后的元素排列为：1,3,2,6,5
 *  6和5比较，5和6交换位置，交换后的元素排列为：1,3,2,5,6
 *  **6最终冒出**
 *

第二次要比较的元素：1,3,2,5

*  外层第二次循环：
 *  1与3比较，不交换位置，但是会比较，元素排列为：1,3,2,5
 *  3与2比较，3和2交换位置，交换后的元素排列为：1,2,3,5
 *  3与5比较，不交换位置，但是会进行比较，元素排列为：1,2,3,5
 *  **5最终冒出**
 *

第三次要比较的元素：1,2,3

*  外层第三次循环：
 *  1和2比较，1和2不交换位置，但是会进行比较，元素排列为：1,2,3
 *  2和3比较， 2和3不交换位置，但是会进行比较，元素排列为：1,2,3
 *  **3最终冒出**
 *

第四次要比较的元素：1,2

*  外层第四次循环：
 *  1和2比较，1和2不交换位置，但是会进行比较，元素排列为：1,2
 *  **2最终冒出**
 *  
 *  冒泡排序规律：
 *      外层循环次数 = 数组元素的长度-1
 *      内层循环次数 = 比较元素个数-1

代码实现如下：

public class BubbleSort { 
    	public static void main(String[] args) { 
    		int[] arr = { 3,1,6,2,5};
    		for(int i = arr.length-1; i>0;i--) { 
    			for(int j=0;j<i;j++) { 
    				if(arr[j]>arr[j+1]) {  //比较完进行交换位置，arr[j]与arr[j+1]进行交换位置
    					int temp;
    					temp=arr[j];
    					arr[j]=arr[j+1];
    					arr[j+1]=temp;
    				}
    			}
    		}
    		//排序后进行遍历
    		for(int i=0;i<arr.length;i++) { 
    			System.out.println(arr[i]);
    		}
    	}
    }

交换位置图解如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pTNzQ1MjA_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pTNzQ1MjA_size_16_color_FFFFFF_t_70]: /images/20221120/5c06d01a164347cab8718a64e2eb1e14.png