0
点赞
收藏
分享

微信扫一扫

芯片后端的APR是指什么?

登高且赋 2024-03-06 阅读 15

目录

1.直接插入排序

2.希尔排序

3.选择排序

4.冒泡排序

5.计数排序

6.排序总结


1.直接插入排序

(1)思想

所谓插入排序,就是将待排序数据插入到已经有序的数据中,为了使插入后数据依然有序,就要选中一个合理的位置进行插入。

图示展示思想:

第一步: 

第二步:比较,交换数据 

第二轮:

不断类推,直到有序(i走到非法位置)

(2)代码

代码需要完整,则要判断数组是否合法有数据等等,下面不做补充

public static void insertSort(int[] array) {
        if(array == null) {
            return;
        }
        if(array.length <= 1) {
            return;
        }
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i -1;
            for (; j >= 0; j--) {
                if(array[j] > tmp) {
                    array[j+1] = array[j];//元素后移
                }else {
                    break;
                }
            }
            array[j+1] = tmp;//放回元素
        }
    }

(3)总结

2.希尔排序

(1)思想

如何分组:定义一个变量gap,称为组距。也就是每间隔五个数据就有一个数据是这个组的。

 分组的间距从大到小,一开始,我们先赋值为数组的长度。下面代码的写法可以保证gap最后一次为1,完成最后的插入排序

public static void shellSort(int[] array) {
        int gap = array.length;
        while(gap > 1) {
            gap /= 2;
            shell(array,gap);//进行插入排序
        }

    }

分组后,在组内进行插入排序即可。

如何确定:无序数据和有序数据

得出插入排序部分代码:

 j每次移动的距离就是gap,保证在同组内移动。j循环结束代表一组的插入排序完成,进入下一轮(也就是下一组);

 private static void shell(int[] array,int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i -gap;
            for (;j >= 0;j-=gap) {
                if(array[j] > tmp) {
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

进入下一组:

(2)完整代码

 public static void shellSort(int[] array) {
        int gap = array.length;
        while(gap > 1) {
            gap /= 2;
            shell(array,gap);//进行插入排序
        }

    }
    private static void shell(int[] array,int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i -gap;
            for (;j >= 0;j-=gap) {
                if(array[j] > tmp) {
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

(3)总结

3.选择排序

(1)思想

定义变量:i、j

思路图:

根据上面的思路,可以得出下面的代码

(2)完整代码

 public static void selectSort(int[] array) {

        for (int i = 0; i < array.length-1; i++) {
            int minIndex = i;//记录当前下标
            int j = i+1;
            for(;j < array.length;j++) {
                if(array[j]<array[minIndex]) {
                    minIndex = j;//最小值下标更新
                }
            }
            swap(array,i,minIndex);
        }

    }
    public static void swap(int[] array,int i,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

思想和代码都比较简单,就不再做简述

(3)总结

4.冒泡排序

(1)思路

待排序数组:

int[] arr = {10,9,8,7,6,5,4,3,2,1};

第一轮冒泡: 

 第二轮冒泡:

后续同理

(2)完整代码

public static void  bubbleSort(int[] array) {

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

为了应对逆序的代码,可以做出以下优化

public static void  bubbleSort(int[] array) {

        for (int i = 0; i < array.length-1; i++) {
            boolean bool = true;
            for (int j = 0; j < array.length-i-1; j++) {
                if(array[j] > array[j+1]) {
                    bool = false;
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
            if(bool) {
                break;
            }
        }
    }

如果一轮比较下来,都没有发生交换,说明已经排好序了

(3)总结

5.计数排序

适用场景(局限性):数据基本趋于一个区间内,如:待排序数据的值都是处于0-10的范围内

(1)思路步骤

第一步:求这组数据的最大值和最小值。

第二步:创建一个计数数组,大小为这批数据的差值。

第三步:遍历原数组数组,将值作计数数组的下标,该位置++。

第四步:取出计数数组,存入原数组中

(2)完整代码

public static void countSort(int[] array) {
        //1.求最值
        int max = array[0];
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i] > max) {
                max = array[i];
            }
            if(array[i] < min) {
                min = array[i];
            }
        }
        //2.创建计数数组并初始化
        int[] count = new int[max-min+1];
        //3.遍历数组
        for (int i = 0; i < array.length; i++) {
            int index = array[i];
            count[index-min]++;
        }
        //4.取出计数数组
        int k = 0;
        for (int i = 0; i < count.length; i++) {
            int len = count[i];

           while (len != 0) {
               array[k] = i+min;
               k++;
               len--;
           }
        }
    }

(3)总结

6.排序总结

排序方法最好时间最坏时间空间稳定性
插入排序O(n)O(n^2)O(1)稳定
希尔排序O(n)O(n^2)O(1)不稳定
选择排序O(n^2)O(n^2)O(1)不稳定
堆排序O(n*logn)O(nlogn)O(1)不稳定
冒泡排序O(n)O(n^2)O(1)稳定
快速排序O(n*logn)O(n*logn)O(logn)-O(n)不稳定
归并排序O(n*logn)O(n*logn)O(n)稳定

举报

相关推荐

0 条评论