湖南网站托管,郴州建网站,wordpress外贸建站,手机网站建设哪个原文链接#xff1a;https://www.jianshu.com/p/42f81846c0fb 这篇文章是常见数据结构与算法整理总结的下篇#xff0c;上一篇主要是对常见的数据结构进行集中总结#xff0c;这篇主要是总结一些常见的算法相关内容#xff0c;文章中如有错误#xff0c;欢迎指出。 一、概…原文链接https://www.jianshu.com/p/42f81846c0fb 这篇文章是常见数据结构与算法整理总结的下篇上一篇主要是对常见的数据结构进行集中总结这篇主要是总结一些常见的算法相关内容文章中如有错误欢迎指出。 一、概述
二、查找算法
三、排序算法
四、其它算法
五、常见算法题
六、总结一、概述 以前看到这样一句话语言只是工具算法才是程序设计的灵魂。的确算法在计算机科学中的地位真的很重要在很多大公司的笔试面试中算法掌握程度的考察都占据了很大一部分。不管是为了面试还是自身编程能力的提升花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习总结。 算法简介 算法是指解题方案的准确而完整的描述是一系列解决问题的清晰指令算法代表着用系统的方法描述解决问题的策略机制。对于同一个问题的解决可能会存在着不同的算法为了衡量一个算法的优劣提出了空间复杂度与时间复杂度这两个概念。 时间复杂度 一般情况下算法中基本操作重复执行的次数是问题规模n的某个函数f(n)算法的时间度量记为 ** T(n) O(f(n)) **它表示随问题规模n的增大算法执行时间的增长率和f(n)的增长率相同称作算法的渐近时间复杂度简称时间复杂度。这里需要重点理解这个增长率。 举个例子看下面3个代码1、{x;}
2、for(i 1; i n; i) { x; }
3、for(j 1; j n; j) for(j 1; j n; j) { x; }
上述含有 x 操作的语句的频度分别为1 、n 、n^2
假设问题的规模扩大了n倍3个代码的增长率分别是1 、n 、n^2
它们的时间复杂度分别为O(1)、O(n )、O(n^2) 空间复杂度 空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度记做S(n)O(f(n))。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。
二、查找算法
查找和排序是最基础也是最重要的两类算法熟练地掌握这两类算法并能对这些算法的性能进行分析很重要这两类算法中主要包括二分查找、快速排序、归并排序等等。 顺序查找 顺序查找又称线性查找。它的过程为从查找表的最后一个元素开始逐个与给定关键字比较若某个记录的关键字和给定值比较相等则查找成功否则若直至第一个记录其关键字和给定值比较都不等则表明表中没有所查记录查找不成功它的缺点是效率低下。 二分查找 简介
二分查找又称折半查找对于有序表来说它的优点是比较次数少查找速度快平均性能好。
二分查找的基本思想是将n个元素分成大致相等的两部分取a[n/2]与x做比较如果xa[n/2],则找到x算法中止如果xa[n/2]则只要在数组a的左半部分继续搜索x如果xa[n/2]则只要在数组a的右半部搜索x。
二分查找的时间复杂度为O(logn)
实现
//给定有序查找表array 二分查找给定的值data
//查找成功返回下标 查找失败返回-1static int funBinSearch(int[] array, int data) {
span classhljs-keywordint/span low span classhljs-number0/span;
span classhljs-keywordint/span high span classhljs-built_inarray/span.length - span classhljs-number1/span;span classhljs-keywordwhile/span (low lt; high) {span classhljs-keywordint/span mid (low high) / span classhljs-number2/span;span classhljs-keywordif/span (data span classhljs-built_inarray/span[mid]) {span classhljs-keywordreturn/span mid;} span classhljs-keywordelse/span span classhljs-keywordif/span (data lt; span classhljs-built_inarray/span[mid]) {high mid - span classhljs-number1/span;} span classhljs-keywordelse/span {low mid span classhljs-number1/span;}
}
span classhljs-keywordreturn/span span classhljs-number-1/span;}
三、排序算法
排序是计算机程序设计中的一种重要操作它的功能是将一个数据元素或记录的任意序列重新排列成一个按关键字有序的序列。下面主要对一些常见的排序算法做介绍并分析它们的时空复杂度。 常见排序算法 常见排序算法性能比较 图片来自网络 上面这张表中有稳定性这一项排序的稳定性是指如果在排序的序列中存在前后相同的两个元素的话排序前和排序后他们的相对位置不发生变化。
下面从冒泡排序开始逐一介绍。 冒泡排序 简介
冒泡排序的基本思想是设排序序列的记录个数为n进行n-1次遍历每次遍历从开始位置依次往后比较前后相邻元素这样较大的元素往后移n-1次遍历结束后序列有序。
例如对序列(3,2,1,5)进行排序的过程是共进行3次遍历第1次遍历时先比较3和2交换继续比较3和1,交换再比较3和5不交换这样第1次遍历结束最大值5在最后的位置得到序列(2,1,3,5)。第2次遍历时先比较2和1交换继续比较2和3不交换第2次遍历结束时次大值3在倒数第2的位置得到序列(1,2,3,5)第3次遍历时先比较1和2不交换得到最终有序序列(1,2,3,5)。
需要注意的是如果在某次遍历中没有发生交换那么就不必进行下次遍历因为序列已经有序。
实现
// 冒泡排序 注意 flag 的作用
static void funBubbleSort(int[] array) {
boolean flag span classhljs-literaltrue/span;span classhljs-keywordfor/span (span classhljs-keywordint/span i span classhljs-number0/span; i lt; span classhljs-built_inarray/span.length - span classhljs-number1/span amp;amp; flag; i) {flag span classhljs-literalfalse/span;span classhljs-keywordfor/span (span classhljs-keywordint/span j span classhljs-number0/span; j lt; span classhljs-built_inarray/span.length - span classhljs-number1/span - i; j) {span classhljs-keywordif/span (span classhljs-built_inarray/span[j] gt; span classhljs-built_inarray/span[j span classhljs-number1/span]) {span classhljs-keywordint/span temp span classhljs-built_inarray/span[j];span classhljs-built_inarray/span[j] span classhljs-built_inarray/span[j span classhljs-number1/span];span classhljs-built_inarray/span[j span classhljs-number1/span] temp;flag span classhljs-literaltrue/span;}}
}span classhljs-keywordfor/span (span classhljs-keywordint/span i span classhljs-number0/span; i lt; span classhljs-built_inarray/span.length; i) {System.out.println(span classhljs-built_inarray/span[i]);
}}
分析
最佳情况下冒泡排序只需一次遍历就能确定数组已经排好序不需要进行下一次遍历所以最佳情况下时间复杂度为** O(n) **。
最坏情况下冒泡排序需要n-1次遍历第一次遍历需要比较n-1次第二次遍历需要n-2次...最后一次需要比较1次最差情况下时间复杂度为** O(n^2) **。 简单选择排序 简介
简单选择排序的思想是设排序序列的记录个数为n进行n-1次选择每次在n-i1(i 1,2,...,n-1)个记录中选择关键字最小的记录作为有效序列中的第i个记录。
例如排序序列(3,2,1,5)的过程是进行3次选择第1次选择在4个记录中选择最小的值为1放在第1个位置得到序列(1,3,2,5)第2次选择从位置1开始的3个元素中选择最小的值2放在第2个位置得到有序序列(1,2,3,5)第3次选择因为最小的值3已经在第3个位置不需要操作最后得到有序序列1,2,3,5。
实现
static void funSelectionSort(int[] array) {
span classhljs-keywordfor/span (span classhljs-keywordint/span i span classhljs-number0/span; i lt; span classhljs-built_inarray/span.length - span classhljs-number1/span; i) {span classhljs-keywordint/span mink i;span classhljs-comment// 每次从未排序数组中找到最小值的坐标/spanspan classhljs-keywordfor/span (span classhljs-keywordint/span j i span classhljs-number1/span; j lt; span classhljs-built_inarray/span.length; j) {span classhljs-keywordif/span (span classhljs-built_inarray/span[j] lt; span classhljs-built_inarray/span[mink]) {mink j;}}span classhljs-comment// 将最小值放在最前面/spanspan classhljs-keywordif/span (mink ! i) {span classhljs-keywordint/span temp span classhljs-built_inarray/span[mink];span classhljs-built_inarray/span[mink] span classhljs-built_inarray/span[i];span classhljs-built_inarray/span[i] temp;}
}span classhljs-keywordfor/span (span classhljs-keywordint/span i span classhljs-number0/span; i lt; span classhljs-built_inarray/span.length; i) {System.out.print(span classhljs-built_inarray/span[i] span classhljs-string /span);
}}
分析
简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况** 无关。当i1时需进行n-1次比较当i2时需进行n-2次比较依次类推共需要进行的比较次数是(n-1)(n-2)…21n(n-1)/2即进行比较操作的时间复杂度为 O(n^2) 进行移动操作的时间复杂度为 O(n) 。总的时间复杂度为 O(n^2) **。
最好情况下即待排序记录初始状态就已经是正序排列了则不需要移动记录。最坏情况下即待排序记录初始状态是按第一条记录最大之后的记录从小到大顺序排列则需要移动记录的次数最多为3n-1。
简单选择排序是不稳定排序。 直接插入排序 简介
直接插入的思想是是将一个记录插入到已排好序的有序表中从而得到一个新的、记录数增1的有序表。
例如排序序列(3,2,1,5)的过程是初始时有序序列为(3)然后从位置1开始先访问到2将2插入到3前面得到有序序列(2,3)之后访问1,找到合适的插入位置后得到有序序列(1,2,3)最后访问5得到最终有序序列(1,2,3,5).
实现
static void funDInsertSort(int[] array) {
span classhljs-keywordint/span j;span classhljs-keywordfor/span (span classhljs-keywordint/span i span classhljs-number1/span; i lt; span classhljs-built_inarray/span.length; i) {span classhljs-keywordint/span temp span classhljs-built_inarray/span[i];j i - span classhljs-number1/span;span classhljs-keywordwhile/span (j gt; span classhljs-number-1/span amp;amp; temp lt; span classhljs-built_inarray/span[j]) {span classhljs-built_inarray/span[j span classhljs-number1/span] span classhljs-built_inarray/span[j];j--;}span classhljs-built_inarray/span[j span classhljs-number1/span] temp;}span classhljs-keywordfor/span (span classhljs-keywordint/span i span classhljs-number0/span; i lt; span classhljs-built_inarray/span.length; i) {System.out.print(span classhljs-built_inarray/span[i] span classhljs-string /span);
}}
分析
最好情况下当待排序序列中记录已经有序时则需要n-1次比较不需要移动时间复杂度为** O(n) 。最差情况下当待排序序列中所有记录正好逆序时则比较次数和移动次数都达到最大值时间复杂度为 O(n^2) 。平均情况下时间复杂度为 O(n^2) **。 希尔排序 希尔排序又称“缩小增量排序”它是基于直接插入排序的以下两点性质而提出的一种改进(1) 直接插入排序在对几乎已经排好序的数据操作时效率高即可以达到线性排序的效率。(2) 直接插入排序一般来说是低效的因为插入排序每次只能将数据移动一位。点击查看更多关于希尔排序的内容 归并排序 简介
归并排序是分治法的一个典型应用它的主要思想是将待排序序列分为两部分对每部分递归地应用归并排序在两部分都排好序后进行合并。
例如排序序列(3,2,8,6,7,9,1,5)的过程是先将序列分为两部分(3,2,8,6)和(7,9,1,5)然后对两部分分别应用归并排序第1部分(3,2,8,6)第2部分(7,9,1,5)对两个部分分别进行归并排序第1部分继续分为(3,2)和(8,6)(3,2)继续分为(3)和(2)(8,6)继续分为(8)和(6)之后进行合并得到(2,3)(6,8)再合并得到(2,3,6,8)第2部分进行归并排序得到(1,5,7,9)最后合并两部分得到(1,2,3,5,6,7,8,9)。
实现 //归并排序static void funMergeSort(int[] array) {span classhljs-keywordif/span (span classhljs-built_inarray/span.length gt; span classhljs-number1/span) {span classhljs-keywordint/span length1 span classhljs-built_inarray/span.length / span classhljs-number2/span;span classhljs-keywordint/span[] array1 span classhljs-keywordnew/span span classhljs-keywordint/span[length1];System.arraycopy(span classhljs-built_inarray/span, span classhljs-number0/span, array1, span classhljs-number0/span, length1);funMergeSort(array1);span classhljs-keywordint/span length2 span classhljs-built_inarray/span.length - length1;span classhljs-keywordint/span[] array2 span classhljs-keywordnew/span span classhljs-keywordint/span[length2];System.arraycopy(span classhljs-built_inarray/span, length1, array2, span classhljs-number0/span, length2);funMergeSort(array2);span classhljs-keywordint/span[] datas merge(array1, array2);System.arraycopy(datas, span classhljs-number0/span, span classhljs-built_inarray/span, span classhljs-number0/span, span classhljs-built_inarray/span.length);}}span classhljs-comment//合并两个数组/span
span classhljs-keywordstatic/span span classhljs-keywordint/span[] merge(span classhljs-keywordint/span[] list1, span classhljs-keywordint/span[] list2) {span classhljs-keywordint/span[] list3 span classhljs-keywordnew/span span classhljs-keywordint/span[list1.length list2.length];span classhljs-keywordint/span count1 span classhljs-number0/span;span classhljs-keywordint/span count2 span classhljs-number0/span;span classhljs-keywordint/span count3 span classhljs-number0/span;span classhljs-keywordwhile/span (count1 lt; list1.length amp;amp; count2 lt; list2.length) {span classhljs-keywordif/span (list1[count1] lt; list2[count2]) {list3[count3] list1[count1];} span classhljs-keywordelse/span {list3[count3] list2[count2];}}span classhljs-keywordwhile/span (count1 lt; list1.length) {list3[count3] list1[count1];}span classhljs-keywordwhile/span (count2 lt; list2.length) {list3[count3] list2[count2];}span classhljs-keywordreturn/span list3;
}分析
归并排序的时间复杂度为O(nlogn)它是一种稳定的排序java.util.Arrays类中的sort方法就是使用归并排序的变体来实现的。 快速排序 简介
快速排序的主要思想是在待排序的序列中选择一个称为主元的元素将数组分为两部分使得第一部分中的所有元素都小于或等于主元而第二部分中的所有元素都大于主元然后对两部分递归地应用快速排序算法。
实现
// 快速排序
static void funQuickSort(int[] mdata, int start, int end) {if (end start) {int pivotIndex quickSortPartition(mdata, start, end);funQuickSort(mdata, start, pivotIndex - 1);funQuickSort(mdata, pivotIndex 1, end);}
}// 快速排序前的划分 static int quickSortPartition(int[] list, int first, int last) {
span classhljs-keywordint/span pivot span classhljs-built_inlist/span[first];
span classhljs-keywordint/span low first span classhljs-number1/span;
span classhljs-keywordint/span high last;span classhljs-keywordwhile/span (high gt; low) {span classhljs-keywordwhile/span (low lt; high amp;amp; span classhljs-built_inlist/span[low] lt; pivot) {low;}span classhljs-keywordwhile/span (low lt; high amp;amp; span classhljs-built_inlist/span[high] gt; pivot) {high--;}span classhljs-keywordif/span (high gt; low) {span classhljs-keywordint/span temp span classhljs-built_inlist/span[high];span classhljs-built_inlist/span[high] span classhljs-built_inlist/span[low];span classhljs-built_inlist/span[low] temp;}
}span classhljs-keywordwhile/span (high gt; first amp;amp; span classhljs-built_inlist/span[high] gt; pivot) {high--;
}span classhljs-keywordif/span (pivot gt; span classhljs-built_inlist/span[high]) {span classhljs-built_inlist/span[first] span classhljs-built_inlist/span[high];span classhljs-built_inlist/span[high] pivot;span classhljs-keywordreturn/span high;
} span classhljs-keywordelse/span {span classhljs-keywordreturn/span first;
}}
分析
在快速排序算法中比较关键的一个部分是主元的选择。在最差情况下划分由n个元素构成的数组需要进行n次比较和n次移动因此划分需要的时间是O(n)。在最差情况下每次主元会将数组划分为一个大的子数组和一个空数组这个大的子数组的规模是在上次划分的子数组的规模上减1这样在最差情况下算法需要(n-1)(n-2)...1 ** O(n^2) **时间。
最佳情况下每次主元将数组划分为规模大致相等的两部分时间复杂度为** O(nlogn) **。 堆排序 简介
在介绍堆排序之前首先需要了解堆的定义n个关键字序列K1K2…Kn称为堆当且仅当该序列满足如下性质简称为堆性质(1) ki k(2i且 ki k(2i1) (1 ≤ i≤ n/2当然这是小根堆大根堆则换成号。
如果将上面满足堆性质的序列看成是一个完全二叉树则堆的含义表明完全二叉树中所有的非终端节点的值均不大于或不小于其左右孩子节点的值。
堆排序的主要思想是给定一个待排序序列首先经过一次调整将序列构建成一个大顶堆此时第一个元素是最大的元素将其和序列的最后一个元素交换然后对前n-1个元素调整为大顶堆再将其第一个元素和末尾元素交换这样最后即可得到有序序列。
实现
//堆排序
public class TestHeapSort {
span classhljs-functionspan classhljs-keywordpublic/span span classhljs-keywordstatic/span span classhljs-keywordvoid/span span classhljs-titlemain/spanspan classhljs-params(String[] args)/span /span{span classhljs-keywordint/span arr[] { span classhljs-number5/span, span classhljs-number6/span, span classhljs-number1/span, span classhljs-number0/span, span classhljs-number2/span, span classhljs-number9/span };heapsort(arr, span classhljs-number6/span);System.out.println(Arrays.toString(arr));
}span classhljs-functionspan classhljs-keywordstatic/span span classhljs-keywordvoid/span span classhljs-titleheapsort/spanspan classhljs-params(span classhljs-keywordint/span arr[], span classhljs-keywordint/span n)/span /span{span classhljs-comment// 先建大顶堆/spanspan classhljs-keywordfor/span (span classhljs-keywordint/span i n / span classhljs-number2/span - span classhljs-number1/span; i gt; span classhljs-number0/span; i--) {heapAdjust(arr, i, n);}span classhljs-keywordfor/span (span classhljs-keywordint/span i span classhljs-number0/span; i lt; n - span classhljs-number1/span; i) {swap(arr, span classhljs-number0/span, n - i - span classhljs-number1/span);heapAdjust(arr, span classhljs-number0/span, n - i - span classhljs-number1/span);}
}span classhljs-comment// 交换两个数/span
span classhljs-functionspan classhljs-keywordstatic/span span classhljs-keywordvoid/span span classhljs-titleswap/spanspan classhljs-params(span classhljs-keywordint/span arr[], span classhljs-keywordint/span low, span classhljs-keywordint/span high)/span /span{span classhljs-keywordint/span temp arr[low];arr[low] arr[high];arr[high] temp;
}span classhljs-comment// 调整堆/span
span classhljs-functionspan classhljs-keywordstatic/span span classhljs-keywordvoid/span span classhljs-titleheapAdjust/spanspan classhljs-params(span classhljs-keywordint/span arr[], span classhljs-keywordint/span index, span classhljs-keywordint/span n)/span /span{span classhljs-keywordint/span temp arr[index];span classhljs-keywordint/span child span classhljs-number0/span;span classhljs-keywordwhile/span (index * span classhljs-number2/span span classhljs-number1/span lt; n) {child index * span classhljs-number2/span span classhljs-number1/span;span classhljs-comment// child为左右孩子中较大的那个/spanspan classhljs-keywordif/span (child ! n - span classhljs-number1/span amp;amp; arr[child] lt; arr[child span classhljs-number1/span]) {child;}span classhljs-comment// 如果指定节点大于较大的孩子 不需要调整/spanspan classhljs-keywordif/span (temp gt; arr[child]) {span classhljs-keywordbreak/span;} span classhljs-keywordelse/span {span classhljs-comment// 否则继续往下判断孩子的孩子 直到找到合适的位置/spanarr[index] arr[child];index child;}}arr[index] temp;
}} 分析
由于建初始堆所需的比较次数较多所以堆排序不适宜于记录数较少的文件。堆排序时间复杂度也为O(nlogn)空间复杂度为O(1)。它是不稳定的排序方法。与快排和归并排序相比堆排序在最差情况下的时间复杂度优于快排空间效率高于归并排序。
四、其它算法
在上面的篇幅中主要是对查找和常见的几种排序算法作了介绍这些内容都是基础的但是必须掌握的内容尤其是二分查找、快排、堆排、归并排序这几个更是面试高频考察点。这里不禁想起百度一面的时候让我写二分查找和堆排序二分查找还行然而堆排序当时一脸懵逼...下面主要是介绍一些常见的其它算法。 递归 简介
在平常解决一些编程或者做一些算法题的时候经常会用到递归。程序调用自身的编程技巧称为递归。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。上面介绍的快速排序和归并排序都用到了递归的思想。
经典例子
斐波那契数列又称黄金分割数列、因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入故又称为“兔子数列”指的是这样一个数列0、1、1、2、3、5、8、13、21、34、……在数学上斐波纳契数列以如下被以递归的方法定义F00F11FnF(n-1)F(n-2)n≥2n∈N*。
//斐波那契数列 递归实现
static long funFib(long index) {
span classhljs-keywordif/span (index span classhljs-number0/span) {span classhljs-keywordreturn/span span classhljs-number0/span;
} span classhljs-keywordelse/span span classhljs-keywordif/span (index span classhljs-number1/span) {span classhljs-keywordreturn/span span classhljs-number1/span;
} span classhljs-keywordelse/span {span classhljs-keywordreturn/span funFib(index - span classhljs-number1/span) funFib(index - span classhljs-number2/span);
}}
上面代码是斐波那契数列的递归实现然而我们不难得到它的时间复杂度是O(2^n)递归有时候可以很方便地解决一些问题但是它也会带来一些效率上的问题。下面的代码是求斐波那契数列的另一种方式效率比递归方法的效率高。
static long funFib2(long index) {
span classhljs-keywordlong/span f0 span classhljs-number0/span;
span classhljs-keywordlong/span f1 span classhljs-number1/span;
span classhljs-keywordlong/span f2 span classhljs-number1/span;span classhljs-keywordif/span (index span classhljs-number0/span) {span classhljs-keywordreturn/span f0;
} span classhljs-keywordelse/span span classhljs-keywordif/span (index span classhljs-number1/span) {span classhljs-keywordreturn/span f1;
} span classhljs-keywordelse/span span classhljs-keywordif/span (index span classhljs-number2/span) {span classhljs-keywordreturn/span f2;
}span classhljs-keywordfor/span (span classhljs-keywordint/span i span classhljs-number3/span; i lt; index; i) {f0 f1;f1 f2;f2 f0 f1;
}span classhljs-keywordreturn/span f2;} 分治算法 分治算法的思想是将待解决的问题分解为几个规模较小但类似于原问题的子问题递归地求解这些子问题然后合并这些子问题的解来建立最终的解。分治算法中关键地一步其实就是递归地求解子问题。关于分治算法的一个典型例子就是上面介绍的归并排序。查看更多关于分治算法的内容 动态规划 动态规划与分治方法相似都是通过组合子问题的解来求解待解决的问题。但是分治算法将问题划分为互不相交的子问题递归地求解子问题再将它们的解组合起来而动态规划应用于子问题重叠的情况即不同的子问题具有公共的子子问题。动态规划方法通常用来求解最优化问题。查看更多关于动态规划的内容
动态规划典型的一个例子是最长公共子序列问题。
常见的算法还有很多比如贪心算法回溯算法等等这里都不再详细介绍想要熟练掌握还是要靠刷题刷题刷题然后总结。
五、常见算法题
下面是一些常见的算法题汇总。 不使用临时变量交换两个数 static void funSwapTwo(int a, int b) {
a a ^ b;
b b ^ a;
a a ^ b;System.out.println(a span classhljs-string /span b);} 判断一个数是否为素数 static boolean funIsPrime(int m) {
span classhljs-keywordboolean/span flag span classhljs-keywordtrue/span;span classhljs-keywordif/span (m span classhljs-number1/span) {flag span classhljs-keywordfalse/span;
} span classhljs-keywordelse/span {span classhljs-keywordfor/span (span classhljs-keywordint/span i span classhljs-number2/span; i lt; Math.sqrt(m); i) {span classhljs-keywordif/span (m % i span classhljs-number0/span) {flag span classhljs-keywordfalse/span;span classhljs-keywordbreak/span;}}
}span classhljs-keywordreturn/span flag;} 其它算法题 1、15道使用频率极高的基础算法题 2、二叉树相关算法题 3、链表相关算法题 4、字符串相关算法问题
六、总结
以上就是自己对常见的算法相关内容的总结算法虐我千百遍我待算法如初恋革命尚未成功同志仍需刷题加油。
