Java排序算法之交换排序

一、冒泡排序

1、算法思想：依次比较相邻的两个数，较小数放前面，较大数放后面，直到最大数放在最后， 然后重复操作，最后排序为升序。
第一层循环为重复的次数，循环次数为array.length-1
第二次循环为依次比较相邻的数，循环次数为array.length-1-i
2、原理图

3、Java代码实现

// 1、冒泡排序
    public static void puppleSort(int arr[]) {

        for (int i = 0; i < arr.length - 1; ++i) {

            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

//测试
public static void main(String[] args) {

    int arr[] = new int[] {1,3,6,9,7,2,8,5,4};
    puppleSort(arr);
    System.out.println(Arrays.toString(arr));
}

结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]

4、分析
冒泡排序的空间复杂度为O(1)，时间复杂度为O(n^2)，适用于序列初始状态基本有序（正序）的情况。

二、快速排序

1、算法思想：选择序列中一个元素作为基准元素base，维护两个指针front和back分别指向序列的首尾，首先用front指向的元素和base进行比较，如果大于base，则与back指向的元素进行交换，否则指针右移；然后比较back指向的元素是否小于base，返回为true则与front指向的元素进行交换，否则指针左移。前后交替这样就能保证较小数都放在base的左边，较大数在base的右边，然后递归调用对各部分继续排序，直到最后排好序。
2、原理图

3、Java代码实现

//找到最后基准元素的索引
public static int quickSort(int arr[], int front, int back) {
        //最后一个元素作为基准元素
        int base = arr[back];
        while (front < back) {

            for (; front < back; front++) {

                if (arr[front] > base) {
                    arr[back] = arr[front];
                    break;
                }

            }

            for (; front < back; back--) {

                if (arr[back] < base) {
                    arr[front] = arr[back];
                    break;
                }
            }
        }
        arr[back] = base;
        return back;

    }
//递归调用
public static void qSort(int arr[], int front, int back) {

    if (front < back) {

        int index = quickSort(arr, front, back);
        qSort(arr, front, index - 1);
        qSort(arr, index + 1, back);

    }
}

public static void main(String[] args) {

    int arr[] = new int[] {1,3,6,9,7,2,8,5,4};
    qSort(arr, 0, arr.length - 1);
    System.out.println(Arrays.toString(arr));
}

结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]

4、分析
快速排序算法空间复杂度为O(nlogn)，时间复杂度为O(nlogn)。
快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。
但该算法可能会在结束时改变几个相同元素的相对位置，所以是不稳定的.