经典排序算法详解-优快云博客

快速排序(是种不稳定的排序,因为会打乱原有的排序)

直接引用百科的话,其思想是

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1； [1]
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]； [1]
3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换； [1]
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换； [1]
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）

但百科的话貌似不严谨,不一定歹大于或小于的时候才移动,等于的时候也要进行指针的移动,否则会造成数组中有相同值时,程序陷入死循环
代码

@Test
    public void method1() {
        int[] ints = {5, 3, 7, 6, 4, 1, 0, 2, 9, 10, 8};
        dfs(0, ints.length - 1, ints);
        for (int anInt : ints) {
            System.out.print(anInt + "   ");
        }
    }


    public static void dfs(int i, int j, int[] ints) {
        if (i >= j) return;
        int orgini = i, orginj = j;
        int key = ints[i];
        while (i != j) {
            //小的左移
            while (ints[j] >= key && i != j) j--;
            exchange(i, j, ints);
            //大的右移
            while (ints[i] <= key && i != j) i++;
            exchange(i, j, ints);
        }
        dfs(orgini, i - 1, ints);
        dfs(i + 1, orginj, ints);
    }


    //交换
    public static void exchange(int i, int j, int ints[]) {
        int c = ints[j];
        ints[j] = ints[i];
        ints[i] = c;
    }

插入排序

在这里插入图片描述
就跟打扑克一样

代码实现
这里踩啦一个坑添加链接描述

  @Test
    public void method2() {
        int[] arr = {5, 3, 7, 10, 4, 10, 0, 2, 9, 8};
        for (int i = 1; i <= arr.length - 1; i++) {
            int j = i - 1, tar = arr[i];
            while (j >= 0 && arr[j] > tar) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j+1]=tar;
        }
        for (int anInt : arr) {
            System.out.print(anInt + " ");
        }
    }

冒泡排序

就是给定一个arr[]数组,从头到尾遍历length遍,挨着的两个值若值不一样,就交换顺序
代码实现

 @Test
    public void method2() {
        int[] arr = {5, 3, 7, 10, 4, 10, 0, 2, 9, 10, 8};
        for (int i = 0; i < arr.length; i++) {
            for (int i1 = 0; i1 < arr.length - 1; i1++) {
                if (arr[i1] > arr[i1 + 1]) exchange(i1, i1 + 1, arr);
            }
        }
        for (int anInt : arr) {
            System.out.print(anInt + " ");
        }
    }

  //交换
    public static void exchange(int i, int j, int ints[]) {
        int c = ints[j];
        ints[j] = ints[i];
        ints[i] = c;
    }

选择排序

就是重复遍历,找出最大的值然后跟末尾元素互换位置
代码实现

@Test
    public void method2() {
        int[] arr = {5, 3, 7, 10, 4, 10, 0, 2, 9, 10, 8};
        for (int i = 0; i <arr.length-1; i++) {
            int max = arr[0], maxindex = 0;
            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > max) {
                    max = arr[j];
                    maxindex = j;
                }
            }
            exchange(maxindex, arr.length - i-1, arr);
        }
        for (int anInt : arr) {
            System.out.print(anInt + " ");
        }
    }

  //交换
    public static void exchange(int i, int j, int ints[]) {
        int c = ints[j];
        ints[j] = ints[i];
        ints[i] = c;
    }

堆排序

基本思想：

1.首先将待排序的数组构造成一个大根堆，此时，整个数组的最大值就是堆结构的顶端

2.将顶端的数与末尾的数交换，此时，末尾的数为最大值，剩余待排序数组个数为n-1

3.将剩余的n-1个数再构造成大根堆，再将顶端数与n-1位置的数交换，如此反复执行，便能得到有序数组
代码实现:

 @Test
    public void method2() {
        int[] arr = {5, 3, 13, 10, 4, 10, 0, 2, 9, 8};
        for (int i = arr.length - 1; i >= 0; i--) {
            changeOrderByindex(i, arr);
        }

        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
    
    //交换一个结点的顺序
    //此函数功能是通过传入索引,能得到此索引前边(不包括索引后边的)堆的最大值,并将交换位置
    public static void changeOrderByindex(int lastindex, int[] arr) {
        int rootIndex = (lastindex - 1) / 2;
        for (int i = rootIndex; i >= 0; i--) {
            int leftIndex = i * 2 + 1;
            int rightIndex = i * 2 + 2;
            //比较交换的前提是,没有超出lastindex的范围
              //就比如   	2
                         4    6
            		   5   10
            	//传入的lastindex是3,只会返回索引为3的位置即5往上的二叉树的最大值(6,不会返回10)
            	                         //限制条件
            if (leftIndex < arr.length && leftIndex <= lastindex) {
                if (arr[leftIndex] > arr[i]) exchange(leftIndex, i, arr);
            }
            if (rightIndex < arr.length && rightIndex <= lastindex) {
                if (arr[rightIndex] > arr[i]) exchange(rightIndex, i, arr);
            }
        }
        exchange(0, lastindex, arr);
    }


    //交换顺序
    public static void exchange(int i, int j, int ints[]) {
        int c = ints[j];
        ints[j] = ints[i];
        ints[i] = c;
    }