冒泡排序

介绍

冒泡排序是一种算法，比较相邻元素，如果他们处在错误的位置上，那么交换他们的位置。排序可以进行升序或者降序。

原理

1. 从第一个元素开始，比较第一个元素和第二个元素，如果第一个元素大于第二个元素，那么交换他们的位置。
   比较 第二个元素和第三个元素的位置，如果处在错误的位置，那么交换他们。
   上面的过程直到数组的最后一个元素。
   
   2. 相同的过程应用于剩余的迭代中，每次迭代之后，最大的元素将会放在未排序的元素之后。
      每次迭代之后，对比结束在最后一个未排序的元素
      当未排序的元素放在正确的位置上，那么久完成排序了。
      
      
      

冒泡排序算法

```
bubbleSort(array)
  	for i <- 1 to indexOfLastUnsortedElement-1
	    if leftElement > rightElement
	      swap leftElement and rightElement
end bubbleSort
```

Java实现

// Bubble sort in Java

import java.util.Arrays;

class BubbleSort {
  void bubbleSort(int array[]) {
    int size = array.length;
    for (int i = 0; i < size - 1; i++)
      for (int j = 0; j < size - i - 1; j++)
        // To sort in descending order, change > to < in this line.
        if (array[j] > array[j + 1]) {
          int temp = array[j];
          array[j] = array[j + 1];
          array[j + 1] = temp;
        }
  }
  public static void main(String args[]) {
    int[] data = { -2, 45, 0, 11, -9 };
    BubbleSort bs = new BubbleSort();
    bs.bubbleSort(data);
    System.out.println("Sorted Array in Ascending Order:");
    System.out.println(Arrays.toString(data));
  }
}

优化的冒泡排序

在上面的代码，如果数组已经排序了，还是会继续进行比较，会增加执行时间。
代码可以通过变量swapped进行优化，当每次迭代之后，如果没有交换发生，那么就不需要进行接下来的迭代了。
在这种情况下，变量swapped设置为false，就可以终止接下来的迭代了。

优化冒泡算法

bubbleSort(array)
  swapped <- false
  for i <- 1 to indexOfLastUnsortedElement-1
    if leftElement > rightElement
      swap leftElement and rightElement
      swapped <- true
end bubbleSort

Java实现

// Optimized bubble sort in Java

import java.util.Arrays;

class BubbleSort {
  void bubbleSort(int array[]) {
    int size = array.length;
    for (int i = 0; i < size - 1; i++) {
      boolean swapped = true;
      for (int j = 0; j < size - i - 1; j++) {
        // To sort in descending order, change > to < in this line.
        if (array[j] > array[j + 1]) {
          int temp = array[j];
          array[j] = array[j + 1];
          array[j + 1] = temp;
          swapped = false;
        }
      }
      if (swapped == true)
        break;
    }
  }
  
  public static void main(String args[]) {
    int[] data = { -2, 45, 0, 11, -9 };
    BubbleSort bs = new BubbleSort();
    bs.bubbleSort(data);
    System.out.println("Sorted Array in Ascending Order:");
    System.out.println(Arrays.toString(data));
  }
}

复杂度

冒泡排序时最简单的排序之一，在算法中需要两个循环。

循环	对比数量
1st	(n-1)
2nd	(n-2)
3rd	(n-3)
…	…
last	1

对比数量：(n-1) + (n-2) + (n-3) + … + 1= n(n-1)/2 接近等于n^2
复杂度是：O(n^2)

也可以通过另一种方法看复杂度，因为有两个循环，所以复杂度是：O(n^2)

时间复杂度

最坏情况：O(n^2)
最好情况：O(n)
平均情况：O(n^2)

空间复杂度

普通的冒泡排序空间复杂度是O(1)，因为只有一个额外变量temp使用
优化冒泡排序空间复杂度是O(2)，因为有两个额外变量使用.