精华内容
下载资源
问答
  • JAVA冒泡排序算法详解

    2011-11-23 10:19:25
    从老师那弄的JAVA冒泡排序的一个讲解,不明白的可以好好看看哈
  • Java冒泡排序算法 基本思想 对当前还未排好序的范围内的所有数。自上而下对相邻的俩个数依次进行比較和调整,让较大的数下沉。较小的数往上冒。 即每当俩相邻的数比較后发现他们的排序与排序的要求相反时。就将他们...

    Java冒泡排序算法

    基本思想

    对当前还未排好序的范围内的所有数。自上而下对相邻的俩个数依次进行比較和调整,让较大的数下沉。较小的数往上冒。

    即每当俩相邻的数比較后发现他们的排序与排序的要求相反时。就将他们交换。每次遍历都可确定一个最大值放到待排数组的末尾,下次遍历,对该最大值以及它

    之后的元素不再排序(已经排好)。

    代码实现

    话不多说,直接上代码,部分解释在代码中以注释形式进行讲解

    package array;
    
    import java.util.Arrays;
    
    public class Demo03 {
    
    
    
        public static void main(String[] args) {
            int[] array = {2,6,4,1,8,5,3,9,7};
            sort(array);
            printArray(array);
            System.out.println("\n\n\n\n\n");
            int[] array1 = {2,6,4,1,8,5,3,9,7};
            sort1(array1);
            printArray(array1);
            System.out.println("\n\n\n\n\n");
            int[] array2 = {2,6,4,1,8,5,3,9,7};
            sort2(array2);
            printArray(array2);
            System.out.println("\n\n\n\n\n");
            int[] array3 = {2,6,4,1,8,5,3,9,7};
            sort2(array3);
            printArray(array3);
            System.out.println("\n\n\n\n\n");
        }
    
    
    
    
    
        //定义一个打印数组的方法
        public static void printArray(int[] array){
            System.out.println("**************************************************");
            System.out.println("排序后的数组为:"+Arrays.toString(array));
            System.out.println("**************************************************");
        }
    
    
    
    
    
    
        //初级冒泡排序方法
        /*用最初级的冒泡排序我们可以发现存在这样一种现象:
        当第4次外层循环执行完毕后,数组已经排序完成,但是后面4次外层循环还是会进行,这是对内存资源以及效率的浪费
        */
    
        public static void sort(int[] array){
            int temp = 0;
            //外层循环
            for (int i=0;i<array.length-1;i++){
                //内层循环
                for (int j=0;j<array.length-i-1;j++){
                    if (array[j]>array[j+1]){
                        temp = array[j+1];
                        array[j+1] = array[j];
                        array[j] = temp;
                    }
                }
                //打印每次外层循环一次后的数组排序
                System.out.println("第"+(i+1)+"次外层循环后的数组排序为:");
                System.out.println("__________________________________________");
                System.out.println(Arrays.toString(array));
            }
        }
    
    
    
    
        //改进冒泡排序方法1
        /*上面已经分析过。冒泡排序的效率比較低,所以我们要通过各种方法改进。
        最简单的改进方法是增加一标志性变量flag,用于标志某一趟排序过程中是否有数据交换.
        假设进行某一趟排序时并没有进行数据交换。则说明数据已经按要求排列好,可马上结束排序,避免不必要的比較过程
        在上例中,第4轮排序之后实际上整个数组已经是有序的了。最后4轮的比較不是必需进行。
        改进后的代码例如以下:*/
        public static void sort1(int[] array){
            int temp = 0;
            for (int i=0;i<array.length-1;i++){
                boolean flag = false;
                for (int j=0;j<array.length-i-1;j++){
                    if (array[j] > array[j+1]){
                        temp = array[j+1];
                        array[j+1] = array[j];
                        array[j] = temp;
                        //当发生了数据交换现象,flag为true
                        flag = true;
                    }
                }
                System.out.println("第"+(i+1)+"次外层循环后的数组排序为:");
                System.out.println("__________________________________________");
                System.out.println(Arrays.toString(array));
                if(!flag){
                    break;//假设上一轮没有发生交换数据。证明已经是有序的了。结束排序
                }
            }
        }
    
    
    
    
    
    
    
        //改进冒泡排序方法2
        /*第1轮排序之后,11、18、20已经是有序的了,后面的几次排序后它们的位置都没有变化,
        可是依据冒泡算法。18依旧会在第2轮參与比較,11依旧会在第2轮、第3轮參与比較,事实上都是无用功。
        我们能够对算法进一步改进:设置一个pos指针。pos后面的数据在上一轮排序中没有发生交换,下一轮排序时,就对pos之后的数据不再比較*/
        public static void sort2(int[] array){
            int temp;
            int counter = 1;
            int endPoint = array.length-1;  //endPoint代表最后一个须要比較的元素下标
    
            while(endPoint>0){
                int pos = 1;
                for(int j=1;j<=endPoint;j++){
                    if(array[j-1]>array[j]){  //假设前一位大于后一位。交换位置
                        temp= array[j-1];
                        array[j-1]= array[j];
                        array[j]= temp;
    
                        pos= j;  //下标为j的元素与下标为j-1的元素发生了数据交换
                    }
                }
                endPoint= pos-1;  //下一轮排序时仅仅对下标小于pos的元素排序,下标大于等于pos的元素已经排好
    
                System.out.println("第"+counter+"轮排序结果:"+Arrays.toString(array));
                System.out.println("__________________________________________");
                counter++;
            }
        }
    
    
    
    
    
        //改进冒泡排序方法3
        /*对的算法来说。没有最好。仅仅有更好。上面的两种改进方法事实上治标不治本,是一种“扬汤止沸”的改进。以下我们来一次“釜底抽薪”的改进。
        传统的冒泡算法每次排序仅仅确定了最大值,我们能够在每次循环之中进行正反两次冒泡,分别找到最大值和最小值,如此可使排序的轮数降低一半*/
        public static void sort3(int[] array){
            int temp;
            int low = 0;
            int high = array.length-1;
            int counter = 1;
            while(low<high){
    
                for(int i=low;i<high;++i){   //正向冒泡,确定最大值
                    if(array[i]>array[i+1]){  //假设前一位大于后一位。交换位置
                        temp= array[i];
                        array[i]= array[i+1];
                        array[i+1]= temp;
                    }
                }
                --high;
    
                for(int j=high;j>low;--j){   //反向冒泡,确定最小值
                    if(array[j]<array[j-1]){  //假设前一位大于后一位,交换位置
                        temp= array[j];
                        array[j]= array[j-1];
                        array[j-1]= temp;
                    }
                }
                ++low;
                System.out.print("第"+counter+"轮排序结果:");
                counter++;
            }
        }
    }
    
    
    
    
    
    
    
    
    //运行结果为:1次外层循环后的数组排序为:
    __________________________________________
    [2, 4, 1, 6, 5, 3, 8, 7, 9]2次外层循环后的数组排序为:
    __________________________________________
    [2, 1, 4, 5, 3, 6, 7, 8, 9]3次外层循环后的数组排序为:
    __________________________________________
    [1, 2, 4, 3, 5, 6, 7, 8, 9]4次外层循环后的数组排序为:
    __________________________________________
    [1, 2, 3, 4, 5, 6, 7, 8, 9]5次外层循环后的数组排序为:
    __________________________________________
    [1, 2, 3, 4, 5, 6, 7, 8, 9]6次外层循环后的数组排序为:
    __________________________________________
    [1, 2, 3, 4, 5, 6, 7, 8, 9]7次外层循环后的数组排序为:
    __________________________________________
    [1, 2, 3, 4, 5, 6, 7, 8, 9]8次外层循环后的数组排序为:
    __________________________________________
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    **************************************************
    排序后的数组为:[1, 2, 3, 4, 5, 6, 7, 8, 9]
    **************************************************1次外层循环后的数组排序为:
    __________________________________________
    [2, 4, 1, 6, 5, 3, 8, 7, 9]2次外层循环后的数组排序为:
    __________________________________________
    [2, 1, 4, 5, 3, 6, 7, 8, 9]3次外层循环后的数组排序为:
    __________________________________________
    [1, 2, 4, 3, 5, 6, 7, 8, 9]4次外层循环后的数组排序为:
    __________________________________________
    [1, 2, 3, 4, 5, 6, 7, 8, 9]5次外层循环后的数组排序为:
    __________________________________________
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    **************************************************
    排序后的数组为:[1, 2, 3, 4, 5, 6, 7, 8, 9]
    **************************************************1轮排序结果:[2, 4, 1, 6, 5, 3, 8, 7, 9]
    __________________________________________
    第2轮排序结果:[2, 1, 4, 5, 3, 6, 7, 8, 9]
    __________________________________________
    第3轮排序结果:[1, 2, 4, 3, 5, 6, 7, 8, 9]
    __________________________________________
    第4轮排序结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]
    __________________________________________
    第5轮排序结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]
    __________________________________________
    **************************************************
    排序后的数组为:[1, 2, 3, 4, 5, 6, 7, 8, 9]
    **************************************************1轮排序结果:[2, 4, 1, 6, 5, 3, 8, 7, 9]
    __________________________________________
    第2轮排序结果:[2, 1, 4, 5, 3, 6, 7, 8, 9]
    __________________________________________
    第3轮排序结果:[1, 2, 4, 3, 5, 6, 7, 8, 9]
    __________________________________________
    第4轮排序结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]
    __________________________________________
    第5轮排序结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]
    __________________________________________
    **************************************************
    排序后的数组为:[1, 2, 3, 4, 5, 6, 7, 8, 9]
    **************************************************
    
    
    

    冒泡排序的算法分析

    待排数组中一共同拥有9个数。第一轮排序时进行了8次比較。第二轮排序时进行了5比較。依次类推,最后一轮进行了一次比較。

    增加元素总数为N,则一共须要的比較次数为:

    (N-1)+ (N-2)+ (N-3)+ …1=N*(N-1)/2

    这样,算法约做了N2/2次比較。由于仅仅有在前面的元素比后面的元素大时才交换数据,所以交换的次数少于比較的次数。假设数据是随机的,大概有一半数据须要交换。则交换的次数为N2/4(只是在最坏情况下,即初始数据逆序时,每次比較都须要交换)。

    交换和比較的操作次数都与N2成正比,由于在大O表示法中。常数忽略不计,冒泡排序的时间复杂度为O(N2)

    O(N2)的时间复杂度是一个比較糟糕的结果。尤其在数据量非常大的情况下。所以冒泡排序通常不会用于实际应用

    展开全文
  • 冒泡排序算法详解

    2019-11-28 00:00:13
    什么是冒泡排序?...而我们的冒泡排序之所以叫做冒泡排序,正是因为这种排序算法的每一个元素都可以像小气泡一样,根据自身大小,一点一点向着数组的一侧移动。 具体如何来移动呢?让我们来看一个栗子: 有...

    什么是冒泡排序?

    冒泡排序的英文Bubble Sort,是一种最基础的交换排序。

    大家一定都喝过汽水,汽水中常常有许多小小的气泡,哗啦哗啦飘到上面来。这是因为组成小气泡的二氧化碳比水要轻,所以小气泡可以一点一点向上浮动。
    img

    而我们的冒泡排序之所以叫做冒泡排序,正是因为这种排序算法的每一个元素都可以像小气泡一样,根据自身大小,一点一点向着数组的一侧移动。

    具体如何来移动呢?让我们来看一个栗子:
    img
    有8个数 组成一个无序数列:5,8,6,3,9,2,1,7,希望从小到大排序。

    按照冒泡排序的思想,我们要把相邻的元素两两比较,根据大小来交换元素的位置,过程如下:

    首先让5和8比较,发现5比8小,因此元素位置不变。

    接下来让8和6比较,发现8比6要大,所以8和6交换位置。
    img

    继续让8和3比较,发现8比3要大,所以8和3交换位置。
    img

    继续让8和9比较,发现8比9要小,所以元素位置不变。

    接下来让9和2比较,发现9比2要大,所以9和2交换位置。

    img

    接下来让9和1比较,发现9比1要大,所以9和1交换位置。

    img

    最后让9和7比较,发现9比7要大,所以9和7交换位置。

    img

    这样一来,元素9作为数列的最大元素,就像汽水里的小气泡一样飘啊飘,飘到了最右侧。

    这时候,我们的冒泡排序的第一轮结束了。数列最右侧的元素9可以认为是一个有序区域,有序区域目前只有一个元素。
    img

    下面,让我们来进行第二轮排序:

    首先让5和6比较,发现5比6要小,因此元素位置不变。

    接下来让6和3比较,发现6比3要大,所以6和3交换位置。
    img

    继续让6和8比较,发现6比8要小,因此元素位置不变。

    接下来让8和2比较,发现8比2要大,所以8和2交换位置。

    img

    接下来让8和1比较,发现8比1要大,所以8和1交换位置。

    img

    继续让8和7比较,发现8比7要大,所以8和7交换位置。

    img

    第二轮排序结束后,我们数列右侧的有序区有了两个元素,顺序如下:
    img

    至于后续的交换细节,我们这里就不详细描述了,第三轮过后的状态如下:
    img

    第四轮过后状态如下:
    img
    第五轮过后状态如下:
    img

    第六轮过后状态如下:

    img

    第七轮过后状态如下(已经是有序了,所以没有改变):
    img

    第八轮过后状态如下(同样没有改变):
    img

    到此为止,所有元素都是有序的了,这就是冒泡排序的整体思路。

    原始的冒泡排序是稳定排序。由于该排序算法的每一轮要遍历所有元素,轮转的次数和元素数量相当,所以时间复杂度是O(N^2) 。

    冒泡排序第一版:

    public class BubbleSort{
        private static void sort(int array[])
        {
            int tmp = 0;
            for(int i = 0;i< array.length;i++)
            {
                for(int j = 0;j<array.length -i-1;j++)
                {
                    if(array[j] > array[j+1])
                    {
                        tmp = array[j];
                        array[j] = array[j+1];
                        array[j+1] = tmp;
                    }
                }
            }
        }
        public static void main(String [] args){
            int [] array = new int [] {5,8,6,3,9,2,1,7};
            sort(array);
            System.out.println(Arrays.toString(array));
        }
    }
    

    代码非常简单,使用双循环来进行排序。外部循环控制所有的回合,内部循环代表每一轮的冒泡处理,先进行元素比较,再进行元素交换。

    原始的冒泡排序有哪些优化点呢?

    让我们回顾一下刚才描述的排序细节,仍然以5,8,6,3,9,2,1,7这个数列为例,当排序算法分别执行到第六、第七、第八轮的时候,数列状态如下:
    img

    很明显可以看出,自从经过第六轮排序,整个数列已然是有序的了。可是我们的排序算法仍然“兢兢业业”地继续执行第七轮、第八轮。

    这种情况下,如果我们能判断出数列已经有序,并且做出标记,剩下的几轮排序就可以不必执行,提早结束工作。

    冒泡排序第二版

    public class BubbleSort{
        private static void sort(int array[])
        {
            int tmp =0;
            for(int i = 0;i<array.length;i++)
            {
                //有序标记,每一轮的初始是true
                boolean isSorted = true;
                for(int j=0;j<array.length-i-1;j++)
                {
                    if(array[j]>array[j+1])
                    {
                        tmp = array[j];
                        array[j] = array[j+1];
                        array[j+1]= tmp;
                        //有元素交换,所以不是有序,标记变为false
                        isSorted = false;
                    }
                     }
                    if(isSorted)
                    {
                        break;
                    }
                }
            }
            
       
        public static void main(String[] args){
                int[] array = new int[]{5,8,6,3,9,2,1,7};
                sort(array);
                System.out.println(Arrays.toString(array));
            }
    }
    
    这一版代码做了小小的改动,利用布尔变量isSorted作为标记。如果在本轮排序中,元素有交换,则说明数列无序;如果没有元素交换,说明数列已然有序,直接跳出大循环。
    

    再次优化

    为了说明问题,咱们这次找一个新的数列:
    img
    这个数列的特点是前半部分(3,4,2,1)无序,后半部分(5,6,7,8)升序,并且后半部分的元素已经是数列最大值。

    让我们按照冒泡排序的思路来进行排序,看一看具体效果:

    第一轮

    元素3和4比较,发现3小于4,所以位置不变。

    元素4和2比较,发现4大于2,所以4和2交换。
    img
    img

    元素4和1比较,发现4大于1,所以4和1交换。
    img

    元素4和5比较,发现4小于5,所以位置不变。

    元素5和6比较,发现5小于6,所以位置不变。

    元素6和7比较,发现6小于7,所以位置不变。

    元素7和8比较,发现7小于8,所以位置不变。

    第一轮结束,数列有序区包含一个元素:

    img

    第二轮

    元素3和2比较,发现3大于2,所以3和2交换。

    img
    img

    元素3和1比较,发现3大于1,所以3和1交换。

    img
    img

    元素3和4比较,发现3小于4,所以位置不变。

    元素4和5比较,发现4小于5,所以位置不变。

    元素5和6比较,发现5小于6,所以位置不变。

    元素6和7比较,发现6小于7,所以位置不变。

    元素7和8比较,发现7小于8,所以位置不变。

    第二轮结束,数列有序区包含一个元素:
    img
    这个问题的关键点在哪里呢?关键在于对数列有序区的界定。

    按照现有的逻辑,有序区的长度和排序的轮数是相等的。比如第一轮排序过后的有序区长度是1,第二轮排序过后的有序区长度是2 …

    实际上,数列真正的有序区可能会大于这个长度,比如例子中仅仅第二轮,后面5个元素实际都已经属于有序区。因此后面的许多次元素比较是没有意义的。

    如何避免这种情况呢?我们可以在每一轮排序的最后,记录下最后一次元素交换的位置,那个位置也就是无序数列的边界,再往后就是有序区了。

    冒泡排序第三版

    public class BubbleSort{
        private static void sort(int array[])
        {
            int tmp = 0;
            //记录最后一次交换的位置
            int lastExchangeIndex = 0;
            //无序数列的边界,每次比较只需要比到这里为止
            int sortBorder = array.length-1;
            for(int i =0;i<array.length;i++)
            {
                //有序标记,每一轮的初始是true
                boolean isSorted = true;
                for(int j =0;j<sortBorder;j++)
                {
                    if(array[j]>array[j+1])
                    {
                        tmp = array[j];
                        array[j] = array[j+1];
                        array[j+1] = tmp;
                        //有元素交换,所以不是有序,标记变为false
                        isSorted = false;
                        //把无序数列的边界更新为最后一次交换元素的位置
                        lastExchangeIndex = j;
                    }
                }
                sortBorder = lastExchangeIndex;
                if(isSorted)
                {
                    break;
                }
            }
        }
        public static void main(String[] args)
        {
            int[] array = new int[]{3,4,2,1,5,6,7,8};
            sort(array);
            System.out.println(Arrays.toString(array));
        }
    }
    

    这一版代码中,sortBorder就是无序数列的边界。每一轮排序过程中,sortBorder之后的元素就完全不需要比较了,肯定是有序的。
    注:文章来自小灰算法
    小灰算法

    展开全文
  • 经典排序算法(1)——冒泡排序算法详解
                   

    冒泡排序(Bubble Sort)是一种典型的交换排序算法,通过交换数据元素的位置进行排序。


    一、算法基本思想

    (1)基本思想

    冒泡排序的基本思想就是:从无序序列头部开始,进行两两比较,根据大小交换位置,直到最后将最大(小)的数据元素交换到了无序队列的队尾,从而成为有序序列的一部分;下一次继续这个过程,直到所有数据元素都排好序。

    算法的核心在于每次通过两两比较交换位置,选出剩余无序序列里最大(小)的数据元素放到队尾。


    (2)运行过程

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

    1、比较相邻的元素。如果第一个比第二个大(小),就交换他们两个。

    2、对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大(小)的数。

    3、针对所有的元素重复以上的步骤,除了最后已经选出的元素(有序)。

    4、持续每次对越来越少的元素(无序元素)重复上面的步骤,直到没有任何一对数字需要比较,则序列最终有序。


    (3)示例


    二、算法实现(核心代码)

    C++实现:

    void bubble_sort(int arr[], int len) int i, j; for (i = 0; i < len - 1; i++)  for (j = 0; j < len - 1 - i; j++)   if (arr[j] > arr[j + 1])    swap(arr[j], arr[j + 1]);}


    Java实现:

    public static void bubble_sort(int[] arr) {  int i, j, temp, len = arr.length;  for (i = 0; i < len - 1; i++)   for (j = 0; j < len - 1 - i; j++)    if (arr[j] > arr[j + 1]) {     temp = arr[j];     arr[j] = arr[j + 1];     arr[j + 1] = temp;    }}


    三、算法改进和变种

    (1)设置标志变量change

    标志变量用于记录每趟冒泡排序是否发生数据元素位置交换。如果没有发生交换,说明序列已经有序了,不必继续进行下去了。

    void bubble_sort(int arr[], int len) int i, j, change=1;         for (i = 0; i < len - 1 && change!=0; i++)        {                change=0;  for (j = 0; j < len - 1 - i; j++)   if (arr[j] > arr[j + 1])                        {    swap(arr[j], arr[j + 1]);                                change = 1;                         }        }}

    (2)鸡尾酒排序

    鸡尾酒排序又叫定向冒泡排序,搅拌排序、来回排序等,是冒泡排序的一种变形。此算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序。

    鸡尾酒排序在于排序过程是先从低到高,然后从高到低;而冒泡排序则仅从低到高去比较序列里的每个元素。它可以得到比冒泡排序稍微好一点的效能,原因是冒泡排序只从一个方向进行比对(由低到高),每次循环只移动一个项目。

    以序列(2,3,4,5,1)为例,鸡尾酒排序只需要从低到高,然后从高到低就可以完成排序,但如果使用冒泡排序则需要四次。

    但是在乱数序列的状态下,鸡尾酒排序与冒泡排序的效率都很差劲。

    void cocktail_sort(int arr[], int len) int j, left = 0, right = len - 1while (left < right) {  for (j = left; j < right; j++)   if (arr[j] > arr[j + 1])    swap(arr[j], arr[j + 1]);  right--;  for (j = right; j > left; j--)   if (arr[j - 1] > arr[j])    swap(arr[j - 1], arr[j]);  left++; }}


    四、性能(算法时间、空间复杂度、稳定性)分析

    (1)时间复杂度

    在设置标志变量之后:

    当原始序列“正序”排列时,冒泡排序总的比较次数为n-1,移动次数为0,也就是说冒泡排序在最好情况下的时间复杂度为O(n);

    当原始序列“逆序”排序时,冒泡排序总的比较次数为n(n-1)/2,移动次数为3n(n-1)/2次,所以冒泡排序在最坏情况下的时间复杂度为O(n^2);

    当原始序列杂乱无序时,冒泡排序的平均时间复杂度为O(n^2)。


    (2)空间复杂度

    冒泡排序排序过程中需要一个临时变量进行两两交换,所需要的额外空间为1,因此空间复杂度为O(1)。


    (3)稳定性

    冒泡排序在排序过程中,元素两两交换时,相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。



               
    展开全文
  • 例题:要求将数组{3, 7, 2, -13, 19, 8}通过冒泡排序算法由小到大排序。 冒泡排序:比较相邻的两个元素,step1:(1)从第一个数开始和第二个数比较,若第二个数比第一个大,则保持不变,若第一个数较大,则这两个数...

    冒泡排序作为排序算法中很经典也相对简单的算法,学编程的一定都会接触,在最近的学习中对冒泡排序有更深入的理解,特此记录。
    例题:要求将数组{3, 7, 2, -13, 19, 8}通过冒泡排序算法由小到大排序。
    冒泡排序:比较相邻的两个元素,step1:(1)从第一个数开始和第二个数比较,若第二个数比第一个大,则保持不变,若第一个数较大,则这两个数交换位置。
    (2)同理,让第二个数和第三个数比较

    (n - 1)让第n-1个数和第n个数比较
    当step1比较结束后,此时数组的最后一个值一定为数组最大的一个值
    step2:继续以step1的规则进行比较,需要注意的是此时最后一个数是不需要进行排序的,因为已经是最大的了。

    step(n-1):都效仿step2
    在这里插入图片描述

    以第一次循环为例说明比较过程,3和7比7大所以保持不变,7和2比,7大所以2和7交换,7再和-13比,7大继续交换,7和19比19大保持不变,19和8比,19大交换如下所示:
    在这里插入图片描述

    可以发现一个规律,循环的次数 = 数组的长度 - 1;比较的次数 = 数组的长度 - 1 - 第n次循环的n值。
    最后附上python、java的实现
    python:

    import os
    
    
    class SortPort():
        def __init__(self):
            pass
    
        def bubblesort(self, lis):
            for j in range(len(lis) - 1):    # 完整的一次排序需要的次数
                for i in range(len(lis) - j - 1):     # 每一次排序具体的交换次数
                    if lis[i] > lis[i + 1]:
                        lis[i], lis[i + 1] = lis[i + 1], lis[i]
            print(l)
            return l
    
    
    if __name__ == '__main__':
        l = [3, 7, 2, -13, 19, 8]
        A = SortPort()
        A.bubblesort(l)
    

    Java:

    import java.util.Arrays;
    
    public class BubbleSort {
        public static void main(String[] args) {
    
            int[] arr = new int[]{3, 7, 2, -13, 19, 8};
    
            //冒泡排序
            //n个元素的数组就需要进行n-1大轮的排序
            for (int i = 0;i < arr.length - 1;i++){
                /*每一大轮的循环需要进行的次数(第一大轮结束以后,最后一个数一定为最大的值,
                所以第二大轮排序时则不用管最后一个值,第二大轮结束以后同理倒数第二个数是除了最后一个数以外的最大值)
                 */
                for (int j = 0;j < arr.length - i -1;j++){
    
                    if (arr[j] > arr[j + 1]){
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
    
            }
            System.out.println(Arrays.toString(arr));
        }
    }
    

    在这里插入图片描述


    未经许可,禁止转载!

    展开全文
  • 这里先对冒泡排序算法进行分析讨论。 冒泡排序思想 ! 冒泡排序算法是通过比较两个相邻元素,然后根据比较条件是否执行交换位置实现的。通常我们会用它来对数组进行排序,下面我将已数组排序作为研究对象对冒泡...
  • 一、算法基本思想(1)基本思想冒泡排序的基本思想就是:从无序序列头部开始,进行两两比较,根据大小交换位置,直到最后将最大...(2)运行过程冒泡排序算法的运作如下:1、比较相邻的元素。如果第一个比第二个大(...
  • Java冒泡排序算法

    千次阅读 2013-12-22 23:02:40
    冒泡排序算法详解:http://blog.csdn.net/ysjian_pingcx/article/details/8653732 冒泡排序算法源码免积分下载:http://download.csdn.net/detail/ysjian_pingcx/6755209 序:一个爱上Java最初的想法一直没有磨灭:...
  • 主要介绍了java 算法冒泡排序实例详解的相关资料,冒泡排序,就是模仿泡泡从水中浮起跑到水面的过程需要的朋友可以参考下
  • java数组冒泡排序算法代码详解

    千次阅读 2019-10-17 15:45:38
    冒泡排序由两层嵌套循环实现排序,外层循环数据对比轮数,内层循环控制每轮对比次数,每一轮依次减少一次对比次数,最终实现排序 */ //乱序数组 int[] arr = {9,3,2,10,4,6}; //外层控制对比轮...
  • java编写一个方法,其功能是对一个整型数组升序排列(请采用冒泡算法) According to 我的刚学的 konwledge ,the 冒泡就是这样写的 public class test { public static void maopao(int[] arr) { for (int i = 0;...
  • 冒泡排序:俩俩比较,大的值下沉,小的上浮,最终排序顺序从小到大 ... //然后进行冒泡排序算法,才用for循环 for(int i=0;i<num.length-1;i++){ for(int j=0;j<num[i].length-i-1;j++){ if(n
  • Java冒泡排序一、算法原理二、算法步骤三、代码实现 一、算法原理 例如我们有一个数组,我们如果需要把较大的元素排在后面,把小的元素排在前面,那么需要从头部到尾开始比较操作: 比较相邻的元素。如果第一个比...
  • 冒泡排序算法 Java 实现过程及详解

    千次阅读 2014-12-25 23:23:06
    冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,... 冒泡排序算法的运作如下:  比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素作同样
  • 冒泡排序排序算法中比较经典的算法,首先它的时间复杂度为O(n^2),时间复杂度为平方的算法一般就需要两层嵌套循环。 首先分析一下这个算法,这个算法主要是每次查看的相邻的两个数据进行大小比较,然后将大的数据...
  • java冒泡排序详解

    千次阅读 多人点赞 2016-12-23 11:52:31
    冒泡排序详解
  • java常见排序算法详解

    2018-02-27 10:58:18
    冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经...
  • 冒泡排序是一种非常常见的排序算法。如同水中的一排泡泡,先冒出最大的一个泡泡。再冒出剩余泡泡中的最大泡泡,依次类推,它的排序规则如下:从第一个元素开始,比较相邻的两个元素,如果后面的小于前面的,交换两个...
  • Java冒泡排序详解

    2018-05-13 10:17:17
    突然想着写一波Java的常用排序算法,有需要的小伙伴可以关注我一波,我陆续会出Java的常用排序算法。 1. 冒泡排序原理:将被排序的记录数为n的数组r垂直排列,从上往下扫描该数组r,两两相邻的比较,排序逆序就交换...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,437
精华内容 1,374
关键字:

java冒泡排序算法详解

java 订阅