排序算法学习笔记

最新推荐文章于 2022-04-21 22:46:57 发布

怕我上不了岸，一辈子摇晃

最新推荐文章于 2022-04-21 22:46:57 发布

阅读量657

点赞数 1

分类专栏：学习笔记文章标签：排序算法学习算法

本文链接：https://blog.csdn.net/LXY_YXL_JAY/article/details/122744233

版权

学习笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

排序算法

排序算法的分类

内部排序:
指将需要处理的所有数据都加载到内部存储器(内存)中进行排序。
外部排序法：
数据量过大，无法全部加载到内存中，需要借助外部存储(文件等)进行排序。
3.常见的排序算法分类

1.冒泡排序

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = new int[10];
        for (int i = 0; i < 10; i++) {
            a[i] = (int) (Math.random() * 100);
        }
        System.out.println("排序前：" + Arrays.toString(a));
        //冒泡排序
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {//完成几次外层循环，最后就几位有序，故内存循环要减去外层循环的次数                
            if (a[j] > a[j + 1]) {//利用中间值temp交换
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        System.out.println("排序后：" + Arrays.toString(a));
    }
}

2.选择排序

基本思想：从全部数中选出最小（大）值，与第一位交换，继续从剩余数选出最小(大)值，与第二位交换····以此类推，直到n-1位。
思路分析图：
在这里插入图片描述

public class SelectSort {
    public static void main(String[] args) {
        int[] a = new int[10];
        for (int i = 0; i < 10; i++) {
            a[i] = (int) (Math.random() * 100);
        }
        System.out.println("排序前：" + Arrays.toString(a));
        for (int i = 0; i < a.length - 1; i++) {//选择次数n-1
            int min = a[i];//假定该数最小
            int minIndex = i;
            for (int j = i + 1; j < a.length; j++) {//找出最小数及其下标
                if (min > a[j]) {
                    min = a[j];
                    minIndex = j;
                }
            }
            if (minIndex != i) {//交换
                a[minIndex] = a[i];
                a[i] = min;
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

3.插入排序

基本思想是：假设将数组分成两部分：有序部分和无序部分，最开始有序部分只有第一位数字，其余为无序部分数字。从无序部分中拿出第一位数字与有序表数字比较，若拿出数字较小，则与之比较的数字后移，直至拿出的数大于比较的数，则放在它的后一位上。以此类推直到全部放入有序表

public class InsertSort {
    public static void main(String[] args) {
        int[] a=new int[10];
        for(int i=0;i<10;i++){
            a[i]=(int)(Math.random()*100);
        }
        System.out.println(Arrays.toString(a));
        System.out.println("=======");
        insertSort(a);
        System.out.println(Arrays.toString(a));

    }

    public static void insertSort(int[] arr){
       for(int i=1;i<arr.length;i++){//从第二位开始，循环n-1次，记录插入数字的值和前一位的下标
           int insertVal=arr[i];
           int insertIndex=i-1;
           while(insertIndex>=0 && insertVal<arr[insertIndex]){//保证不越界，插入值与前一位比较
               arr[insertIndex+1]=arr[insertIndex];//比较值后移
               insertIndex--;
           }
           arr[insertIndex+1]=insertVal;//找到并插入
       }
        System.out.println(Arrays.toString(arr));
    }

4.希尔排序

我们看简单的插入排序可能存在的问题.
数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是：
{2,3,4,5,6,6}
{2,3,4,5,5,6}
{2,3,4,4,5,6}
{2,3,3,4,5,6}
{2,2,3,4,5,6}
{1,2,3,4,5,6}
结论: 当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响.

希尔排序法基本思想
希尔排序是把记录按下标的一定增量进行分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1 时，整个文件恰被分成一组，算法便终止

public class ShellSort {
    public static void main(String[] args) {
        int[] a=new int[10];
        for(int i=0;i<10;i++){
            a[i]=(int)(Math.random()*100);
        }
//        int[] a={5,2,4,3,1,6,55,8} ;
        System.out.println(Arrays.toString(a));
        ShellSort(a);
    }

    public static void ShellSort(int[] arr){
        for(int gap=arr.length/2;gap>0;gap/=2){//分组，组数为gap，增量也为gap，直至增量（组数）为一
            for(int i=gap;i<arr.length;i++){
                for(int j=i-gap;j>=0;j-=gap){
                    if(arr[j]>arr[j+gap]){
                        int temp=arr[j];
                        arr[j]=arr[j+gap];
                        arr[j+gap]=temp;
                    }
                }
            }
        } 
        System.out.println(Arrays.toString(arr));
    }
}

5.快速排序

public class QuickSort {
    public static void main(String[] args) {
        int[] a = new int[10];
        for (int i = 0; i < a.length; i++) {
            a[i] = (int) (Math.random() * 100);
        }
//        int[] a = {3, 1, 7, 1, -2, -3, 4};
        System.out.println("排序前：" + Arrays.toString(a));
        quickSort(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));
    }

    //快排代码
    public static void quickSort(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        int pivot = arr[(left + right) / 2];
        int temp = 0;

        while (l < r) {
            while (arr[l] < pivot) {
                l++;
            }
            while (arr[r] > pivot) {
                r--;
            }
            if (l >= r) {
                break;
            }
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            if (arr[l] == pivot) {
                r--;
            }
            if (arr[r] == pivot) {
                l++;
            }
        }
        if (l == r) {
            l++;
            r--;
        }
        if (right > l) {

            quickSort(arr, l, right);
        }
        if (left < r) {
            quickSort(arr, left, r);
        }

    }
}

6.归并排序

public class MergeSort {
    public static void main(String[] args) {
        int[] a=new int[10];
        for(int i=0;i<a.length;i++){
            a[i]=(int)(Math.random()*100);
        }
//        int[] a={8,4,5,7,1,3,6,2};
        System.out.println("排序前：" + Arrays.toString(a));
        int temp[]=new int[a.length];
        mergeSort(a,0,a.length-1,temp);
        System.out.println("排序后：" + Arrays.toString(a));
    }

    public static void mergeSort(int[] arr,int left,int right,int[] temp){
    if(left<right){
        int mid=(left+right)/2;
        mergeSort(arr,left,mid,temp);
        mergeSort(arr,mid+1,right,temp);
        merge(arr,left,mid,right,temp);
        }
    }

    public  static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i=left;
        int j=mid+1;
        int t=0;

        while(i<=mid &&j<=right){
            if(arr[i]<=arr[j]){
                temp[t]=arr[i];
                i++;
                t++;
            }else{
                temp[t]=arr[j];
                t++;
                j++;
            }
        }
        while(i<=mid){
            temp[t]=arr[i];
            t++;
            i++;
        }
        while(j<=right){
            temp[t]=arr[j];
            j++;
            t++;
        }
        t=0;
        int tempIndex=left;//不是0
        while(tempIndex<=right){
            arr[tempIndex]=temp[t];
            t++;
            tempIndex++;
        }
     }
    }

7.基数排序

public class RadixSort {
    public static void main(String[] args) {
        int[] a=new int[10];
        for(int i=0;i<a.length;i++){
            a[i]=(int)(Math.random()*100);
        }
//        int[] a={8,4,5,7,1,3,6,2};
        System.out.println("排序前：" + Arrays.toString(a));
        radixSort(a);

        System.out.println("排序后：" + Arrays.toString(a));
    }

    public static  void radixSort(int[] arr){
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
        }
        int maxLength=(max+"").length();

        int bucket[][]=new int[10][arr.length];//10个桶，每个桶又是一个一维数组
        int[] bucketOfEleNums= new int[10];//记录10个桶装的对应数目，例如bucketOfEleNums[0]=3表示第一个桶装了三个


        for(int i=0,n=1;i<maxLength;i++,n*=10){//放入桶
            for(int j=0;j<arr.length;j++){
                int bucketNum=arr[j]/n%10;
                bucket[bucketNum][bucketOfEleNums[bucketNum]]=arr[j];
                bucketOfEleNums[bucketNum]++;//对应的桶所装的数量增加
            }

            int index=0;
            for(int k=0;k<bucketOfEleNums.length;k++){//取出
                if(bucketOfEleNums[k]!=0){
                    for(int l=0;l<bucketOfEleNums[k];l++){
                        arr[index++]=bucket[k][l];
                    }

                }
                bucketOfEleNums[k]=0;
            }

        }
    }

8.堆排序

public class HeapSort {
    public static void main(String[] args) {
    int arr[]={4,6,8,5,9,11,14,3,1};
    heapSort(arr);
    System.out.println(Arrays.toString(arr));

    }

    //堆排序的方法
    public static void heapSort(int[] arr) {
        int temp=0;
        System.out.println("堆排序");
        for(int i=arr.length/2-1;i>=0;i--){//构成大顶堆
            adjustHeap(arr,i,arr.length);
        }
        for(int j=arr.length-1;j>0;j--){
            temp=arr[j];
            arr[j]=arr[0];
            arr[0]=temp;//最大的已经放到最后
            adjustHeap(arr,0,j);//调整剩余的重新满足大顶推结构，已经调整的最后一个不再参与重新调整成大顶堆结果（每调整一个j--）
        }

    }

    //数组（二叉树）调节成大顶堆

    //方法注释快捷键" /** + enter "
    /**
     *
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustHeap(int[] arr, int i, int length) {
        int temp = arr[i];
        for (int k = 2 * i + 1; k < length; k = k * 2 + 1) {//从最后一个非叶子节点开始
            if (k + 1 < length && arr[k] < arr[k + 1]) {//获取该非叶子节点的较大子节点
                k++;
            }
            if (arr[k] > temp) {//较大子节点大于自身，则将该较大子节点赋予该节点，同时下标i转成下标k
                arr[i] = arr[k];
                i = k;//作用？？
            } else {
                break;
            }
        }
        arr[i]=temp;
    }

}

怕我上不了岸，一辈子摇晃

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
排序算法学习笔记

排序算法排序算法的分类`在这里插入代码片`冒泡排序选择排序如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入排序算法的分类在这里插入代码片内部排序:指将需要处理的所有数据都加载到内部存储器(内存)中进行排序。外部排序法：数据量过大，无法全部加载到内存中，需要借助外部存储(文件等)进行排序。3.
复制链接

扫一扫