算法排序

1、冒泡排序

int a = [5,2,9,3,1,7,6,8];
// 一共循环多少轮
for(int i = 0; i < a.length - 1; i++){
    // 每一轮中做替换
    for (int j = 0; j < a.length - 1 - i; j++) {
         int next = j+1;
         if (a[j] > a[next]) {
            int temp = a[next];
            a[next] = a[j];
            a[j] = temp;
         }
    }
}

这是个升序的排序方法，过程如下：

1、第一位的5和第二位的2比，5大于2所以把小数2放到第一位，大数5放到第二位；

2、第二位的5和第三位的9比，5小于9所以不动；

3、第三位的9和第四位3的比，9大于3所以把小数3放到第三位，大数9放到第四位；

..........

以此类推，最终把9放到最后一位，然后再进行第二轮比较，注意这时最大的9已经到达最后一位，所以只需要对比前面的7位即可，代码中j < j < a.length - 1 - i; 

2、选择排序

int a = [2,6,7,1,9,8,3];
int findMaxPos(arr, n){
    int max = arr[0], pos = 0;
    for (int i = 0; i < n; i++) {
        if (max < arr[i]) {
            max = arr[i];
            pos = i;
        }
    }

    return pos;
}

int i = a.length;
while(i > 0){
    int maxPos = findMaxPos(a, i);
    int temp = a[maxPos];
    a[maxPos] = a[i - 1];
    a[i - 1] = temp;
    i--;
}

过程如下：

数组长度7位，一共循环7轮，每一轮找出最大的数与数组最后一位进行替换，以此类推直到替换完全部。

3、快速排序

  public static void quickSort(int arr[], int start, int end) {

        int l = start,h = end;
        int pivot = arr[start];
        while (l < h) {
            // 从右边寻找到第一个小于povit的数
            while (l < h && arr[h] >= pivot){
                h--;
            }

            // 找到后替换到左边的第一个
            if (l < h) {
                arr[l] = arr[h];
                l++;
            }

            // 从左边寻找到第一个大约povit的数
            while (l < h && arr[l] <= pivot){
                l++;
            }
            //找到后替换到右边第一个找到的位置
            if (l < h) {
                arr[h] = arr[l];
                h--;
            }
        }

        // 最后这个l放入pivot
        arr[l] = pivot;

        if (l - 1 > start) {
            quickSort(arr, start, l - 1);
        }
        if (h + 1 < end) {
            quickSort(arr, h + 1, end);
        }


    }

过程如下：

1、拿数组第一个当做pivot（基准值），然后两个指针创建两个指针l和h；

2、l指向数组左边，h指向数组右边；

3、h向左滑动，如果小于pivot（基准值）那么就放到左边第l个，l向右移一个，h此时不动（右边的已经都大于pivot了）。

4、l向右滑动，如果大于pivot那么就把这个数放到右边的h处。

5、这样就完成了一次替换，把右边小于pivot的放到了左边，并且把左边大于pivot的放到了右边。

然后重复3-5的过程直到l == h的时候表明 l==h == n，n这个位置的左边已经全部小于pivot，右边全部大于pivot，此时n这个位置的值已经放到左边或者右边了，最后再把pivot放到n这个位置就完成了第一轮排序。

6、然后递归按照1-5的步骤分别排列n左边和右边。

这个算法跟冒泡算法比起来在n个循环中，每次都少一半的对比所以是O(n * logn)的时间复杂度