基础排序算法

最新推荐文章于 2024-07-23 17:36:37 发布
最新推荐文章于 2024-07-23 17:36:37 发布
阅读量160 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 算法 排序算法 插入排序 合并排序 快速排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Darlight/article/details/119912828
版权

一 递归,回溯

1.递归定义

  • 程序调用自身的编程技巧称为递归.
  • 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

2.递归的使用条件

  • 子问题须与原始问题为同样的事，且更为简单；
  • 递归要有边界条件、递归前进段和递归返回段。
  • 当边界条件不满足时，递归前进；
  • 当边界条件满足时，递归返回。

3.经典案例

  1. 斐波那契数列
    从第三个数开始 就等于前面两个数相加；
    例如:1 ,1 ,2, 3, 5, 8, 13
    可以得出逻辑公式:
    f(n) = f(n-1)+f(n-2);
    终止条件:
    f(1) = 1 ;f(2) = 1;
  2. 电商分销系统
    例如:B是A的下线，C是B的下线，那么在分钱返利的时候A可以分B，C的钱，如果要计算出A的钱就要分别找B,C的最后上级,然后才能分级计算

4.递归优化

  • 使用非递归。所有的递归代码理论上是一定可以转换成非递归的。
  • 加入缓存：把我们中间的运算结果保存起来，这样就可以把递归降至为o(n)
  • 尾递归：什么是尾递归？尾递归就是调用函数一定出现在末尾，没有任何其他的操作了。因为我们编译器在编译代码时，如果发现函数末尾已经没有操作了，这时候就不会创建新的栈，而且覆盖到前面去。倒着算，不需要在回溯了，因为我们每次会把中间结果带下去。

5.代码及分析

  1. 斐波那契数列
    • 递归代码
public class MyFibonacci {
           public static long fab(int n) {
               if (n <= 2) {
                   return 1;
               }else {
                   return fab(n - 1) + fab(n - 2);
               }
           }
       
           public static void main(String[] args) {
       //        1 1 2 3 5 8 13 21
               long l = System.currentTimeMillis();
               int n = 50;
               long fab = fab(n);
               System.out.println("第" + n + "个数为:" + fab);
               System.out.println("用时:" + (System.currentTimeMillis() - l) + "毫秒");
               /**
                * 第50个数为:12586269025
                * 用时:28497毫秒
                */
           }
       }
  • 时间复杂度和空间复杂度分析
    • 简单递归解决斐波那契问题的时间复杂度和空间复杂度非常高,每新增一个点,就会多出两个分支进行重复计算,可以看到,当计算第50个数的时候已经用时超过28s,如果计算更大的数时间将更长,如果程序中使用此代码将会导致程序阻塞
  • 优化:尾递归
    那么如何去优化这个代码呢
    从上面的图中可以看到,高时间复杂度和空间复杂度是因为重复计算导致,如果我们把计算结果记录下来,并且递归的时候进行传递呢,可以试验一下
             /**
              *
              * @param n 第几个数
              * @param pre 上一个计算的结果
              * @param res 当前节点的计算结果
              * @return
              */
             public static long tailFab(int n ,long pre,long res) {
                 if (n <= 2) {
                     return res;
                 }else {
         //            这个相当于倒着计算,知道第一个第二个点的数据,依次往后累加
         //           下一个点的res就相当于当前点pre+res,下一个点的pre就相当于当前点的res
                     return tailFab(n - 1, res,pre + res);
                 }
             }
             public static void main(String[] args) {
         //        1 1 2 3 5 8 13 21
                 long l = System.currentTimeMillis();
                 int n = 50;
         //        倒着计算,从2开始,所以pre和res都是1
                 long fab = tailFab(n,1,1);
                 System.out.println("第" + n + "个数为:" + fab);
                 System.out.println("用时:" + (System.currentTimeMillis() - l) + "毫秒");
                 /**
                  * 第50个数为:12586269025
                  * 用时:1毫秒
                  */
             }

可以看到,计算50个数,时间缩短到1毫秒.尾递归的巧妙之处在于从尾开始,倒着计算,传递已经计算好的值,减少了回溯过程,时间复杂度和空间复杂度降低到o(n)

二.排序算法

1.概述

  • 常见的排序算法及特点
    • 快速排序
      • 时间复杂度: O (nlogn)
      • 是否稳定:不稳定
    • 插入排序
      • 时间复杂度: O(n^2)
      • 是否稳定:稳定
    • 冒泡排序
      • 时间复杂度: O(n²)
      • 是否稳定:稳定
    • 希尔排序
      • 时间复杂度: O(n^2)
      • 是否稳定:不稳定
    • 二分排序
      • 时间复杂度: O(logn)
      • 是否稳定:稳定
    • 归并排序
      • 时间复杂度: O(nlogn)
      • 是否稳定:稳定
    • 选择排序
      • 时间复杂度: O(n^2)
      • 是否稳定:不稳定

2.插入排序

  • 实现步骤
    1.将数组分成已排序段和未排序段。初始化时已排序端只有一个元素
    2.到未排序段取元素插入到已排序段，并保证插入后仍然有序
    3.重复执行上述操作，直到未排序段元素全部加完。
  • 代码
   package algorithm.sort;
    
    /**
     * @author darlight
     * @date 2021/8/24 10:40
     * @blame ue189 Team
     */
    public class InsertSort {
        public static void sort(int[] value) {
    
            for (int i = 1; i < value.length; i++) {
                int data = value[i];
                for (int j = i - 1; j >= 0; j--) {
    //                如果这个数比当前数大,当前数就前移
                    if (value[j] > data) {
                        value[j + 1] = value[j];
                        value[j] = data;
                    } else {
    //                 直到找到比当前数小的数,就不需要移动
                        break;
                    }
                }
            }
        }
    
        public static void main(String[] args) {
            int[] a = {9, 5, 6, 3, 1, 2, 8, 7};
            sort(a);
            for (int i = 0; i < a.length; i++) {
                System.out.print(a[i]+" ");
            }
        }
    }

代码中可以看到,插入排序的时间复杂度是比较高的,嵌套循环,时间复杂度为O(n^2),并且是稳定的,相同大小的元素,不会改变元素原有的排列顺序

3.希尔排序

  • 实现步骤
    希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
    先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量 =1( < …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
    其实就是分成很多小组使序列尽可能的变成有序段，因为我们通过对插入排序分析可知，插入排序对已经排好序的序列速度是很快的。
    来看一个具体的过程：7 8 9 0 4 3 1 2 5 10
    我们取的这个增量分别就是5 2 1

  • 图解
    请添加图片描述

  • 代码

      package algorithm.sort;
      
      import java.util.Arrays;
      
      /**
       * @author darlight
       * @date 2021/8/24 13:39
       * @blame ue189 Team
       */
      public class HillSort {
      
          public static void main(String[] args) {
              int[] arr = {1, 4, 2, 7, 9, 8, 3, 6};
              sort(arr);
              System.out.println(Arrays.toString(arr));
              int[] arr1 = {1, 4, 2, 7, 9, 8, 3, 6};
              sort1(arr1);
              System.out.println(Arrays.toString(arr1));
          }
      
          /**
           * 希尔排序 针对有序序列在插入时采用交换法
           *
           * @param arr
           */
          public static void sort(int[] arr) {
              //增量gap，并逐步缩小增量
              for (int gap = arr.length / 2; gap > 0; gap /= 2) {
                  //从第gap个元素，逐个对其所在组进行直接插入排序操作
                  for (int i = gap; i < arr.length; i++) {
                      int j = i;
                      while (j - gap >= 0 && arr[j] < arr[j - gap]) {
                          //插入排序采用交换法
                          swap(arr, j, j - gap);
                          j -= gap;
                      }
                  }
              }
          }
      
          /**
           * 希尔排序 针对有序序列在插入时采用移动法。
           *
           * @param arr
           */
          public static void sort1(int[] arr) {
              //增量gap，并逐步缩小增量
              for (int gap = arr.length / 2; gap > 0; gap /= 2) {
                  //从第gap个元素，逐个对其所在组进行直接插入排序操作
                  for (int i = gap; i < arr.length; i++) {
                      int j = i;
                      int temp = arr[j];
                      if (arr[j] < arr[j - gap]) {
                          while (j - gap >= 0 && temp < arr[j - gap]) {
                              //移动法
                              arr[j] = arr[j - gap];
                              j -= gap;
                          }
                          arr[j] = temp;
                      }
                  }
              }
          }
      
          /**
           * 交换数组元素
           *
           * @param arr
           * @param a
           * @param b
           */
          public static void swap(int[] arr, int a, int b) {
              arr[a] = arr[a] + arr[b];
              arr[b] = arr[a] - arr[b];
              arr[a] = arr[a] - arr[b];
          }
      
      }

4.归并排序

  • 实现步骤
    顾名思义,采用递归和分治的思想进行排序,将要排序的数组分到最小单元后再对比排序,依次合并,如下图所示

  • 图解
    请添加图片描述

  • 代码示例

      package algorithm.sort;
  
  import java.util.Arrays;
  
  /**
   * @author darlight
   * @date 2021/8/24 15:28
   * @blame ue189 Team
   */
  public class RecursionSort {
      public static void mergeSort(int data[],int left ,int right) {
  //        如果左边和右边相等,说明已经分到只有一个数了,不需要再拆分了
          if (left < right) {
              int mid = (left + right) / 2;
  //            拆分左边
              System.out.println("拆分左边:left:"+left+";right:"+mid+";");
              mergeSort(data, left, mid);
  //            拆分右边
              System.out.println("拆分右边:left:"+(mid+1)+";right:"+right+";");
              mergeSort(data, mid + 1, right);
  //            合并
              System.out.println("合并:left:"+left+";mid:"+mid+";right:"+right+";");
              merge(data, left, mid, right);
          }
      }
  
      public static void merge(int[] data, int left, int mid, int right) {
          int[] temp = new int[data.length];
  //        左边第一个数的位置
          int point1 = left;
  //        右边第一个数的位置
          int point2 = mid + 1;
  //        表示当前已经到了哪个位置
          int loc = left;
  //        左边到头并且右边也到头了就停止合并
          while (point1 <= mid && point2 <= right) {
  //            哪个小就把哪个放到前面
              if (data[point1] < data[point2]) {
                  temp[loc] = data[point1];
                  point1++;
                  loc++;
              }else {
                  temp[loc] = data[point2];
                  point2++;
                  loc++;
              }
          }
  //        如果左边没有走完但是右边走完了,那么左边没走完的放入新的数组
          while (point1 <= mid) {
              temp[loc++] = data[point1++];
          }
  //        如果右边没有走完但是左边走完了,右边没有走完的放入新的数组
          while (point2 <= right) {
              temp[loc++] = data[point2++];
          }
  //        排序过的数组替换原数组继续下一轮排序
          for (int i = left; i <=right ; i++) {
              data[i] = temp[i];
          } 
      }
  
      public static void main(String[] args) {
          int[] data = {9, 5, 6, 8, 0, 3, 7, 1,2,4,23,51,98,14};
          mergeSort(data, 0, data.length - 1);
          System.out.println(Arrays.toString(data));
      }
  }

5.选择排序

  • 实现步骤
    选择排序的思路和插入排序非常相似，也分已排序和未排序区间。但选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。
    例如:对 4 5 6 3 2 1 进行排序
    第一次排序: 1 5 6 3 2 4
    第二次排序: 1 2 6 3 5 4

  • 图解
    请添加图片描述

  • 代码示例

      package algorithm.sort;
      
      import java.util.Arrays;
      
      /**
       * 选择排序
       * @author darlight
       * @date 2021/8/25 14:31
       * @blame ue189 Team
       */
      public class SelectSort {
          public static void selectSort(int[] data) {
      //        未排序区的指针
              for (int i = 0; i < data.length ; i++) {
                  int min = data[i];
                  int loc = i;
                  for (int j = i; j < data.length; j++) {
      //                如果最小的数大于当前数,那么当前数就是最小的数
                      if (min > data[j]) {
                          min = data[j];
                          loc = j;
                      }
                  }
                  int datum = data[i];
                  data[i] = data[loc];
                  data[loc] = datum;
              }
          }
      
          public static void main(String[] args) {
              int[] data = {4, 5, 6, 3, 2, 1};
              selectSort(data);
              System.out.println(Arrays.toString(data));
          }
      }

6.冒泡排序

  • 实现方式
    冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复n次，就完成了n个数据的排序工作。

  • 图解
    请添加图片描述

  • 代码示例

     package algorithm.sort;
 
 import java.util.Arrays;
 
 /**
  * @author darlight
  * @date 2021/8/25 15:05
  * @blame ue189 Team
  */
 public class BubbleSort {
     public static void bubbleSort(int[] data) {
 //        这是排序的次数,后面已经拍好的就不需要再进行比较了
         for (int i = 0; i < data.length ; i++) {
             boolean flag = false;
             for (int j = 0; j < data.length - i - 1; j++) {
                 if (data[j] > data[j + 1]) {
                     int a = data[j];
                     data[j] = data[j + 1];
                     data[j + 1] = a;
                     flag = true;
                 }
             }
 //            如果没有进行交换了,说明已经排完序了
             if (!flag) {
                 break;
             }
         }
     }
 
     public static void main(String[] args) {
         int[] data = {4, 5, 6, 3, 2, 1};
         bubbleSort(data);
         System.out.println(Arrays.toString(data));
     }
 }

7.快速排序

  • 实现步骤
    取一个基准数(通常是排序的第一个数),从后面往前找到比基准数小的数进行对换,从前面往后面找比基准数大的进行对换,直到不需要交换,以基准数分为3部分，左边的比之小，右边比之大.

  • 图解
    请添加图片描述

  • 代码示例

package algorithm.sort;
      
      import java.util.Arrays;
      
      /**
       * @author darlight
       * @date 2021/8/26 11:00
       * @blame ue189 Team
       */
      public class QuicklySort {
          public static void quicklySort(int[] data, int left, int right) {
              int base = data[left];
      //        从左边开始找的位置
              int ll = left;
      //        从右边开始找的位置
              int rr = right;
      //        如果右边比基准数大就一直找
              while (ll < rr ) {
                  while (data[rr] >= base) {
                      rr--;
                  }
      //        如果右边有比基准数小的就和基准数就行交换
                  if (ll < rr) {
                      data[ll] = data[rr];
                      data[rr] = base;
      //                已经找过的数下次就不需要找了
                      ll++;
                  }
      //            如果左边一直小于基准数就一直找
                  while (ll < rr && data[ll] <= base) {
                      ll++;
                  }
      //            如果在左边找到了比基准数大的数,就和基准数进行交换
                  if (ll < rr) {
                      data[rr] = data[ll];
                      data[ll] = base;
                      rr--;
                  }
              }
      //        左边起始点比移动到的左边下标小,说明左边需要继续排序
              if (left < ll) {
                  quicklySort(data, left, ll - 1);
              }
      //        分出来的的部分也需要继续排序
              if (ll < right) {
                  quicklySort(data, ll + 1, right);
              }
          }
      
          public static void main(String[] args) {
              int[] data = {45, 62, 72, 36, 12, 81, 90, 11, 15, 13};
              quicklySort(data, 0, data.length - 1);
              System.out.println(Arrays.toString(data));
      //        [11, 12, 13, 15, 36, 45, 62, 72, 81, 90]
          }
      }
夏の在りか
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法入门教程（七、迭代）
YoungGeeker
08-13 1454
迭代法也称辗转法，是一种不断用变量的旧值递推新值的过程，在解决问题时总是重复利用一种方法。与迭代法相对应的是直接法（或者称为一次解法），即一次性解决问题。迭代法又分为精确迭代和近似迭代。“二分法”和“牛顿迭代法”属于近似迭代法，功能都比较类似。......
递归算法和迭代法
m0_62636612的博客
12-15 2547
迭代和递归
递归与迭代详解
龙门变化人皆望，莺谷飞鸣自有时
09-17 749
​ 递归是个很神奇的思想，与迭代不同的地方在于，迭代通过原来的变量推出新值，接着以新值为初始值继续递推，直到满足条件，而递归则是A循环调用本身。举个简单的例子，计算1到n的和： ​ 迭代实现： def a(n): sum = 0 for i in range(1, n + 1): sum += i return sum ​ 每次都以sum的新值为基础,以sum+=i这个式子递推，直到实现功能。 ​ 递归实现： def b(n)
7、算法设计（高级）
qq_44774198的博客
09-22 1285
算法设计：迭代、穷举搜索、递推、递归、回溯、贪心、动态规划、分治等算法设计。在算法设计中，主要考查动态规划法、分治法、回溯法、递归法、贪心法。
算法分析一：基础知识
qq_51184727的博客
05-26 2066
算法分析一：基础知识
python实现5种基础排序算法
11-02
格式：jupyter notebook 默认格式 最后运行时间状态：2020.11....内容：冒泡、选择、插入、归并、快速排序算法实现及绘图对比（简单绘图） 相关介绍参考https://blog.csdn.net/jerry_liufeng/article/details/109443382
c语言基础包括排序算法
03-16
它的基础知识是每个程序员都应该掌握的重要技能，而排序算法是计算机科学中不可或缺的部分，它涉及到数据处理和效率优化。在这个主题中，我们将深入探讨C语言的基础以及其中的排序算法。 一、C语言基础 1. 变量与...
基础算法python冒泡排序法
11-01
【基础算法】python冒泡排序法 def bubble_sort_optimized(arr): n = len(arr) for i in range(n): swapped = False for j in range(n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] ...
排序算法介绍.zip基础算法
03-27
在“排序算法介绍.zip基础算法”这个压缩包中，我们很可能会找到关于各种排序算法的详细讲解，包括它们的基本原理、实现方式以及性能分析。下面我们将深入探讨排序算法的一些主要知识点。 1. **冒泡排序**：是最...
算法（Java实现）-算法的时间复杂度和空间复杂度
jQueryZK的博客
09-06 3832
1、时间复杂度 1.1度量一个程序（算法）执行时间的两种方法 事后统计的方法 这种方法可行, 但是有两个问题： 一是要想对设计的算法的运行性能进行评测，需要实际运行该程序； 二是所得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式，要在同一台计算机的相同状态下运行，才能比较那个算法速度更快。 事前估计的方法 通过分析某个算法的时间复杂度来判断哪个算法更优。因事后统计方法更多的依赖于计算机的硬件、软件等环境因素，有时容易掩盖算法本身的优劣。因此人们常常采用事前分析估算的方法。 在编写程序前，依据
【18】输出字符菱形
2301_78786609的博客
07-19 411
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 361
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
算法题目整合5
最新发布
qq_62571233的博客
07-23 666
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 591
AtCoder Beginner Contest 363 ABCDE
2024.7.19 刷题总结
TheJustice_的博客
07-19 269
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 482
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 282
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 364
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
C语言基础排序算法详解
在本课件中，我们还讲解了排序算法的基本概念和实现方法，包括冒泡排序、选择排序、插入排序等。通过对排序算法的学习，学生可以了解算法的基本概念和实现方法，并具备解决实际问题的能力。 在本课件的最后，我们还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值