三种排序算法代码与优缺点介绍（插入排序，冒泡排序，快速排序）

冒泡排序

public void qipao() {
        int nums[] = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
        int temp = 0;
        for (int i = nums.length - 1; i >= 0; i--)
            for (int j = 0; j < i; j++) {
                if (nums[j] > nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        for (int i = 0;i< nums.length;i++){
            System.out.print(nums[i]+",");
        }
    }

将数列的相邻的两个数进行比较如果前一个数大则将两个数交换位置，将数列中最大的数置于最后。
冒泡排序：最好的情况是数据本来就有序，复杂度为O(n)；最差的情况是O(N^2),稳定算法。

插入排序

public void charu() {
        int arr[] = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        int tmp;
        int i;
        int j;
        for (i = 1; i < arr.length; i++) {
            tmp = arr[i];
            for (j = i - 1; j >= 0 && arr[j] > tmp; j--) {
                arr[j + 1] = arr[j];
            }
            arr[j + 1] = tmp;
        }
        for (int k = 0;k<arr.length;k++){
            System.out.print(arr[k]+",");
        }

    }

插入排序：最好的情况是数据本来就有序，复杂度为O(n)；最差的情况是O(N^2),稳定算法

快速排序

import org.junit.Test;

public class erfenPaixu {
    /**
     * 首先调用哨兵方法之后在使用递归的方法循环将基准左边部分和右边部分排序
     * ，直到达到递归出口l = r为止。
     * @param nums
     * @param l
     * @param r
     */
    void erfen(int[] nums, int l, int r) {
        if (l >= r) return;
        int i = shaobing(nums, l, r);
        erfen(nums, l, i - 1);
        erfen(nums, i + 1, r);
    }

    /**
     * 利用哨兵划分将数组根据基准分为两半
     *
     * @param nums
     * @param l 初始状态左边的索引
     * @param r 初始状态右边的索引
     * @return 返回一个i的边界值
     */
    int shaobing(int[] nums, int l, int r) {
        //i 为 l的初始状态，j 为 r的初始状态
        int i = l;
        int j = r;
        while (i < j) {
            //i从左往右找大于基准的第一个数，j从右往左找小于基准的第一个数，把他俩交换
            //继续从当前位置的i，j继续循环查找，直到 i = j 将 i = j 所在位置与基准交换
            while (i < j && nums[j] >= nums[l]) j--;
            while (i < j && nums[i] <= nums[l]) i++;
            swap(nums, i, j);
        }
        swap(nums, i, l);
        return i;
    }

    /**
     * 交换数组中的元素
     *
     * @param nums 数组
     * @param i
     * @param j
     */
    public void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

    @Test
    public void test() {
        int nums[] = {8, 2, 11, 9, 1, 5, 3};
        erfen(nums, 0, nums.length - 1);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + ",");
        }
    }
}

快速排序：最好的情况复杂度为NlogN,最差的情况是O(N^2),快速排序将不幸退化为冒泡排序;不稳定算法

冒泡排序：
1. 冒泡排序是一种用时间换空间的排序方法
2. 最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序， 最差时间复杂度O(N^2)只是表示其操作次数的数量级
3. 最好的情况是数据本来就有序，复杂度为O(n)
快速排序：
1. n大时好，快速排序比较占用内存，内存随n的增大而增大，但却是效率高不稳定的排序算法。
2. 划分之后一边是一个，一边是n-1个，
这种极端情况的时间复杂度就是O(N^2)
3. 最好的情况是每次都能均匀的划分序列，O(N*log2N)

感谢您的阅读，如果本篇文章对您有帮助，欢迎点赞，关注，您的阅读是我莫大的鼓励！