标签：第一个 时间复杂度 array 比较 lse 中心 -- 工作 通过
原理：把相邻的元素两两比较，根据大小来交换元素的位置。
原始的冒泡排序是稳定排序。由于该排序的每一轮要遍历所以元素，轮转的次数和元素数量相当，所以时间复杂度是 O(N^2)。
java代码表达如下：
import java.util.Arrays;
public class BubbleSort{
private static void sort(int array[]){
int tmp = 0;
for (int i = 0; i < array.length; i++){
for (int j = 0; j < array.length - i - 1;j++) {
if (array[j] > array[j+1]) {
tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
}
}
}
}
public static void main(String[] args){
int[] array = new int[]{5,8,6,3,9,2,1,7};
sort(array);
System.out.println(Arrays.toString(array));
}
}（使用双循环来进行排序。外部循环控制所有的回合，内部循环代表每一轮的冒泡处理，先进行元素比较，再进行元素交换。）
冒泡优化（一）
判断出数列已经有序，并且做出标记，剩下的几轮排序就可以不必执行，提早结束工作。
代码如下：
import java.util.Arrays;
public class BubbleSort{
private static void sort(int arrray[]){
int tmp = 0;
for (int i = 0; i < arrray.length; i++) {
//有序标记，每一轮的初始是true
boolean isSorted = true;
for (int j = 0; j < arrray.length - i - 1; j++ ) {
if(arrray[j] > arrray[j+1]) {
tmp = arrray[j];
arrray[j] = arrray[j+1];
arrray[j+1] = tmp;
//有元素交换，所以不是有序，标记变为false
isSorted = false;
}
}
if(isSorted){
break;
}
}
}
public static void main(String[] args){
int[] arrray = new int[]{5,8,6,3,9,2,1,7};
sort(arrray);
System.out.println(Arrays.toString(arrray));
}
}利用布尔变量 isSorted作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，说明数列已然有序，直接跳出大循环。
冒泡优化（二）
如果元素排序前面无序，后面无序，我们可以设定排序边界，这样当遍历到有序数组时，跳出循环，结束程序。
思路：我们在每一轮排序的最后，记录下最后一次元素交换的位置，那个位置也就是无序数列的边界，再往后就是有序区了。
代码如下：
import java.util.Arrays;
public class BubbleSort {
private static void sort(int array[]) {
int tmp = 0;
// 记录最后一次交换的位置
int lastExchangeIndex = 0;
// 无序数列的边界，每次比较只需要比到这里为止
int sortBorder = array.length - 1;
for (int i = 0; i < array.length; i++) {
// 有序标记，每一轮的初始是true
boolean isSorted = true;
for (int j = 0; j < sortBorder; j++) {
if (array[j] > array[j+1]) {
tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
// 有元素交换，所以不是有序，标记为false
isSorted = false;
// 把无序数列的边界更新为最后一次交换元素的位置
lastExchangeIndex = j;
}
}
sortBorder = lastExchangeIndex;
if (isSorted) {
break;
}
}
}
public static void main(String[] args) {
int[] array = new int[]{3,4,2,1,5,6,7,8};
sort(array);
System.out.println(Arrays.toString(array));
}
}sortBorder 就是无序数列的边界。每一轮排序过程中，sortBorder 之后的元素就完全不需要比较了，肯定是有序的。
快速排序跟冒泡排序一样，都属于交换类排序，通过采用不断的比较和移动元素来实现排序。
快速排序利用了 ”分治法“ 的思想， 通过设置基准数 key ，将比基准数大的数从前面移动到后面，比基准数小的数从后面移动到前面，将数组分为两部分，其中以 key 为中心， key 左边的数比 key 小，key 右边的数比 key 大，然后对这两部分分别重复这个排序的过程，直到整个有序。
由于采取 ”分治法“ ，我们可以很容易的得出快速排序的平均时间复杂度为：O(nlogn) 。
快速排序的简单实现：
import java.util.Arrays;
public class QuickSort {
private static void quickSort(int[] a, int low, int high) {
//1.找到递归算法的出口
if (low > high) {
return;
}
//2. 存
int i = low;
int j = high;
//3. key
int key = a[low];
//4,完成一趟排序
while(i < j) {
//4.1 从右往左找到第一个小于key的数
while(i<j && a[j] > key){
j--;
}
//4.2 从左往右找到第一个大于key的数
while (i<j && a[i] <= key) {
i++;
}
//4.3 交换
if(i < j){
int p = a[i];
a[i] = a[j];
a[j] = p;
}
}
//4.4 调整key的位置
int p = a[i];
a[i] = a[low];
a[low] = p;
//5. 对key左边的数快排
quickSort(a, low, i - 1);
//6. 对key右边的数快排
quickSort(a, i + 1, high);
}
public static void quickSort(int[] a){
if (a.length>0) {
quickSort(a, 0, a.length - 1);
}
}
public static void main(String[] args) {
int[] a = {1,2,4,5,7,4,5,3,9,0};
quickSort(a);
System.out.println(Arrays.toString(a));
}
}标签：第一个 时间复杂度 array 比较 lse 中心 -- 工作 通过
原文地址：https://www.cnblogs.com/weixuqin/p/10123641.html
