链与二叉树

最新推荐文章于 2022-08-30 14:52:27 发布

以喻九州

最新推荐文章于 2022-08-30 14:52:27 发布

阅读量199

点赞数

分类专栏： J2EE学习 # 第三章JAVA核心类库文章标签：数据结构

本文链接：https://blog.csdn.net/weixin_43372836/article/details/107330625

版权

J2EE学习同时被 2 个专栏收录

57 篇文章 1 订阅

订阅专栏

第三章JAVA核心类库

9 篇文章 0 订阅

订阅专栏

1.链

1.1 什么是链表？

链表 [Linked List]：链表是由一组不必相连（不必相连：可以连续也可以不连续）的内存结构（节点），按特定的顺序链接在一起的抽象数据类型。

补充：抽象数据类型（Abstract Data Type [ADT]）：表示数学中抽象出来的一些操作的集合。内存结构：内存中的结构，如：struct、特殊内存块...等等之类；

//链表节点
class Node{
    Object date;
    Node next;
}

数组和链表的区别和优缺点：

数组是一种连续存储线性结构，元素类型相同，大小相等

数组的优点：存取速度快

数组的缺点：事先必须知道数组的长度插入删除元素很慢空间通常是有限制的需要大块连续的内存块插入删除元素的效率很低

链表是离散存储线性结构 n 个节点离散分配，彼此通过指针相连，每个节点只有一个前驱节点，每个节点只有一个后续节点，首节点没有前驱节点，尾节点没有后续节点。

链表优点：空间没有限制插入删除元素很快

链表缺点：存取速度很慢

1.2 链表共分几类？

链表常用的有 3 类：单链表、双向链表、循环链表。

链表的核心操作集有 3 种：插入、删除、查找(遍历）

单链表 [Linked List]：

由各个内存结构通过一个 Next 指针链接在一起组成，每一个内存结构都存在后继内存结构(链尾除外），内存结构由数据域和 Next 指针域组成。

解析：

Data 数据 + Next 指针，组成一个单链表的内存结构；第一个内存结构称为链头，最后一个内存结构称为链尾；链尾的 Next 指针设置为 NULL [指向空]；单链表的遍历方向单一（只能从链头一直遍历到链尾）单链表操作集：

双向链表 [Double Linked List]：

由各个内存结构通过指针 Next 和指针 Prev 链接在一起组成，每一个内存结构都存在前驱内存结构和后继内存结构(链头没有前驱，链尾没有后继），内存结构由数据域、Prev 指针域和 Next 指针域组成。

双向链表实现图示：

解析：

Data 数据 + Next 指针 + Prev 指针，组成一个双向链表的内存结构；

第一个内存结构称为链头，最后一个内存结构称为链尾；

链头的 Prev 指针设置为 NULL，链尾的 Next 指针设置为 NULL；

Prev 指向的内存结构称为前驱， Next 指向的内存结构称为后继；

双向链表的遍历是双向的，即如果把从链头的 Next 一直到链尾的[NULL] 遍历方向定义为正向，那么从链尾的 Prev 一直到链头 [NULL ]遍历方向就是反向；

双向链表操作集：

循环链表

单向循环链表 [Circular Linked List] : 由各个内存结构通过一个指针 Next 链接在一起组成，每一个内存结构都存在后继内存结构，内存结构由数据域和 Next 指针域组成。

双向循环链表 [Double Circular Linked List] : 由各个内存结构通过指针 Next 和指针 Prev 链接在一起组成，每一个内存结构都存在前驱内存结构和后继内存结构，内存结构由数据域、Prev 指针域和 Next 指针域组成。

循环链表的单向与双向实现图示：

解析：

循环链表分为单向、双向两种；

单向的实现就是在单链表的基础上，把链尾的 Next 指针直接指向链头，形成一个闭环；

双向的实现就是在双向链表的基础上，把链尾的 Next 指针指向链头，再把链头的 Prev 指针指向链尾，形成一个闭环；

循环链表没有链头和链尾的说法，因为是闭环的，所以每一个内存结构都可以充当链头和链尾；

循环链表操作集

2.二叉树

2.1 什么是二叉树

二叉树是树的一种，每个节点最多可具有两个子树，即结点的度最大为 2（结点度：结点拥有的子树数）。

二叉树就是每个节点不能多于有两个儿子，上面的图就是一颗二叉树，而且还是一种特殊的二叉树：

2.2 二叉查找树(binary search tree)。

定义：当前根节点的左边全部比根节点小，当前根节点的右边全部比根节点大。

一棵树至少会有一个节点(根节点)

树由节点组成，每个节点的数据结构是这样的

因此，我们定义树的时候往往是**->定义节点->节点连接起来就成了树**，而节点的定义就是：一个数据、两个指针(如果有节点就指向节点、没有节点就指向 null)

2.3 二叉树的一些性质

1.二叉树第 i 层上的结点数目最多为 2^(i-1) (i≥1)
2.深度为 h 的二叉树至多有 2^h-1 个结点(h≥1)
3.包含 n 个结点的二叉树的高度至少为 log2 (n+1)
4.在任意一棵二叉树中，若终端结点的个数为 n0，度为 2 的结点数为 n2，则 n0=n2+1

2.4二叉树的遍历方式

二叉树的遍历方式，一般分为先序遍历，中序遍历，后序遍历。

先序遍历 o 先访问根节点，然后访问左节点，最后访问右节点(根->左->右) •

中序遍历 o 先访问左节点，然后访问根节点，最后访问右节点(左->根->右) •

后序遍历 o 先访问左节点，然后访问右节点，最后访问根节点(左->右->根)

先序遍历(根-左-右):1-2-4-8-9-5-10-3-6-7

中序遍历:(左-根-右):8-4-9-2-10-5-1-6-3-7

后序遍历(左-右-根):8-9-4-10-5-2-6-7-3-1

一、前序遍历

　　访问顺序：先根节点，再左子树，最后右子树；上图的访问结果为：GDAFEMHZ。

　　1）递归实现

public void preOrderTraverse1(TreeNode root) {
        if (root != null) {
            System.out.print(root.var + "->");
            preOrderTraverse1(root.left);
            preOrderTraverse1(root.right);
        }
    }

2）非递归实现

public void preOrderTraverse2(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = root;
        while (node != null || !stack.empty()) {
            if (node != null) {
                System.out.print(node.var+ "->");
                stack.push(node);
                node = node.left;
            } else {
                TreeNode tem = stack.pop();
                node = tem.right;
            }
        }
    }

二、中序遍历

　　访问顺序：先左子树，再根节点，最后右子树；上图的访问结果为：ADEFGHMZ。

　　1）递归实现

public void inOrderTraverse(TreeNode root) {
        if (root != null) {
            inOrderTraverse(root.left);
            System.out.print(root.val + "->");
            inOrderTraverse(root.right);
        }
    }

2）非递归实现

public void inOrderTraverse(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = root;
        while (node != null || !stack.isEmpty()) {
            if (node != null) {
                stack.push(node);
                node = node.left;
            } else {
                TreeNode tem = stack.pop();
                System.out.print(tem.val + "->");
                node = tem.right;
            }
        }
    }

三、后序遍历

　　访问顺序：先左子树，再右子树，最后根节点，上图的访问结果为：AEFDHZMG。

　　1）递归实现

public void postOrderTraverse(TreeNode root) {
        if (root != null) {
            postOrderTraverse(root.left);
            postOrderTraverse(root.right);
            System.out.print(root.val + "->");
        }
    }

2）非递归实现

public void postOrderTraverse(TreeNode root) {
        TreeNode cur, pre = null;

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);

        while (!stack.empty()) {
            cur = stack.peek();
            if ((cur.left == null && cur.right == null) || (pre != null && (pre == cur.left || pre == cur.right))) {
                System.out.print(cur.val + "->");
                stack.pop();
                pre = cur;
            } else {
                if (cur.right != null)
                    stack.push(cur.right);
                if (cur.left != null)
                    stack.push(cur.left);
            }
        }
    }

四、层次遍历

　　访问结果：GDMAFHZE。

public void levelOrderTraverse(TreeNode root) {
        if (root == null) {
            return;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            System.out.print(node.val + "->");

            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
    }