学习遍历前，为了让我们的算法更具有通用性，我们先介绍一下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).
