常见数据结构与算法整理总结（下）

最新推荐文章于 2024-04-30 14:16:03 发布
最新推荐文章于 2024-04-30 14:16:03 发布
阅读量157 收藏 1
点赞数

常见数据结构与算法整理总结（下）

    <!-- 作者区域 -->
    <div class="author">
      <a class="avatar" href="/u/a82533b0437e">
        <img src="//upload.jianshu.io/users/upload_avatars/2243690/01cb1bae1c10.jpg?imageMogr2/auto-orient/strip|imageView2/1/w/96/h/96" alt="96">


尘语凡心





2016.10.03 16:28*
字数 4379
阅读 33751 评论 10 赞赏 1 



    <!-- 文章内容 -->
    <div data-note-content="" class="show-content">
      <div class="show-content-free" deep="4">
        <blockquote>

这篇文章是常见数据结构与算法整理总结的下篇，上一篇主要是对常见的数据结构进行集中总结，这篇主要是总结一些常见的算法相关内容，文章中如有错误，欢迎指出。

一、概述
二、查找算法
三、排序算法
四、其它算法
五、常见算法题
六、总结

一、概述

以前看到这样一句话，语言只是工具，算法才是程序设计的灵魂。的确，算法在计算机科学中的地位真的很重要，在很多大公司的笔试面试中，算法掌握程度的考察都占据了很大一部分。不管是为了面试还是自身编程能力的提升，花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习总结。

算法简介

算法是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。对于同一个问题的解决，可能会存在着不同的算法，为了衡量一个算法的优劣，提出了空间复杂度与时间复杂度这两个概念。

时间复杂度

一般情况下，算法中基本操作重复执行的次数是问题规模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做比较，如果x=a[n/2],则找到x，算法中止；如果x<a[n/2]，则只要在数组a的左半部分继续搜索x，如果x>a[n/2]，则只要在数组a的右半部搜索x。

二分查找的时间复杂度为O(logn)

  • 实现
//给定有序查找表array 二分查找给定的值data
//查找成功返回下标 查找失败返回-1

static int funBinSearch(int[] array, int data) {

<span class="hljs-keyword">int</span> low = <span class="hljs-number">0</span>;
<span class="hljs-keyword">int</span> high = <span class="hljs-built_in">array</span>.length - <span class="hljs-number">1</span>;

<span class="hljs-keyword">while</span> (low &lt;= high) {

    <span class="hljs-keyword">int</span> mid = (low + high) / <span class="hljs-number">2</span>;

    <span class="hljs-keyword">if</span> (data == <span class="hljs-built_in">array</span>[mid]) {
        <span class="hljs-keyword">return</span> mid;
    } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (data &lt; <span class="hljs-built_in">array</span>[mid]) {
        high = mid - <span class="hljs-number">1</span>;
    } <span class="hljs-keyword">else</span> {
        low = mid + <span class="hljs-number">1</span>;
    }
}
<span class="hljs-keyword">return</span> <span class="hljs-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 class="hljs-literal">true</span>;

<span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &lt; <span class="hljs-built_in">array</span>.length - <span class="hljs-number">1</span> &amp;&amp; flag; i++) {

    flag = <span class="hljs-literal">false</span>;

    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> j = <span class="hljs-number">0</span>; j &lt; <span class="hljs-built_in">array</span>.length - <span class="hljs-number">1</span> - i; j++) {

        <span class="hljs-keyword">if</span> (<span class="hljs-built_in">array</span>[j] &gt; <span class="hljs-built_in">array</span>[j + <span class="hljs-number">1</span>]) {

            <span class="hljs-keyword">int</span> temp = <span class="hljs-built_in">array</span>[j];
            <span class="hljs-built_in">array</span>[j] = <span class="hljs-built_in">array</span>[j + <span class="hljs-number">1</span>];
            <span class="hljs-built_in">array</span>[j + <span class="hljs-number">1</span>] = temp;

            flag = <span class="hljs-literal">true</span>;
        }
    }
}

<span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &lt; <span class="hljs-built_in">array</span>.length; i++) {
    System.out.println(<span class="hljs-built_in">array</span>[i]);
}

}

  • 分析

最佳情况下冒泡排序只需一次遍历就能确定数组已经排好序，不需要进行下一次遍历，所以最佳情况下，时间复杂度为** O(n) **。

最坏情况下冒泡排序需要n-1次遍历，第一次遍历需要比较n-1次，第二次遍历需要n-2次，...，最后一次需要比较1次，最差情况下时间复杂度为** O(n^2) **。

简单选择排序

  • 简介

简单选择排序的思想是：设排序序列的记录个数为n，进行n-1次选择，每次在n-i+1(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 class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &lt; <span class="hljs-built_in">array</span>.length - <span class="hljs-number">1</span>; i++) {

    <span class="hljs-keyword">int</span> mink = i;

        <span class="hljs-comment">// 每次从未排序数组中找到最小值的坐标</span>
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> j = i + <span class="hljs-number">1</span>; j &lt; <span class="hljs-built_in">array</span>.length; j++) {

        <span class="hljs-keyword">if</span> (<span class="hljs-built_in">array</span>[j] &lt; <span class="hljs-built_in">array</span>[mink]) {
            mink = j;
        }
    }

    <span class="hljs-comment">// 将最小值放在最前面</span>
    <span class="hljs-keyword">if</span> (mink != i) {
        <span class="hljs-keyword">int</span> temp = <span class="hljs-built_in">array</span>[mink];
        <span class="hljs-built_in">array</span>[mink] = <span class="hljs-built_in">array</span>[i];
        <span class="hljs-built_in">array</span>[i] = temp;
    }
}

<span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &lt; <span class="hljs-built_in">array</span>.length; i++) {
    System.out.print(<span class="hljs-built_in">array</span>[i] + <span class="hljs-string">" "</span>);
}

}

  • 分析

简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况** 无关。当i=1时，需进行n-1次比较；当i=2时，需进行n-2次比较；依次类推，共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2，即进行比较操作的时间复杂度为 O(n^2) ，进行移动操作的时间复杂度为 O(n) 。总的时间复杂度为 O(n^2) **。

最好情况下，即待排序记录初始状态就已经是正序排列了，则不需要移动记录。最坏情况下，即待排序记录初始状态是按第一条记录最大，之后的记录从小到大顺序排列，则需要移动记录的次数最多为3（n-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 class="hljs-keyword">int</span> j;

<span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">1</span>; i &lt; <span class="hljs-built_in">array</span>.length; i++) {

    <span class="hljs-keyword">int</span> temp = <span class="hljs-built_in">array</span>[i];

    j = i - <span class="hljs-number">1</span>;

    <span class="hljs-keyword">while</span> (j &gt; <span class="hljs-number">-1</span> &amp;&amp; temp &lt; <span class="hljs-built_in">array</span>[j]) {

        <span class="hljs-built_in">array</span>[j + <span class="hljs-number">1</span>] = <span class="hljs-built_in">array</span>[j];

        j--;
    }

    <span class="hljs-built_in">array</span>[j + <span class="hljs-number">1</span>] = temp;

}

<span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &lt; <span class="hljs-built_in">array</span>.length; i++) {
    System.out.print(<span class="hljs-built_in">array</span>[i] + <span class="hljs-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 class="hljs-keyword">if</span> (<span class="hljs-built_in">array</span>.length &gt; <span class="hljs-number">1</span>) {

        <span class="hljs-keyword">int</span> length1 = <span class="hljs-built_in">array</span>.length / <span class="hljs-number">2</span>;
        <span class="hljs-keyword">int</span>[] array1 = <span class="hljs-keyword">new</span> <span class="hljs-keyword">int</span>[length1];
        System.arraycopy(<span class="hljs-built_in">array</span>, <span class="hljs-number">0</span>, array1, <span class="hljs-number">0</span>, length1);
        funMergeSort(array1);

        <span class="hljs-keyword">int</span> length2 = <span class="hljs-built_in">array</span>.length - length1;
        <span class="hljs-keyword">int</span>[] array2 = <span class="hljs-keyword">new</span> <span class="hljs-keyword">int</span>[length2];
        System.arraycopy(<span class="hljs-built_in">array</span>, length1, array2, <span class="hljs-number">0</span>, length2);
        funMergeSort(array2);

        <span class="hljs-keyword">int</span>[] datas = merge(array1, array2);
        System.arraycopy(datas, <span class="hljs-number">0</span>, <span class="hljs-built_in">array</span>, <span class="hljs-number">0</span>, <span class="hljs-built_in">array</span>.length);
    }

}

<span class="hljs-comment">//合并两个数组</span>
<span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span>[] merge(<span class="hljs-keyword">int</span>[] list1, <span class="hljs-keyword">int</span>[] list2) {

    <span class="hljs-keyword">int</span>[] list3 = <span class="hljs-keyword">new</span> <span class="hljs-keyword">int</span>[list1.length + list2.length];

    <span class="hljs-keyword">int</span> count1 = <span class="hljs-number">0</span>;
    <span class="hljs-keyword">int</span> count2 = <span class="hljs-number">0</span>;
    <span class="hljs-keyword">int</span> count3 = <span class="hljs-number">0</span>;

    <span class="hljs-keyword">while</span> (count1 &lt; list1.length &amp;&amp; count2 &lt; list2.length) {

        <span class="hljs-keyword">if</span> (list1[count1] &lt; list2[count2]) {
            list3[count3++] = list1[count1++];
        } <span class="hljs-keyword">else</span> {
            list3[count3++] = list2[count2++];
        }
    }

    <span class="hljs-keyword">while</span> (count1 &lt; list1.length) {
        list3[count3++] = list1[count1++];
    }

    <span class="hljs-keyword">while</span> (count2 &lt; list2.length) {
        list3[count3++] = list2[count2++];
    }

    <span class="hljs-keyword">return</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 class="hljs-keyword">int</span> pivot = <span class="hljs-built_in">list</span>[first];
<span class="hljs-keyword">int</span> low = first + <span class="hljs-number">1</span>;
<span class="hljs-keyword">int</span> high = last;

<span class="hljs-keyword">while</span> (high &gt; low) {

    <span class="hljs-keyword">while</span> (low &lt;= high &amp;&amp; <span class="hljs-built_in">list</span>[low] &lt;= pivot) {
        low++;
    }

    <span class="hljs-keyword">while</span> (low &lt;= high &amp;&amp; <span class="hljs-built_in">list</span>[high] &gt; pivot) {
        high--;
    }

    <span class="hljs-keyword">if</span> (high &gt; low) {
        <span class="hljs-keyword">int</span> temp = <span class="hljs-built_in">list</span>[high];
        <span class="hljs-built_in">list</span>[high] = <span class="hljs-built_in">list</span>[low];
        <span class="hljs-built_in">list</span>[low] = temp;
    }
}

<span class="hljs-keyword">while</span> (high &gt; first &amp;&amp; <span class="hljs-built_in">list</span>[high] &gt;= pivot) {
    high--;
}

<span class="hljs-keyword">if</span> (pivot &gt; <span class="hljs-built_in">list</span>[high]) {
    <span class="hljs-built_in">list</span>[first] = <span class="hljs-built_in">list</span>[high];
    <span class="hljs-built_in">list</span>[high] = pivot;
    <span class="hljs-keyword">return</span> high;
} <span class="hljs-keyword">else</span> {
    <span class="hljs-keyword">return</span> first;
}

}

  • 分析

在快速排序算法中，比较关键的一个部分是主元的选择。在最差情况下，划分由n个元素构成的数组需要进行n次比较和n次移动，因此划分需要的时间是O(n)。在最差情况下，每次主元会将数组划分为一个大的子数组和一个空数组，这个大的子数组的规模是在上次划分的子数组的规模上减1，这样在最差情况下算法需要(n-1)+(n-2)+...+1= ** O(n^2) **时间。

最佳情况下，每次主元将数组划分为规模大致相等的两部分，时间复杂度为** O(nlogn) **。

堆排序

  • 简介

在介绍堆排序之前首先需要了解堆的定义，n个关键字序列K1，K2，…，Kn称为堆，当且仅当该序列满足如下性质（简称为堆性质）：(1) ki <= k(2i）且 ki <= k(2i+1) (1 ≤ i≤ n/2），当然，这是小根堆，大根堆则换成>=号。

如果将上面满足堆性质的序列看成是一个完全二叉树，则堆的含义表明，完全二叉树中所有的非终端节点的值均不大于（或不小于）其左右孩子节点的值。

堆排序的主要思想是：给定一个待排序序列，首先经过一次调整，将序列构建成一个大顶堆，此时第一个元素是最大的元素，将其和序列的最后一个元素交换，然后对前n-1个元素调整为大顶堆，再将其第一个元素和末尾元素交换，这样最后即可得到有序序列。

  • 实现
//堆排序
public class TestHeapSort {

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> </span>{
    <span class="hljs-keyword">int</span> arr[] = { <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">2</span>, <span class="hljs-number">9</span> };
    heapsort(arr, <span class="hljs-number">6</span>);
    System.out.println(Arrays.toString(arr));
}

<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">heapsort</span><span class="hljs-params">(<span class="hljs-keyword">int</span> arr[], <span class="hljs-keyword">int</span> n)</span> </span>{

    <span class="hljs-comment">// 先建大顶堆</span>
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = n / <span class="hljs-number">2</span> - <span class="hljs-number">1</span>; i &gt;= <span class="hljs-number">0</span>; i--) {
        heapAdjust(arr, i, n);
    }

    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &lt; n - <span class="hljs-number">1</span>; i++) {
        swap(arr, <span class="hljs-number">0</span>, n - i - <span class="hljs-number">1</span>);
        heapAdjust(arr, <span class="hljs-number">0</span>, n - i - <span class="hljs-number">1</span>);
    }
}

<span class="hljs-comment">// 交换两个数</span>
<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">swap</span><span class="hljs-params">(<span class="hljs-keyword">int</span> arr[], <span class="hljs-keyword">int</span> low, <span class="hljs-keyword">int</span> high)</span> </span>{
    <span class="hljs-keyword">int</span> temp = arr[low];
    arr[low] = arr[high];
    arr[high] = temp;
}

<span class="hljs-comment">// 调整堆</span>
<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">heapAdjust</span><span class="hljs-params">(<span class="hljs-keyword">int</span> arr[], <span class="hljs-keyword">int</span> index, <span class="hljs-keyword">int</span> n)</span> </span>{

    <span class="hljs-keyword">int</span> temp = arr[index];

    <span class="hljs-keyword">int</span> child = <span class="hljs-number">0</span>;

    <span class="hljs-keyword">while</span> (index * <span class="hljs-number">2</span> + <span class="hljs-number">1</span> &lt; n) {
                    
        child = index * <span class="hljs-number">2</span> + <span class="hljs-number">1</span>;
                    
        <span class="hljs-comment">// child为左右孩子中较大的那个</span>
        <span class="hljs-keyword">if</span> (child != n - <span class="hljs-number">1</span> &amp;&amp; arr[child] &lt; arr[child + <span class="hljs-number">1</span>]) {
            child++;
        }
        <span class="hljs-comment">// 如果指定节点大于较大的孩子 不需要调整</span>
        <span class="hljs-keyword">if</span> (temp &gt; arr[child]) {
            <span class="hljs-keyword">break</span>;
        } <span class="hljs-keyword">else</span> {
            <span class="hljs-comment">// 否则继续往下判断孩子的孩子 直到找到合适的位置</span>
            arr[index] = arr[child];
            index = child;
        }
    }

    arr[index] = temp;
}

}

  • 分析

由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。堆排序时间复杂度也为O(nlogn)，空间复杂度为O(1)。它是不稳定的排序方法。与快排和归并排序相比，堆排序在最差情况下的时间复杂度优于快排，空间效率高于归并排序。

四、其它算法

在上面的篇幅中，主要是对查找和常见的几种排序算法作了介绍，这些内容都是基础的但是必须掌握的内容，尤其是二分查找、快排、堆排、归并排序这几个更是面试高频考察点。（这里不禁想起百度一面的时候让我写二分查找和堆排序，二分查找还行，然而堆排序当时一脸懵逼...）下面主要是介绍一些常见的其它算法。

递归

  • 简介

在平常解决一些编程或者做一些算法题的时候，经常会用到递归。程序调用自身的编程技巧称为递归。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。上面介绍的快速排序和归并排序都用到了递归的思想。

  • 经典例子

斐波那契数列，又称黄金分割数列、因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）。

//斐波那契数列 递归实现
static long funFib(long index) {

<span class="hljs-keyword">if</span> (index == <span class="hljs-number">0</span>) {
    <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (index == <span class="hljs-number">1</span>) {
    <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
} <span class="hljs-keyword">else</span> {
    <span class="hljs-keyword">return</span> funFib(index - <span class="hljs-number">1</span>) + funFib(index - <span class="hljs-number">2</span>);
}

}

上面代码是斐波那契数列的递归实现，然而我们不难得到它的时间复杂度是O(2^n)，递归有时候可以很方便地解决一些问题，但是它也会带来一些效率上的问题。下面的代码是求斐波那契数列的另一种方式，效率比递归方法的效率高。

static long funFib2(long index) {

<span class="hljs-keyword">long</span> f0 = <span class="hljs-number">0</span>;
<span class="hljs-keyword">long</span> f1 = <span class="hljs-number">1</span>;
<span class="hljs-keyword">long</span> f2 = <span class="hljs-number">1</span>;

<span class="hljs-keyword">if</span> (index == <span class="hljs-number">0</span>) {
    <span class="hljs-keyword">return</span> f0;
} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (index == <span class="hljs-number">1</span>) {
    <span class="hljs-keyword">return</span> f1;
} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (index == <span class="hljs-number">2</span>) {
    <span class="hljs-keyword">return</span> f2;
}

<span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">3</span>; i &lt;= index; i++) {
    f0 = f1;
    f1 = f2;
    f2 = f0 + f1;
}

<span class="hljs-keyword">return</span> f2;

}

分治算法

分治算法的思想是将待解决的问题分解为几个规模较小但类似于原问题的子问题，递归地求解这些子问题，然后合并这些子问题的解来建立最终的解。分治算法中关键地一步其实就是递归地求解子问题。关于分治算法的一个典型例子就是上面介绍的归并排序。查看更多关于分治算法的内容

动态规划

动态规划与分治方法相似，都是通过组合子问题的解来求解待解决的问题。但是，分治算法将问题划分为互不相交的子问题，递归地求解子问题，再将它们的解组合起来，而动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。动态规划方法通常用来求解最优化问题。查看更多关于动态规划的内容

动态规划典型的一个例子是最长公共子序列问题。

常见的算法还有很多，比如贪心算法，回溯算法等等，这里都不再详细介绍，想要熟练掌握，还是要靠刷题，刷题，刷题，然后总结。

五、常见算法题

下面是一些常见的算法题汇总。

不使用临时变量交换两个数

static void funSwapTwo(int a, int b) {

a = a ^ b;
b = b ^ a;
a = a ^ b;

System.out.println(a + <span class="hljs-string">" "</span> + b);

}

判断一个数是否为素数

static boolean funIsPrime(int m) {

<span class="hljs-keyword">boolean</span> flag = <span class="hljs-keyword">true</span>;

<span class="hljs-keyword">if</span> (m == <span class="hljs-number">1</span>) {
    flag = <span class="hljs-keyword">false</span>;
} <span class="hljs-keyword">else</span> {

    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">2</span>; i &lt;= Math.sqrt(m); i++) {
        <span class="hljs-keyword">if</span> (m % i == <span class="hljs-number">0</span>) {
            flag = <span class="hljs-keyword">false</span>;
            <span class="hljs-keyword">break</span>;
        }
    }
}

<span class="hljs-keyword">return</span> flag;

}

其它算法题

1、15道使用频率极高的基础算法题
2、二叉树相关算法题
3、链表相关算法题
4、字符串相关算法问题

六、总结

以上就是自己对常见的算法相关内容的总结，算法虐我千百遍，我待算法如初恋，革命尚未成功，同志仍需刷题，加油。

      </div>
    </div>
</div>
lwx_110
关注
数据结构与算法PPT与知识点整理
12-09
这份"数据结构与算法PPT与知识点整理"涵盖了这两个核心领域的关键概念，为初学者提供了深入学习的平台。 首先，我们要理解数据结构。数据结构是指组织、存储和管理数据的方式，以便于高效地访问和操作。常见的数据...
2021年最新总结 500个常用数据结构，算法，算法导论，面试常用，大厂高级工程师整理总结.zip
06-16
这份“2021年最新总结 500个常用数据结构，算法，算法导论，面试常用，大厂高级工程师整理总结.zip”压缩包文件显然是一个集大成之作，包含了C/C++/JAVA/Python四种主流编程语言的相关学习资源，旨在帮助学生和...
常见的数据结构与算法（下）
Blank的程序员之路
10-18 930
一、概述 二、查找算法 三、排序算法 四、其它算法 五、常见算法题 六、总结 一、概述 以前看到这样一句话，语言只是工具，算法才是程序设计的灵魂。的确，算法在计算机科学中的地位真的很重要，在很多大公司的笔试面试中，算法掌握程度的考察都占据了很大一部分。不管是为了面试还是自身编程能力的提升，花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习总结。 算法简介
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Github近100KJava全栈笔记,学习面试一起抓
2301_79098686的博客
04-28 345
上述知识点，囊括了目前互联网企业的主流应用技术以及能让你成为“香饽饽”的高级架构知识，每个笔记里面几乎都带有实战内容。很多人担心学了容易忘，这里教你一个方法，那就是重复学习。打个比方，假如你正在学习 spring 注解，突然发现了一个注解@Aspect，不知道干什么用的，你可能会去查看源码或者通过博客学习，花了半小时终于弄懂了，下次又看到@Aspect 了，你有点郁闷了，上次好像在哪哪哪学习，你快速打开网页花了五分钟又学会了。从半小时和五分钟的对比中可以发现多学一次就离真正掌握知识又近了一步。
JavaWeb基础教程，JavaWeb从入门到实战
m0_54068390的博客
09-21 899
数据库连接池是个容器，负责分配、管理数据库连接它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接二引起的数据库连接遗漏好处：资源重用提升系统响应速度避免数据库资源遗漏。
前端总结、手写代码、数据结构与算法 Leetcode、源码解析.zip
最新发布
06-17
这份"前端总结、手写代码、数据结构与算法 Leetcode、源码解析.zip"的压缩包文件，显然是一个精心整理的学习资源，旨在帮助开发者深入理解并熟练运用这些关键概念。以下是关于数据结构与算法的一些详细知识： 一、...
小甲鱼数据结构与算法源码.zip
08-01
数据结构与算法是计算机科学的基础，对于理解和解决复杂问题至关重要。小甲鱼数据结构与算法源码库提供了实践这些概念的实例，使学习者能够通过实际编程加深理解。在这个压缩包中，我们可以期待找到一系列用不同编程...
“Java前端基础：探索Web开发的基础知识“
光就是羁绊之力，它会再度被某人继承，散发出耀眼的光。
01-14 1万+
1、Javaweb 1.1 基本概念 web开发： web，代表网页（网站）的意思，比如www.baidu.com 静态web： 列如静态web页面设计使用的：html，css。 静态web性质：提供给所有人看的数据始终不会发生变化。 动态web 比如：淘宝、网易云、几乎所有的网站都使用动态web。 它提供给所有人看到的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同。 技术栈：Servlet/JSP，ASP，PHP。 在Java中，动态web资源开发的技术称为Javaw
web前端学习路线图
02-28
web前端学习路线图
JavaWeb学习路线
weixin_30920091的博客
04-21 164
Web开发也可以理解为B/S(Browser/Server)开发，是一种基于浏览器，不需要安装客户端直接通过浏览器进行操作的程序。 JavaWeb实质上是后端由Java语言实现的Web开发；而前端一般包括HTML,CSS和JavaScript这三大要素，当然也需要bootstrap、Jquery等前端框架，同时数据库可以任选Mysql\SQLserver\Ora...
1.2 Java全栈开发前端+后端（全栈工程师进阶之路）-前置课程JavaScript，看这一篇就够了
明裕学长的博客
04-30 823
上一章我们讲了HTML的知识，那么我们现在要来学习，JavaScript那么首先我们要知道JavaScript写在哪里。
自学Java最简单快速的学习路线图，快速从入门到精通
m0_61408947的博客
04-02 949
现在正是金三银四的春招高潮，前阵子小编一直在搭建自己的网站，并整理了全套的**【一线互联网大厂Java核心面试题库+解析】：包括Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等**
Java程序员需要掌握的前端知识(一)
心向阳光的天域的博客
07-15 721
Java程序员需要掌握的前端知识(一)
转行程序员，最新Java详细学习路线清单，收藏
qq_35254085的博客
12-09 623
最新java详细学习路线，分阶段指引
java大致学习流程（前端知识）
id_yysd的博客
02-09 591
自我学习
前端开始学java_[Java教程]开启前端学习之路
weixin_36219842的博客
03-01 195
[Java教程]开启前端学习之路0 2014-06-10 17:00:06前言第一次在博客园写博客，写写自己开启前端学习之路。应该是受邢师兄的影响吧，不得不说邢师兄人很好，学习也很认真，师兄的前端也是自学的，但是学的很好，大家可以看看我师兄的博客，http://www.cnblogs.com/allenxing/。之前只是听师兄介绍过前端，自己也就慢慢开始学习，师兄说坚持写博客很好，...
八大排序算法原理及实现
a3192048的博客
05-10 7万+
概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。          当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。    快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值