基本算法：冒泡排序算法

基本算法：冒泡排序算法

冒泡算法简介

冒泡算法（Bubble Sort)，是一种比较简单的排序算法。其排序逻辑是：重复访问需要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小首字母从A到Z）有误，就会对元素进行位置交换，重复该过程直到没有相邻的元素需要进行交换。
算法的名称是因为经过该算法排序后，越小的元素会经过交换会像泡泡一样慢慢浮动到数列的顶端，故此得名冒泡算法。

算法排序详解

假设有数组【1，6，3，5，2】，我们使用从小到大进行的方式进行冒泡排序。

第一趟排序：

1. 1与6相比，1小于6，位置不变。【1，6，3，5，2】
2. 6与3相比，6大于3，交换位置。【1，3，6，5，2】
3. 6与5相比，6大于5，交换位置。【1，3，5，6，2】
4. 6与2相比，6大于2，交换位置。【1，3，5，2，6】

第二趟排序：

1. 1与3相比，1小于3，位置不变。【1，3，5，2，6】
2. 3与5相比，3小于5，位置不变。【1，3，5，2，6】
3. 5与2相比，5大于2，交换位置。【1，3，2，5，6】

第三趟排序：

1. 1与3相比，1小于3，位置不变。【1，3，2，5，6】
2. 3与2相比，3大于2，交换位置。【1，2，3，5，6】

分析

• 冒泡排序每排序一趟，就会少比较一个数据。因为每一次排序都会将较大值进行下标后移，第一趟排排序，找出最大值，第二趟排序找出次大值。比较到最后，需要比较的数据越来越少。N个长度的数据要进行冒泡排序，要进行N-1趟排序，第i趟的排除次数为N-i-1次（因为每一趟就会少比较一个数据）。

复杂度分析

下面我们来分析下冒泡排序的时间复杂度和空间复杂度。

时间复杂度：

• 最好的情况：数据本身已经排序完毕，那就不用元素交换。仅需n-1次即可完成排序，时间复杂度是O(n)。
• 最坏情况:数据是逆序排列，所以我们要全部重新排序一次。对于n位的数列则有比较次数为 (n-1) + (n-2) + ... + 1 = n * (n - 1) / 2=O(n^2)。
• 平均复杂度：O(n^2)

空间复杂度：该算法的所消耗的存储空间。

• 最好情况：数据本身有序，不会用到临时变量，则复杂度为0。
• 最差情况：数据逆序排序，每次都会使用到临时变量。复杂度为O(n)。
• 平均复杂度：O(1)。

Java代码实现

package top.enjoyitlife.bubble;

import java.util.Arrays;

/***
* @ClassName: BubbleAlgorithm 
* @Description: 冒泡排序算法
* @author MegaSlark 
 */
public class BubbleAlgorithm {
    public static void main(String[] args) {
        int[] nums=new int[] {1,2,3,6,7};
        BubbleAlgorithm ba = new BubbleAlgorithm();
        ba.bubbleSort(nums);
        System.out.println(Arrays.toString(nums));
    }

    /****
     * 冒泡排序 正序 有小到大
     * @param nums
     */
    public void bubbleSort(int[] nums) {
        if(null==nums||nums.length<1) {
            return;
        }
        int length=nums.length;
        //数组下标从0开始，比较趟数为数组长度减1
        for(int i=0;i  nums[j+1]) {
                    temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                    flag=false;
                }
            }
            if(flag) {
                break;
            }
            
        }
    }
}

以上就是冒泡排序的接受及代码示例，希望对你有所帮助。