学习JAVA必会的几个遍历——冒泡排序

        学习遍历前，为了让我们的算法更具有通用性，我们先介绍一下Comparable接口。

        此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

        int compareTo(T o)：比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数

一、冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

需求： 排序前：{4,5,6,3,2,1}

           排序后：{1,2,3,4,5,6}

        我们需要使用冒泡的方法将合适的元素放到合适的位置，我们可以将整个集合中最大的元素放到最后去，以此类推，最后最小的元素在第一位。

排序原理：

1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。

2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大 值。

例如：

        第一次冒泡：两两比较，4比5小，不需要交换位置（4,5,6,3,2,1）；接着，5比6小，不需要交换位置（4,5,6,3,2,1）；6比3大，6和3位置交换，继续往后比（4,5,3,6,2,1）；6比2大，6和2交换位置（4,5,3,2,6,1）；6比1大，6和1交换位置，结束（4,5,3,2,1,6）。在之后几轮的排序中就不需要考虑6了，因为6已经放在合适的位置。

以此类推：

第二次冒泡：（4,5,3,2,1）->（4,3,5,2,1）->（4,3,2,5,1）->（4,3,2,1,5），5不需考虑。

第三次冒泡：（4,3,2,1）->（3,4,2,1）->（3,2,4,1）->（3,2,1,4），4不需考虑

第四次冒泡：（3,2,1）->（2,3,1）->（2,1,3），3不需考虑

第五次冒泡：（2,1）->（1,2）

第六次冒泡：（1）

重点是每一次冒泡都需要对相邻的元素进行比较。

冒泡排序的API设计：

类名	Bubble
构造方法	Bubble()：创建Bubble对象
成员方法	1.public static void sort(Comparable[] a)：对数组内的元素进行排序 2.private static boolean greater(Comparable v,Comparable w):判断v是否大于w 3.private static void exch(Comparable[] a,int i,int j)：交换a数组中，索引i和索引j处的值

import java.util.Arrays;

/*
Comparable接口和Comparator接口的区别
Comparable接口位于java.lang包下；Comparator位于java.util包下
Comparable接口只提供了一个compareTo()方法；Comparator接口不仅提供了compara()方法，还提供了其他默认方法，如reversed()、thenComparing()，使我们可以按照更多的方式进行排序
如果要用Comparable接口，则必须实现这个接口，并重写comparaTo()方法；但是Comparator接口可以在类外部使用，通过将该接口的一个匿名类对象当做参数传递给Collections.sort()方法或者Arrays.sort()方法实现排序。
Comparator体现了一种策略模式，即可以不用要把比较方法嵌入到类中，而是可以单独在类外部使用，这样我们就可有不用改变类本身的代码而实现对类对象进行排序。
 */
public class Bubble {
    /*
对数组a中的元素进行排序
*/
    public static void sort(Comparable[] a){
        //每一次冒泡都会少一个元素
        for(int i=a.length-1;i>0;i--){//length-1是元素的最大索引
            for (int j = 0; j <i; j++) {
                if (greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }
    }
    /*
比较v元素是否大于w元素
*/
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;//结果大于0说明v大于w
    }
    /*
    数组元素i和j交换位置
    */
    private static void exch(Comparable[] a,int i,int j){
        Comparable t = a[i];
        a[i]=a[j];
        a[j]=t;
    }
    //测试代码

        public static void main(String[] args) {
            Integer[] a = {4, 5, 6, 3, 2, 1};//包装类Integer实现了Comparable接口
            Bubble.sort(a);
            System.out.println(Arrays.toString(a));
        }

//    public static void main(String[] args) {
//        int[] arr = new int[10];
//        System.out.println(arr.length);
//    }
}
/*
Comparable是一个泛型接口，这里没有用它实例化对象，只是定义了data，用于存储具体的值，比如1,3这样具体的数值，为的是调用它的compareTo方法，
这里之所以能够调用是因为Java类库中Integer，Long之类的引用数据类型都实现了Comparable接口，也就是调用的是覆写后的方法，
注意里面的this.data是root.data,也就是每次来了新的节点都从根节点开始查找。
 */

在Java中，length方法用于获取数组的长度。而length()用于获取String字符串中字符的个数。

 冒泡排序的时间复杂度分析

冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以， 我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。

在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，

那么： 元素比较的次数为：

(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

元素交换的次数为：

(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

总执行次数为： (N^2/2-N/2)+(N^2/2-N/2)=N^2-N;

按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2).