zoukankan      html  css  js  c++  java
  • 数组排序-冒泡排序(Bubble Sort)


    概念:

        冒泡排序是一种计算机科学领域的较为简单的排序算法,也是最基础的排序算法。它重复走访要排序的数列,一次比较两个元素,如果它们的顺序(升序/降序)与要求不相符就交换它们。走访数列的工作是重复的进行,直到没有再需要交换的元素,也就是说该数列已经排序完成。这个算法的名称由来是因为越大(或越小)的元素会经由一次次交换慢慢“浮动”到数列的顶端,故名“冒泡排序”。


    排序过程:

        临近的元素两两进行比较,按照从小到大(从大到小)的顺序进行比较交换,这样一趟以后,最大(或最小)的元素被交换到了最后一位。然后除过本趟冒泡后的最后一位元素,其余元素开始下一趟冒泡,直至所有元素均属于冒泡后的最后一位元素即冒泡排序完成。


    示例:

    package com.cnblogs.lxj.testarraysort;
    
    /**
     * @author liuxiaojiang
     * @packageName:com.cnblogs.lxj.testarraysort
     * @ClassName:BubbleSort
     * @Description:测试冒泡排序
     * @date 2020/11/27
     */
    public class BubbleSort {
    
        /**
         * 主方法
         * @param args
         */
        public static void main(String[] args) {
            int[] a = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
            printArray(a);
            bubbleSort(a);
            printArray(a);
        }
    
        /**
         * 冒泡排序方法
         * @param a
         */
        public static void bubbleSort(int[] a){
            for(int i = 0;i < a.length;i++){
                for(int j = a.length - 1;j > i;j--){
                    if(a[j - 1] > a[j]){
                        swapArray(j,j - 1,a);
                    }
                }
            }
        }
    
        /**
         * 交换方法
         * @param j
         * @param count
         * @param a
         */
        public static void swapArray(int j,int count,int[] a){
            int temp = a[j];
            a[j] = a[count];
            a[count] = temp;
        }
    
        /**
         * 输出方法
         * @param array
         */
        public static void printArray(int[] array){
            for(int a : array){
                System.out.print(a + " ");
            }
            System.out.println();
        }
    }
    

    运行结果:

    3 44 38 5 47 15 36 26 27 2 46 4 19 50 48       //初始化
    2 3 4 5 15 19 26 27 36 38 44 46 47 48 50       //冒泡结束
    

    原理:


    算法分析:

        冒泡排序就是把大的元素(或小的元素)往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。所以,如果两个元素相等,这个时候两个元素也不会发生位置交换。如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相等的元素相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定的排序算法,但是效率不是很高。


  • 相关阅读:
    线性代数思维导图——3.向量
    微分中值定理的基础题型总结
    构造函数
    Python课程笔记(七)
    0241. Different Ways to Add Parentheses (M)
    0014. Longest Common Prefix (E)
    0013. Roman to Integer (E)
    0011. Container With Most Water (M)
    0010. Regular Expression Matching (H)
    0012. Integer to Roman (M)
  • 原文地址:https://www.cnblogs.com/joyfulcode/p/14047220.html
Copyright © 2011-2022 走看看