java--冒泡排序

冒泡排序

1.需求：

给定一个数组，使数组有序

2.算法思路

假设排升序 首先定义一个数组

int[] A= {34,53,12,32,56,17};

既然是从小到大排序，也就是大数在后，小数在前，两数比较，大数向后。
第一趟：
先把34和53比较，34<53,故不换位置；
再53和12比较，53>12,交换位置；
53再和32比较53>32,交换位置；
53再和56比较；
53<56,位置不变;
56和17比较，56>17,交换位置。
经过一趟下来，就变成34，12，32，53，17，56。

第二趟：
34和12比较，34>12,交换位置；
34和32比较，34>32，交换位置；
34和53比较，34<53,位置不变；
53和17比较，53>17,交换位置；
经过一趟下来，就变成12，32，34，17，53，56。

第三趟：
12和32比较，12<32,位置不变；
32和34比较，32<34,位置不变；
34和17比较,34>17,交换位置；
34和53比较，34<53，位置不变；
经过这一趟下来，就变成了12，32，17，34，53，56。

第四趟：
12和32比较,12<32，位置不变；
32和17比较，32>17，交换位置；
32和34比较，32<34，位置不变。
就变成了12，17，32，34，53，56。这趟下来我们可以看到已将从小到大排列好了，但是计算机并不知道，所以还要继续。

第五趟：
12和17比较，12<17,位置不变；
就可以得到：
12，17，32，34，53，56
到此冒泡排序完成。

总结：
1.将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换位置，一趟下来最大元素就在数组的末尾
2.依次从上上述过程，直到数组中所有的元素都排列好

3.算法实现

package cn.Tedu.ma.suanfa.sort;

import java.util.Arrays;

@SuppressWarnings({"all"})
public class BubbleSort {
    public static void main(String[] args) {
        int[] a= {34,53,12,32,56,17};
        System.out.println(Arrays.toString(a));
        sort(a);
//        myBubblesort1(a);
        System.out.println(Arrays.toString(a));
    }

    public static void sort(int[] a) {
        for (int i = a.length - 1; i >= 0; i--) { //i从后往前走，一轮结束，说明最大元素已经到最后位置了，下一轮j少走一格
            boolean flg = false;  //设置标志，用于判断当前数组是否已经处于有序状态
            for (int j = 0; j < i; j++) {  //j从前往后走，i走一格，j走完开头到i的所有格
                if (a[j] > a[j + 1]) {  //判断两个相邻位置的元素
                    //交换两个元素的值
                    int t = 0;
                    t = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = t;
                    //当有值交换的时候，说明数组还未有序
                    flg = true;
                }
            }
            //通过标志判断数组是否有序
            if (flg == false) {
                return;
            }
        }
    }
    /*
    执行结果：
    [354, 123, 4545, 789, 12, 456, 753, 1453, 1235]
    [123, 354, 789, 12, 456, 753, 1453, 1235, 4545]
    [123, 354, 12, 456, 753, 789, 1235, 1453, 4545]
    [123, 12, 354, 456, 753, 789, 1235, 1453, 4545]
    [12, 123, 354, 456, 753, 789, 1235, 1453, 4545]
    [12, 123, 354, 456, 753, 789, 1235, 1453, 4545]
    [12, 123, 354, 456, 753, 789, 1235, 1453, 4545]
     */

    //最笨 效率最低的一种解法
    public static void myBubblesort(int[] array) {
        for (int i = 0; i < array.length; i++) {  //有多少个元素 里层跑多少轮 一个一个的比
            for (int j = 0; j < array.length - 1; j++) { //从第一个一直比较到最后一个元素
                //交换元素位置
                if (array[j] > array[j + 1]) {
                    int tmp = 0;
                    tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
        }
    }

    //优化后的代码----原文链接：https://blog.csdn.net/weixin_44580000/article/details/124668217
    //与第一个解法有异曲同工之妙 只不过是i从0开始走，到array.length-1 j从0到arr.lrngth-1-i
    public static void myBubblesort1(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int tmp = 0;
                    tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                    flg = true;
                }
            }
            if (flg == false) {
                return;
            }
        }
    }
}