各种算法的复杂度

图的连通性判断算法的时间复杂度图是数学中一种常见的数据结构，在计算机科学中也有广泛的应用。

图由节点（顶点）和边组成，表示了不同元素之间的关系。

在图中，如果每个节点都可以通过路径相互到达，则该图被称为连通图，否则被称为非连通图。

图的连通性判断算法指的是判断给定的图是否是连通图的问题。

常见的图的连通性判断算法包括深度优先搜索（DFS）和广度优先搜索（BFS）算法。

接下来，将分别介绍这两种算法，并分析它们的时间复杂度。

一、深度优先搜索（DFS）算法深度优先搜索算法是一种递归的算法，通过访问节点的方式来遍历整个图。

DFS算法首先选择一个节点作为起始节点，然后通过递归地访问与该节点相邻的节点，直到没有未访问过的节点。

如果所有的节点都被访问过，则图是连通的；否则，图是非连通的。

DFS算法的时间复杂度取决于图的大小和结构。

假设图有n个节点和m条边，那么DFS算法的时间复杂度为O(n + m)。

在最坏的情况下，每个节点都需要被访问一次，并且每个节点都需要遍历它的所有相邻节点。

二、广度优先搜索（BFS）算法广度优先搜索算法是一种迭代的算法，通过按层级的方式遍历整个图。

BFS算法首先选择一个节点作为起始节点，然后按照从起始节点开始的顺序，依次访问每个节点的所有相邻节点。

通过不断扩展搜索的范围，直到所有节点都被访问过。

如果所有的节点都被访问过，则图是连通的；否则，图是非连通的。

BFS算法的时间复杂度也取决于图的大小和结构。

假设图有n个节点和m条边，那么BFS算法的时间复杂度为O(n + m)。

在最坏的情况下，每个节点都需要被访问一次，并且每次访问时都需要遍历其所有相邻节点。

总结：图的连通性判断算法的时间复杂度分别为O(n + m)的DFS算法和BFS算法。

其中，n表示图的节点数，m表示图的边数。

这两种算法在连通性判断问题上表现良好，并且可以在较短的时间内找到问题的解答。

需要注意的是，虽然DFS和BFS可以用于判断图的连通性，但它们在处理大规模图时可能存在效率问题。

排序算法所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

分类在计算机科学所使用的排序算法通常被分类为：计算的复杂度（最差、平均、和最好表现），依据串列（list）的大小（n）。

一般而言，好的表现是O。

(n log n)，且坏的行为是Ω(n2)。

对於一个排序理想的表现是O(n)。

仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要Ω(n log n)。

记忆体使用量（以及其他电脑资源的使用）稳定度：稳定排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。

也就是一个排序算法是稳定的，就是当有两个有相等关键的纪录R和S，且在原本的串列中R出现在S之前，在排序过的串列中R也将会是在S之前。

一般的方法：插入、交换、选择、合并等等。

交换排序包含冒泡排序（bubble sort）和快速排序（quicksort）。

选择排序包含shaker排序和堆排序（heapsort）。

当相等的元素是无法分辨的，比如像是整数，稳定度并不是一个问题。

然而，假设以下的数对将要以他们的第一个数字来排序。

(4, 1) (3, 1) (3, 7) (5, 6)在这个状况下，有可能产生两种不同的结果，一个是依照相等的键值维持相对的次序，而另外一个则没有：(3, 1) (3, 7) (4, 1) (5, 6) (维持次序)(3, 7) (3, 1) (4, 1) (5, 6) (次序被改变)不稳定排序算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。

不稳定排序算法可以被特别地时作为稳定。

作这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个物件间之比较，就会被决定使用在原先资料次序中的条目，当作一个同分决赛。

然而，要记住这种次序通常牵涉到额外的空间负担。

排列算法列表在这个表格中，n是要被排序的纪录数量以及k是不同键值的数量。

稳定的冒泡排序（bubble sort）— O(n2)鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2)插入排序（insertion sort）— O(n2)桶排序（bucket sort）— O(n); 需要 O(k) 额外记忆体计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外记忆体归并排序（merge sort）— O(n log n); 需要 O(n) 额外记忆体原地归并排序— O(n2)二叉树排序（Binary tree sort）— O(n log n); 需要 O(n) 额外记忆体鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体基数排序（radix sort）—O(n·k); 需要 O(n) 额外记忆体Gnome sort — O(n2)Library sort — O(n log n) with high probability, 需要(1+ε)n 额外记忆体不稳定选择排序（selection sort）— O(n2)希尔排序（shell sort）— O(n log n) 如果使用最佳的现在版本Comb sort — O(n log n)堆排序（heapsort）— O(n log n)Smoothsort — O(n log n)快速排序（quicksort）—O(n log n) 期望时间, O(n2) 最坏情况; 对於大的、乱数串列一般相信是最快的已知排序Introsort — O(n log n)Patience sorting —O(n log n + k) 最外情况时间, 需要额外的 O(n + k) 空间, 也需要找到最长的递增子序列（longest increasing subsequence）不实用的排序算法Bogo排序—O(n × n!) 期望时间, 无穷的最坏情况。

相关知识介绍（所有定义只为帮助读者理解相关概念，并非严格定义）：1、稳定排序和非稳定排序简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。

反之，就是非稳定的。

比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。

假如变成a1,a4, a2,a3,a5就不是稳定的了。

2、内排序和外排序在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。

3、算法的时间复杂度和空间复杂度所谓算法的时间复杂度，是指执行算法所需要的计算工作量。

一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。

功能：选择排序输入：数组名称（也就是数组首地址）、数组中元素个数算法思想简单描述：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

选择排序是不稳定的。

算法复杂度O(n2)--[n的平方void select_sort(int *x, int n){int i, j, min, t;for (i=0; i<n-1; i++) /*要选择的次数：0~n-2共n-1次*/{min = i; /*假设当前下标为i的数最小，比较后再调整*/for (j=i+1; j<n; j++)/*循环找出最小的数的下标是哪个*/{if (*(x+j) < *(x+min)){min = j; /*如果后面的数比前面的小，则记下它的下标*/}}if (min != i) /*如果min在循环中改变了，就需要交换数据*/{t = *(x+i);*(x+i) = *(x+min);*(x+min) = t;}}/*功能：直接插入排序输入：数组名称（也就是数组首地址）、数组中元素个数算法思想简单描述：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。

深度优先算法和广度优先算法都是图搜索中常见的算法，它们具有不同的特点和适用场景。

在进行全面评估之前，让我们先来了解一下深度优先算法和广度优先算法的基本概念和原理。

### 1. 深度优先算法（Depth-First Search, DFS）深度优先算法是一种用于遍历或搜索树或图的算法。

其核心思想是从起始顶点出发，沿着一条路径直到末端，然后回溯，继续搜索下一条路径，直到所有路径都被探索。

在实际应用中，深度优先算法常常通过递归或栈来实现。

### 2. 广度优先算法（Breadth-First Search, BFS）广度优先算法也是一种用于遍历或搜索树或图的算法。

其核心思想是从起始顶点出发，依次遍历该顶点的所有相邻顶点，然后再以这些相邻顶点作为起点，继续遍历它们的相邻顶点，以此类推，直到所有顶点都被遍历。

在实际应用中，广度优先算法通常通过队列来实现。

### 3. 深度优先算法和广度优先算法的时间复杂度在实际应用中，我们经常需要对算法的时间复杂度进行分析。

针对深度优先算法和广度优先算法，它们的时间复杂度并不相同。

- 深度优先算法的时间复杂度：O(V + E)，其中V为顶点数，E为边数。

在最坏的情况下，如果采用邻接矩阵来表示图的话，深度优先算法的时间复杂度为O(V^2)；如果采用邻接表来表示图的话，时间复杂度为O(V + E)。

- 广度优先算法的时间复杂度：O(V + E)，其中V为顶点数，E为边数。

无论采用邻接矩阵还是邻接表表示图，广度优先算法的时间复杂度都是O(V + E)。

### 4. 个人理解和观点在实际应用中，我们在选择使用深度优先算法还是广度优先算法时，需要根据具体的问题场景来进行选择。

如果要寻找图中的一条路径，或者判断两个节点之间是否存在路径，通常会选择使用深度优先算法；如果要寻找最短路径或者进行层次遍历，通常会选择使用广度优先算法。

深度优先算法和广度优先算法都是非常重要的图搜索算法，它们各自适用于不同的场景，并且具有不同的时间复杂度。

算法时间复杂度的计算公式算法时间复杂度是算法效率的一种度量方式，通常用大O符号来表示，例如O(1)、O(n)、O(n^2)等。

在计算算法时间复杂度时，需要考虑算法中各种操作的时间复杂度，并将它们合并为总时间复杂度。

以下是常见的算法操作时间复杂度：1. 常数级别：O(1)2. 对数级别：O(logn)3. 线性级别：O(n)4. 线性对数级别：O(nlogn)5. 平方级别：O(n^2)6. 立方级别：O(n^3)7. 指数级别：O(2^n)计算总时间复杂度的公式如下：1. 顺序执行的操作，时间复杂度直接相加。

例如，若有操作A、B、C，它们的时间复杂度分别为O(a)、O(b)、O(c)，则总时间复杂度为O(a + b + c)。

2. 嵌套执行的操作，时间复杂度取最大值。

例如，若有操作A、B，操作A执行了n次，每次的时间复杂度为O(n)，操作B的时间复杂度为O(nlogn)，则总时间复杂度为O(n*nlogn)，即O(n^2logn)。

3. 分支语句的时间复杂度为其中时间复杂度最大的分支的时间复杂度。

例如，若有分支语句，分别包含操作A和操作B，它们的时间复杂度分别为O(a)、O(b)，则分支语句的时间复杂度为O(max(a,b))。

4. 循环结构的时间复杂度为循环次数乘以循环体的时间复杂度。

例如，若有循环结构，循环次数为n，循环体包含操作A和操作B，它们的时间复杂度分别为O(a)、O(b)，则循环结构的时间复杂度为O(n*max(a,b))。

综上所述，计算算法总时间复杂度需要考虑各个操作的时间复杂度以及它们的执行顺序、嵌套关系、分支和循环结构。

常⽤排序算法的时间复杂度和空间复杂度以上快速排序和归并排序的空间复杂度不正确没有的参考图1，以图2为准（对，就是懒得重新画图了）排序法最差时间分析平均时间复杂度稳定度空间复杂度冒泡排序O(n2)O(n2)稳定O(1)快速排序O(n2)O(n*log2n)不稳定O(log2n)~O(n)选择排序O(n2)O(n2)稳定O(1)⼆叉树排O(n2)O(n*log2n)不稳定O(n)序插⼊排序O(n2)O(n2)稳定O(1)堆排序O(n*log2n)O(n*log2n)不稳定O(1)希尔排序O O不稳定O(1)1.插⼊排序由N-1趟排序组成，对于p=1到p=N-1趟，插⼊排序保证从位置0到位置p上的元素为已排序状态。

时间复杂度：O(N^2)代码void InsertionSort(ElementType A[],int N){int j,p;ElementType Tmp;for(p=1;p<N;p++){Tmp=A[j];//把A[j]保存下来，因为它要被插⼊到前⾯的某个位置去for(j=p;j>0&&A[j-1]>Tmp;j--)//⼤于A[j]的元素逐个后移{A[j]=A[j-1];}A[j]=Tmp;}}2.希尔排序希尔排序使⽤⼀个序列h1，h2，h3，ht，叫做增量排序。

在使⽤增量hk的⼀趟排序之后，对于每个i我们有A[i]<A[i+hk]，所有相隔hk的元素被排序。

时间复杂度：O(N^(1+a))，其中0<a<1。

//代码不太好理解，使⽤了3层循环void ShellSort(ElementType A[],int N){int j,p,Increment;ElementType Tmp;for(Increment=N/2;Increment>0;Increment/=2){for(p=Increment;p<N;p++){Tmp=A[p];for(j=p;j>=Increment;j-=Increment){if(A[j]<A[j-Increment])A[j]=A[j-Increment];elsebreak;}A[j]=Tmp;}}}3. 堆排序思想：建⽴⼩顶堆，然后执⾏N次deleteMin操作。

各种排序算法的时间复杂度和空间复杂度（阿⾥）⼆分查找法的时间复杂度：O(logn) redis,kafka,B+树的底层都采⽤了⼆分查找法参考：⼆分查找法 redis的索引底层的跳表原理实现参考：⼆分查找法参考：⼆分查找法：1.⼆分查找⼆分查找也称为折半查找，它是⼀种效率较⾼的查找⽅法。

⼆分查找的使⽤前提是线性表已经按照⼤⼩排好了序。

这种⽅法充分利⽤了元素间的次序关系，采⽤分治策略。

基本原理是：⾸先在有序的线性表中找到中值，将要查找的⽬标与中值进⾏⽐较，如果⽬标⼩于中值，则在前半部分找，如果⽬标⼩于中值，则在后半部分找；假设在前半部分找，则再与前半部分的中值相⽐较，如果⼩于中值，则在中值的前半部分找，如果⼤于中值，则在后半部分找。

以此类推，直到找到⽬标为⽌。

假设我们要在 2，6，11，13，16，17，22，30中查找22，上图所⽰，则查找步骤为：⾸先找到中值：中值为13（下标：int middle = (0+7)/2），将22与13进⾏⽐较，发现22⽐13⼤，则在13的后半部分找；在后半部分 16，17，22，30中查找22，⾸先找到中值，中值为17（下标：int middle=(0+3)/2），将22与17进⾏⽐较，发现22⽐17⼤，则继续在17的后半部分查找；在17的后半部分 22，30查找22，⾸先找到中值，中值为22（下标：int middle=(0+1)/2），将22与22进⾏⽐较，查找到结果。

⼆分查找⼤⼤降低了⽐较次数，⼆分查找的时间复杂度为：O(logn)，即。

⽰例代码：public class BinarySearch {public static void main(String[] args) {int arr[] = {2, 6, 11, 13, 16, 17, 22, 30};System.out.println("⾮递归结果,22的位置为:" + binarySearch(arr, 22));System.out.println("递归结果,22的位置为:" + binarySearch(arr, 22, 0, 7));}//⾮递归static int binarySearch(int[] arr, int res) {int low = 0;int high = arr.length-1;while(low <= high) {int middle = (low + high)/2;if(res == arr[middle]) {return middle;}else if(res <arr[middle]) {high = middle - 1;}else {low = middle + 1;}}return -1;}//递归static int binarySearch(int[] arr,int res,int low,int high){if(res < arr[low] || res > arr[high] || low > high){return -1;}int middle = (low+high)/2;if(res < arr[middle]){return binarySearch(arr, res, low, middle-1);}else if(res > arr[middle]){return binarySearch(arr, res, middle+1, high);}else {return middle;}}}其中冒泡排序加个标志，所以最好情况下是o(n)直接选择排序：排序过程：1 、⾸先在所有数据中经过 n-1次⽐较选出最⼩的数，把它与第 1个数据交换，2、然后在其余的数据内选出排序码最⼩的数，与第 2个数据交换...... 依次类推，直到所有数据排完为⽌。

查找算法学习常用的查找算法及其时间复杂度查找算法是计算机科学中非常重要的一种算法，它用于在一组数据中查找指定的元素。

在实际应用中，我们经常需要对大量数据进行查找操作，因此了解不同的查找算法及其时间复杂度对于提高查找效率至关重要。

本文将介绍几种常用的查找算法，并分析它们的时间复杂度。

一、顺序查找算法顺序查找算法是最简单的一种查找算法，也被称为线性查找算法。

它的基本思想是从数据的起始位置开始，一个一个地比较待查找元素和数据中的元素，直到找到匹配的元素或者遍历完所有的元素。

顺序查找算法的时间复杂度为O(n)，其中n表示数据的规模。

由于它需要逐个比较元素，因此在数据规模较大时，效率较低。

二、二分查找算法二分查找算法，也被称为折半查找算法，是一种高效的查找算法。

它的前提是数据必须有序。

基本思想是将待查找的值与中间元素进行比较，如果相等则返回位置，如果不相等则根据大小关系决定继续在左半部分或右半部分进行查找，直到找到匹配的元素或者确定不存在。

二分查找算法的时间复杂度为O(log n)，其中n表示数据的规模。

由于每次查找都将数据规模减半，因此效率非常高。

但是它要求数据必须有序，如果数据无序，需要先进行排序操作。

三、哈希查找算法哈希查找算法是一种常用的查找算法，通过哈希函数将待查找的元素映射到一个桶中，然后在桶中进行查找操作。

它的特点是查找的速度非常快，不受数据规模的影响。

哈希查找算法的时间复杂度近似为O(1)，其中1表示常数时间。

但是它的缺点是需要额外的存储空间来构建哈希表，并且需要解决哈希冲突的问题。

四、二叉查找树算法二叉查找树算法是一种基于二叉树的查找算法，它的特点是左子树的所有节点值小于根节点的值，右子树的所有节点值大于根节点的值。

基于这个特点，可以通过比较待查找元素和当前节点的值来确定查找的方向。

二叉查找树算法的时间复杂度取决于树的高度，如果树的高度为h，则查找的时间复杂度为O(h)。

当二叉查找树退化成链表时，树的高度为n，其中n表示节点的个数，此时查找的时间复杂度为O(n)。

递归的复杂度
递归的复杂度：
1.时间复杂度：递归的时间复杂度往往是指算法的运行时间与输入规模之间的关系。

在很多情况下，递归算法可以非常有效地解决问题，但也有可能出现效率较低的情况，例如在解决某些类型的问题时，使用递归可能导致指数级的时间复杂度。

2.空间复杂度：递归的空间复杂度是指算法在运行过程中使用的内存空间与输入规模之间的关系。

在每次递归调用时，通常需要为新的函数调用分配栈空间，因此如果递归深度很大，空间复杂度可能会成为问题。

3.递归深度：递归深度是指从初始函数调用到最底层递归函数调用的层数。

在某些情况下，过深的递归可能导致程序运行时间过长，甚至可能会导致栈溢出。

4.递归效率：这是指在相同硬件条件下，算法执行的速度。

如果递归算法的效率较低，可能需要考虑使用其他算法或优化策略来提高效率。

总的来说，递归的复杂度是一个需要考虑多方面因素的问题。

在设计和实现算法时，应该尽量选择那些具有较低时间复杂度和空间复杂度的算法，同时也要注意算法的效率和可读性。

复杂度的量级分类复杂度的量级分类复杂度是算法分析中的一个重要概念，它用来描述算法运行时间或空间资源的需求。

通常情况下，我们使用“大 O 记号”（Big O Notation）来表示一个算法的复杂度。

在计算机科学中，我们将算法的复杂度分为不同的量级，以便于比较和评估不同算法之间的性能差异。

一、常数时间复杂度常数时间复杂度（O(1)）指算法执行所需时间不随输入规模增加而增加。

例如，给定两个整数 a 和 b，计算它们的和 a+b 的时间复杂度是O(1)，因为无论 a 和 b 的值如何变化，计算它们的和所需时间都是相同的。

二、线性时间复杂度线性时间复杂度（O(n)）指算法执行所需时间随输入规模n 线性增长。

例如，在一个长度为 n 的数组中查找某个元素是否存在需要遍历整个数组，因此其时间复杂度是 O(n)。

三、对数时间复杂度对数时间复杂度（O(log n)）指算法执行所需时间随输入规模 n 增加而增长但增长速率逐渐减慢。

例如，在一个有序数组中查找某个元素是否存在可以使用二分查找算法，其时间复杂度是 O(log n)。

四、平方时间复杂度平方时间复杂度（O(n^2)）指算法执行所需时间随输入规模 n 的平方增长。

例如，在一个长度为 n 的数组中进行冒泡排序需要进行 n^2 次比较和交换操作，因此其时间复杂度是 O(n^2)。

五、指数时间复杂度指数时间复杂度（O(2^n)）指算法执行所需时间随输入规模 n 指数级增长。

例如，在一个长度为 n 的集合中求其所有子集需要枚举所有可能的组合，因此其时间复杂度是 O(2^n)。

六、多项式时间复杂度多项式时间复杂度（O(n^k)）指算法执行所需时间随输入规模 n 的 k 次幂增长。

例如，在一个长度为 n 的矩阵中进行矩阵乘法需要进行n^3 次乘法和加法操作，因此其时间复杂度是 O(n^3)。

七、指数级别的递归调用在某些情况下，递归调用会导致指数级别的运行时间。

例如，在斐波那契数列中，递归计算第n 个斐波那契数会导致指数级别的运行时间。