冒泡排序 思想 JAVA实现

已知一个数组78、75、91、36、72、94、43、64、93、46，使用冒泡排序将此数组有序。

冒泡排序是一个运行时间为O(N²)的排序算法。

算法思想：（已从小到大为例）

78、75、91、36、72、94、43、64、93、46      数组元素

0、 1、   2、  3、  4、  5、  6、  7、  8、  9        数组下标

首先进行第一轮排序。数组长度为array.length。

将index[0]与index[1]有序。若ndex[0]>index[1] 则交换数组元素，否则不操作。

其次将index[1]与index[2]有序，若ndex[1]>index[2] 则交换数组元素，否则不操作。

再其次将index[2]与index[3]有序，若ndex[2]>index[3] 则交换数组元素，否则不操作。

。。。。

直到第一轮排序将数组中最大的元素排序到  数组的最右侧。则第一轮排序结束。

开始第二轮排序，因为数组最后一个元素已经有序，故数组长度为array.length-1。（第二轮排序将最后一个元素排除在外）。

。。。。

开始第三轮排序，因为数组最后两个元素已经有序，故数组长度为array.length-2。（第二轮排序将最后两个元素排除在外）。

。。。。

第四轮，第五轮。直到全部有序。

已下采用java实现：

public class MaoPaoOrder {

private int[] Array;

private int currentIndex;

private int maxIndex;

public MaoPaoOrder(int size) {
          this.Array = new int[size];
          this.currentIndex = 0;
          this.maxIndex = size-1;
}

public void insert(int value) {
          if(this.maxIndex<this.currentIndex) {
                 System.out.println("数组已满");
          }else {
                 this.Array[this.currentIndex++] = value;
          }
}

public void order() {
           int out = this.Array.length-1;
           for(int i=out;i>0;i--) {                          //两层循环，外层循环控制 ‘数组的长度’，内层循环进行比较交换。冒泡排序是将有序元素集中到数组的最右侧。
               for(int j=0;j<out;j++) {                    //控制数组长度为要点，其余进行比较交换即可。
                 onchange(j,j+1);
               }
           }
}

private void onchange(int pre,int next) {
           if(this.Array[pre]>this.Array[next]) {
                  int temp = this.Array[next];
                  this.Array[next] = this.Array[pre];
                  this.Array[pre] = temp;
            }
}

public void show() {
             for (int i : Array) {
                 System.out.println(i);
             }
}
}

最终结果：36、43、46、64、72、75、78、91、93、94

冒泡排序由于进行了大量的比较复制操作，所以其运行时间为O(N²)，属于效率比较低的一种排序算法。