常见的数据结构和算法小结

版权声明：本文为博主原创文章，欢迎转载，转载请注明出处。 https://blog.csdn.net/jun5753/article/details/89639665

前言

瑞士计算机科学家Niklaus Wirth在1976年写了一本书，名为《算法+数据结构=编程》。

数据结构和算法 作为程序的内功修炼，重要性可见一斑。

常见的数据结构和算法

上图展示了10个数据和10个算法：

10个数据结构：数组，链表，栈，队列，散列表，二叉树，堆，跳表，图，Trie的树。

10个算法：递归，排序，二分查找，搜索，哈希算法，贪心算法，分治算法，回溯算法，动态规划，字符串匹配算法。

下图为更详细的数据结构和算法思维导图：

以后的学习主线就根据上面两张图中的知识点逐一展开，学无止境。引用胡适的话说就是“怕什么真理无穷，进一寸有一寸的欢喜”。

下面开始主题：

何为数据结构？何为算法？

• 数据结构就是数据的存储方式，比如数组就是把数据存在一段连续的内存上，而链表则是通过指针的关联将数据存在任意可用的内存上；栈是先进后出，队列是先进先出。

• 算法则是对这些数据的操作方法，比如数据的插入、查找、删除、排序等。

• 二者相辅相成，互为一体，数据结构为算法服务，而算法要在指定数据结构上进行操作。

复杂度分析

• 学习数据结构和算法的目的是为了在实际应用的时候更加优化地利用内存，提高程序运行效率，而复杂度分析则是给我们提供一个衡量代码质量好坏的标准。

• 如果我们在不运行程序的情况下就可以定性知道代码的内存占用和时间消耗，这将会给我们提供一个当前程序的总体评估和未来的改进方向。

• 直接运行程序就可以知道算法的执行时间和占用内存，但这个过程往往会受到运行环境和数据规模的影响，因此，我们需要一个不用进行具体测试就可以粗略估计算法执行效率的方法，这就是复杂度分析。

时间复杂度

常用分析方法：

• 循环最多代码，重点关注

• 串行代码，复杂度相加

• 嵌套代码，复杂度相乘

几种常见的复杂度：

• 多项式量级：

  • 常量阶 $O(1)$

  • 对数阶 $O(\log_n)$

  • 线性对数阶 $O(nlog_n)$

  • 乘方阶 $O(n^2)$ 、 $O(n^3)$ 、 $O(n^k)$

• 非多项式量级

  • 指数阶 $O(2^n)$
  • 阶乘阶 $O(n!)$

常见的时间复杂度如下表所示

执行次数函数	阶	非正式术语
$12$	$O(1)$	常数阶
$2n+3$	$O(n)$	线性阶
$3n^2 +2n +1$	$O(n^2)$	平方阶
$5 log_2 n +20$	$O(logn)$	对数阶
$2n + 3n log_2 n +19$	$O(nlogn)$	$nlogn$阶
$6n^3 +2n^2+3n+4$	$O(n^3)$	立方阶
$2^n$	$O(2^n)$	指数阶

所耗费时间从小到大依次是：

$O(1)$ < $O(logn)$ < $O(n)$ < $O(nlogn)$ < $O(n^2)$ < $O(n^3)$ < $O(2^n)$ < $O(n!)$ < $O(n^ n)$

空间复杂度

空间复杂度表明程序占用内存随着数据规模的变化趋势，分析程序中数据的分配空间即可，一般常见的复杂度有

$O(1)$ 、 $O(n)$、 $O(n ^ 2)$

1.线性表

1.1 数组

数组是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。

1.2 链表

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，这些节点不必在内存中相连。每个节点由数据部分Data和链部分Next，Next指向下一个节点，这样当添加或者删除时，只需要改变相关节点的Next的指向，效率很高。

1.2.1 单链表

另一种图示

单链表只支持一个方向的访问，第一个节点称为头结点，最后一个节点称为尾结点。

链表的实现还有其它的方式，常见的有循环单链表，双向链表，循环双向链表。

栈可以用单向链表来实现

1.2.2 循环链表

循环链表是一种特殊的单向链表，其尾结点指向头结点，从链尾访问链头比较方便。

1.2.3 双向链表

双向链表的每一个结点同时指向其前面的结点和其后面的结点，因此可以双向访问，但两个指针要占用更多的内存空间。

在向链表中插入或者删除某个结点时，我们需要知道该结点的前向结点，这时候，双向链表就显示出其优势来了。

应用场景：

• JDK中LinkedList集合类的实现就是双向链表。

• 队列也可以用双向链表来实现。

1.2.4 双向循环链表

1.2.5 跳表(SkipList)

跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。

跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LevelDB中都有用到。

1.2.6 小结

线性表是数据排成像一条线一样的结构。每个线性表上的数据最多只有前和后两个方向。除了数组，链表、队列、栈等也是线性表结构。

与它相对立的是非线性表，比如二叉树、堆、图等。在非线性表中，数据之间并不是简单的前后关系。

1.3 数组和链表的区别

简要概括

• 数组静态分配内存，链表动态分配内存；
• 数组在内存中连续，链表不连续；
• 数组元素在栈区，链表元素在堆区；
• 数组利用下标定位，时间复杂度为 $O(1)$，链表定位元素时间复杂度 $O(n)$ ；
• 数组插入或删除元素的时间复杂度 $O(n)$，链表的时间复杂度 $O(1)$。

2.栈与队列

2.1 栈

栈和队列也是比较常见的数据结构，它们是比较特殊的线性表，因为对于栈来说，访问、插入和删除元素只能在栈顶进行，对于队列来说，元素只能从队列尾插入，从队列头访问和删除。

栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫作栈顶，对栈的基本操作有push(进栈)和pop(出栈)，前者相当于插入，后者相当于删除最后一个元素。栈有时又叫作LIFO(Last In First Out)表，即后进先出。

2.2 队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

2.3 哈希表

哈希表（Hash table，也叫散列表）， 是根据关键码值(Key-value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

哈希（散列）技术既是一种存储方法，也是一种查找方法。然而它与线性表、树、图等结构不同的是，前面几种结构，数据元素之间都存在某种逻辑关系，可以用连线图示表示出来，而哈希技术的记录之间不存在什么逻辑关系，它只与关键字有关联。因此，哈希主要是面向查找的存储结构。哈希技术最适合的求解问题是查找与给定值相等的记录。

3.树与二叉树

树型结构是一类非常重要的非线性数据结构，其中以树和二叉树最为常用。在介绍二叉树之前，我们先简单了解一下树的相关内容。

3.1 树

树的定义：

树（Tree）是由n（n>=0）个节点的有限集。n=0 时称为空树。

它具有以下特点：

• 每个节点有零个或多个子节点；没有父节点的节点称为 根节点；
• 每一个非根节点有且只有一个父节点 ；
• 除了根节点外，每个子节点可以分为多个不相交的子树。

3.2 二叉树

• 定义

二叉树（Binary Tree）是每个节点最多有两棵子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树常被用于实现二叉查找树和二叉堆。

• 相关性质

二叉树的每个结点至多只有2棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。

二叉树的第i层至多有2(i-1)个结点；深度为k的二叉树至多有2k-1个结点。

一棵深度为k，且有 $2^k-1$个节点的二叉树称之为满二叉树 ；

深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中，序号为1至n的节点对应时，称之为完全二叉树 。

• 三种遍历方法

在二叉树的一些应用中，常常要求在树中查找具有某种特征的节点，或者对树中全部节点进行某种处理，这就涉及到二叉树的遍历。二叉树主要是由3个基本单元组成，根节点、左子树和右子树。如果限定先左后右，那么根据这三个部分遍历的顺序不同，可以分为先序遍历、中序遍历和后续遍历三种。

(1) 先序遍历 若二叉树为空，则空操作，否则先访问根节点，再先序遍历左子树，最后先序遍历右子树。

(2) 中序遍历 若二叉树为空，则空操作，否则先中序遍历左子树，再访问根节点，最后中序遍历右子树。

(3) 后序遍历 若二叉树为空，则空操作，否则先后序遍历左子树访问根节点，再后序遍历右子树，最后访问根节点。

• 树和二叉树的区别

(1) 二叉树每个节点最多有2个子节点，树则无限制。

(2) 二叉树中节点的子树分为左子树和右子树，即使某节点只有一棵子树，也要指明该子树是左子树还是右子树，即二叉树是有序的。

(3) 树决不能为空，它至少有一个节点，而一棵二叉树可以是空的。

上面我们主要对二叉树的相关概念进行了介绍，下面我们将从二叉查找树开始，介绍二叉树的几种常见类型，同时将之前的理论部分用代码实现出来。

二叉查找树

• 定义

二叉查找树就是二叉排序树，也叫二叉搜索树。二叉查找树或者是一棵空树，或者是具有下列性质的二叉树：

(1) 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

(2) 若右子树不空，则右子树上所有结点的值均大于它的根结点的值；

(3) 左、右子树也分别为二叉排序树；

(4) 没有键值相等的结点。

典型的二叉查找树的构建过程

• 性能分析

对于二叉查找树来说，当给定值相同但顺序不同时，所构建的二叉查找树形态是不同的，下面看一个例子。

不同形态平衡二叉树的ASL不同

可以看到，含有n个节点的二叉查找树的平均查找长度和树的形态有关。最坏情况下，当先后插入的关键字有序时，构成的二叉查找树蜕变为单支树，树的深度为n，其平均查找长度 $(n+1)/2$(和顺序查找相同），最好的情况是二叉查找树的形态和折半查找的判定树相同，其平均查找长度和 $log2(n)$成正比。平均情况下，二叉查找树的平均查找长度和 $logn$是等数量级的，所以为了获得更好的性能，通常在二叉查找树的构建过程需要进行“平衡化处理”，之后我们将介绍平衡二叉树和红黑树，这些均可以使查找树的高度为 $O(logn)$。

• 二叉树的节点定义代码如下：

//二叉树的节点定义
class TreeNode<E> {

    E element;
    TreeNode<E> left;
    TreeNode<E> right;

    public TreeNode(E e) {
        element = e;
    }
}

二叉查找树的三种遍历都可以直接用递归的方法来实现：

(1) 先序遍历代码如下：

//先序遍历
protected void preorder(TreeNode<E> root) {

    if (root == null)
        return;

    System.out.println(root.element + " ");

    preorder(root.left);

    preorder(root.right);
}

(2) 中序遍历代码如下：

//中序遍历
protected void inorder(TreeNode<E> root) {

    if (root == null)
        return;

    inorder(root.left);

    System.out.println(root.element + " ");

    inorder(root.right);
}

(3)后序遍历代码如下：

//后序遍历
protected void postorder(TreeNode<E> root) {

    if (root == null)
        return;

    postorder(root.left);

    postorder(root.right);

    System.out.println(root.element + " ");
}

二叉查找树的简单实现代码如下：

//二叉查找树的简单实现
public class MyBinSearchTree<E extends Comparable<E>> {

    // 根
    private TreeNode<E> root;

    // 默认构造函数
    public MyBinSearchTree() {
    }

    // 二叉查找树的搜索
    public boolean search(E e) {

        TreeNode<E> current = root;

        while (current != null) {

            if (e.compareTo(current.element) < 0) {
                current = current.left;
            } else if (e.compareTo(current.element) > 0) {
                current = current.right;
            } else {
                return true;
            }
        }

        return false;
    }

    // 二叉查找树的插入
    public boolean insert(E e) {

        // 如果之前是空二叉树 插入的元素就作为根节点
        if (root == null) {
            root = createNewNode(e);
        } else {
            // 否则就从根节点开始遍历 直到找到合适的父节点
            TreeNode<E> parent = null;
            TreeNode<E> current = root;
            while (current != null) {
                if (e.compareTo(current.element) < 0) {
                    parent = current;
                    current = current.left;
                } else if (e.compareTo(current.element) > 0) {
                    parent = current;
                    current = current.right;
                } else {
                    return false;
                }
            }
            // 插入
            if (e.compareTo(parent.element) < 0) {
                parent.left = createNewNode(e);
            } else {
                parent.right = createNewNode(e);
            }
        }
        return true;
    }

    // 创建新的节点
    protected TreeNode<E> createNewNode(E e) {
        return new TreeNode(e);
    }

}

// 二叉树的节点
class TreeNode<E extends Comparable<E>> {

    E element;
    TreeNode<E> left;
    TreeNode<E> right;

    public TreeNode(E e) {
        element = e;
    }
}

上面的代码的主要展示了一个自己实现的简单的二叉查找树，其中包括了几个常见的操作，当然更多的操作还是需要大家自己去完成。因为在二叉查找树中删除节点的操作比较复杂，所以下面我详细介绍一下这里。

• 二叉查找树中删除节点分析

要在二叉查找树中删除一个元素，首先需要定位包含该元素的节点，以及它的父节点。假设current指向二叉查找树中包含该元素的节点，而parent指向current节点的父节点，current节点可能是parent节点的左孩子，也可能是右孩子。这里需要考虑两种情况：

1. current节点没有左孩子，那么只需要将patent节点和current节点的右孩子相连。
2. current节点有一个左孩子，假设rightMost指向包含current节点的左子树中最大元素的节点，而parentOfRightMost指向rightMost节点的父节点。那么先使用rightMost节点中的元素值替换current节点中的元素值，将parentOfRightMost节点和rightMost节点的左孩子相连，然后删除rightMost节点。

    // 二叉搜索树删除节点
    public boolean delete(E e) {

        TreeNode<E> parent = null;
        TreeNode<E> current = root;

        // 找到要删除的节点的位置
        while (current != null) {
            if (e.compareTo(current.element) < 0) {
                parent = current;
                current = current.left;
            } else if (e.compareTo(current.element) > 0) {
                parent = current;
                current = current.right;
            } else {
                break;
            }
        }

        // 没找到要删除的节点
        if (current == null) {
            return false;
        }

        // 考虑第一种情况
        if (current.left == null) {
            if (parent == null) {
                root = current.right;
            } else {
                if (e.compareTo(parent.element) < 0) {
                    parent.left = current.right;
                } else {
                    parent.right = current.right;
                }
            }
        } else { // 考虑第二种情况
            TreeNode<E> parentOfRightMost = current;
            TreeNode<E> rightMost = current.left;
            // 找到左子树中最大的元素节点
            while (rightMost.right != null) {
                parentOfRightMost = rightMost;
                rightMost = rightMost.right;
            }

            // 替换
            current.element = rightMost.element;

            // parentOfRightMost和rightMost左孩子相连
            if (parentOfRightMost.right == rightMost) {
                parentOfRightMost.right = rightMost.left;
            } else {
                parentOfRightMost.left = rightMost.left;
            }
        }

        return true;
    }

3.3平衡二叉树（AVL树）

平衡二叉树又称AVL树，它或者是一棵空树，或者是具有下列性质的二叉树：

它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。

3.4红黑树

红黑树是平衡二叉树的一种，它保证在最坏情况下基本动态集合操作的事件复杂度为 $O(logn)$。

红黑树和平衡二叉树区别如下：

(1) 红黑树放弃了追求完全平衡，追求大致平衡，在与平衡二叉树的时间复杂度相差不大的情况下，保证每次插入最多只需要三次旋转就能达到平衡，实现起来也更为简单。

(2) 平衡二叉树追求绝对平衡，条件比较苛刻，实现起来比较麻烦，每次插入新节点之后需要旋转的次数不能预知。点击查看更多

二叉树应用场景：

• 赫夫曼树
• 文件的压缩和解压缩

3.6 堆

堆是一种特殊的树，只要满足下列两点要求，就符合堆的定义：

• 堆是一棵完全二叉树；
• 堆中的一个节点的值都必须大于等于（或小于等于）其子树中每个节点的值。

堆的三个应用场景：

优先队列、Top K问题以及利用堆求中位数问题等。

4、图

图是一种较线性表和树更为复杂的数据结构，在线性表中，数据元素之间仅有线性关系，在树形结构中，数据元素之间有着明显的层次关系，而在图形结构中，节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。图的应用相当广泛，特别是近年来的迅速发展，已经渗入到诸如语言学、逻辑学、物理、化学、电讯工程、计算机科学以及数学的其他分支中。

5、总结

关于常见的数据结构的整理就结束了。图片大多来源于网络，侵删。如有不足之处，欢迎指正。

下一篇 :七大经典排序算法总结（Java和Kotlin语言实现）

参考资料：

1.常见数据结构与算法整理总结（上）

2.数据结构与算法之美 课程笔记四 数组

3.数据结构基础温故-6.查找（下）：哈希表

4.【数据结构与算法】之散列表（Java实现）—第十篇

5.【数据结构与算法】之堆的详解 — 第十五篇