交换排序

冒泡排序

对数列进行重复的比较，每次比较相邻的两个元素，直至没有元素需要交换

实现代码

public class BubbleSort
{
    public static void main(String[] args)
    {
        DataWrap[] dataWraps =
        { new DataWrap(21, ""), new DataWrap(30, ""), new DataWrap(49, ""),
                new DataWrap(30, "*"), new DataWrap(23, ""),
                new DataWrap(21, "*"), new DataWrap(16, ""),
                new DataWrap(9, "") };
        System.out.println("排序之前：\n" + Arrays.toString(dataWraps));
        bubbleSort(dataWraps);
        System.out.println("排序之后：\n" + Arrays.toString(dataWraps));
    }

    public static void bubbleSort(DataWrap[] dataWraps)
    {
        System.out.println("开始排序。。。");
        int arrayLength = dataWraps.length;
        for (int i = 0; i < arrayLength - 1; i++)
        {
            boolean flag = false;
            for (int j = 0; j < arrayLength - 1 - i; j++)
            {
                if (dataWraps[j].compareTo(dataWraps[j + 1]) > 0)
                {
                    DataWrap tmp = dataWraps[j];
                    dataWraps[j] = dataWraps[j + 1];
                    dataWraps[j + 1] = tmp;
                    flag = true;
                }
            }
            System.out.println(Arrays.toString(dataWraps));
            if (!flag)
            {
                break;
            }
        }
    }
}

其时间复杂度是不稳定的：
最好的状态：O(n);最差的状态：O($n^2$)
空间复杂度：O(1)

快速排序

这是一种速度非常快的交换排序方法
从待排序的数据中任取一个数据做为分界值，所有小于它的放在左侧，大于它的放在右侧
对左右两个子序列递归以上操作

实现代码

public class QuickSort
{
    public static void main(String[] args)
    {
        DataWrap[] dataWraps =
        { new DataWrap(9, ""), new DataWrap(-16, ""), new DataWrap(21, "*"),
                new DataWrap(23, ""), new DataWrap(-30, "*"),
                new DataWrap(-49, "*"), new DataWrap(21, ""),
                new DataWrap(30, "*"), new DataWrap(13, "*") };
        System.out.println("排序之前：\n" + Arrays.toString(dataWraps));
        quickSort(dataWraps);
        System.out.println("排序之后：\n" + Arrays.toString(dataWraps));
    }

    // 使小于分界值的放在左边，大于分界值的放在右边
    public static void subSort(DataWrap[] dataWraps, int start, int end)
    {
        // 区间存在，需要排序
        if (start < end)
        {
            // 第一个元素作为分界值
            DataWrap base = dataWraps[start];
            // i从左边开始搜索，搜索大于分界值的元素
            int i = start;
            // j从右边开始搜索，搜索大于分界值的元素
            int j = end + 1;
            while (true)
            {
                // 找到大于分界值的索引，或者已到达end处
                while (i < end && dataWraps[++i].compareTo(base) <= 0)
                    ;
                // 找到小于分界值的索引，或者已到达start处
                while (j > start && dataWraps[--j].compareTo(base) >= 0)
                    ;
                if (i < j)
                {
                    swap(dataWraps, i, j);
                    System.out.println(Arrays.toString(dataWraps));
                } else
                {
                    break;
                }
            }
            swap(dataWraps, start, j);
            System.out.println(Arrays.toString(dataWraps));
            System.out.println("j:" + j);
            // 递归左子序列
            subSort(dataWraps, start, j - 1);
            // 递归右子序列
            subSort(dataWraps, j + 1, end);
        }
    }

    public static void quickSort(DataWrap[] dataWraps)
    {
        subSort(dataWraps, 0, dataWraps.length - 1);
    }

    // 交换两个索引处元素位置
    private static void swap(DataWrap[] dataWraps, int i, int j)
    {
        DataWrap tmp = dataWraps[i];
        dataWraps[i] = dataWraps[j];
        dataWraps[j] = tmp;
    }
}

快速排序的时间效率很好，因为它每次能确定的元素呈指数增长。
平均时间复杂度：O($n\log_2n$)
快速排序使用递归，而递归使用栈，因此空间复杂度为O($\log_2n$)