二叉树,顺序存储二叉树,线索二叉树

最新推荐文章于 2021-10-19 14:00:34 发布
最新推荐文章于 2021-10-19 14:00:34 发布
阅读量215 收藏
点赞数
分类专栏： 数据结构学习笔记 文章标签： 二叉树 算法 数据结构 c# 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FHelloWorld/article/details/109168189
版权

目录

二叉树

介绍

  1. 每个节点最多只能有两个子节点
  2. 子节点分为左子节点和右子节点

遍历

[注]:可以把打印当前节点信息的位置当作一种方法来记忆, 例如先打印当前节点信息然后遍历左右子节点即为前序遍历

结点代码

class Node
{
    public int ID { get; set; }
    public string Name { get; set; }
    public Node Left { get; set; }
    public Node Right { get; set; }

    public Node(int id, string name)
    {
        this.ID = id;
        this.Name = name;
    }

    public override string ToString()
    {
        return $"Node: [ID = {this.ID}, Name = {this.Name}]";
    }
}

前序遍历

static void PreOrder(Node root)
{
    if (root == null)
        return;

    Console.WriteLine(root);
    PreOrder(root.Left);
    PreOrder(root.Right);
}

中序遍历

static void InfixOrder(Node root)
{
    if (root == null)
        return;

    InfixOrder(root.Left);
    Console.WriteLine(root);
    InfixOrder(root.Right);
}

后序遍历

static void PostOrder(Node root)
{
    if (root == null)
        return;

    PostOrder(root.Left);
    PostOrder(root.Right);
    Console.WriteLine(root);
}

查找

查找分为通过前序遍历查找，中序遍历查找，后序遍历查找，思路大致相同
[注]：此代码写在Node的类体中

  1. 判断当前节点是否是带查找节点
  2. 如果是，则返回当前节点
  3. 如果不是，则按前序遍历思路遍历下一节点，继续比对

前序

 public Node PreOrderSearch(int id)
 {
     if (this.ID == id)
         return this;

     Node res = null;
     if (this.Left != null)
         res = this.Left.PreOrderSearch(id);

     //说明在左子树找到
     if (res != null)
         return res;

     if (this.Right != null)
         res = this.Right.PreOrderSearch(id);

     return res;
 }

中序

public Node InfixOrderSearch(int id)
{
    Node res = null;
    if (this.Left != null)
        res = this.Left.InfixOrderSearch(id);
    if (res != null)
        return res;

    if (this.ID == id)
        return this;

    if (this.Right != null)
        res = this.Right.InfixOrderSearch(id);

    return res;
}

后序

public Node PostOrderSearch(int id)
{
    Node res = null;
    if (this.Left != null)
        res = this.Left.PostOrderSearch(id);
    if (res != null)
        return res;

    if (this.Right != null)
        res = this.Right.PostOrderSearch(id);
    if (res != null)
        return res;

    if (this.ID == id)
        return this;

    return null;
}

删除

规定：

  1. 如果删除的节点是叶子节点，则删除该节点
  2. 如果删除的节点是非叶子节点，则删除该子树

思路：

  1. 判断是否为空树，或只有一个root节点
  2. 二叉树是单向的，故实际要找的是待删除节点的父亲节点
  3. 如果当前节点的左子节点是待删除结点，则 this.Left = null
  4. 如果当前节点的右子节点是待删除结点，则 this.Right = null
  5. 如果3，4两步未删除节点，递归左子树 递归右子树

代码

public void Delete(int id)
{
    if (this.Left != null && this.Left.ID == id)
    {
        this.Left = null;
        return;
    }
    if (this.Right != null && this.Right.ID == id)
    {
        this.Right = null;
        return;
    }

    if (this.Left != null)
        this.Left.Delete(id);

    if (this.Right != null)
        this.Right.Delete(id);
}

顺序存储二叉树

介绍

  1. 顺序二叉树通常只考虑完全二叉树
  2. 第n个元素的左子节点为 2n+1
  3. 第n个元素的右子节点为 2n+2
  4. 第n个元素的父亲节点是 (n-1)/2

代码

 class ArrayBinaryTree
 {
     private int[] arr;  //存储节点的数组

     public ArrayBinaryTree(int[] arr)
     {
         this.arr = arr;
     }

     /// <summary>
     /// 
     /// </summary>
     /// <param name="index">数组的下标</param>
     public void PreOrder(int index = 0)
     {
         //如果数组为空或者arr.length == 0
         if (arr == null || arr.Length == 0)
         {
             Console.WriteLine("数组为空");
             return;
         }

         Console.WriteLine(arr[index]);

         //向左递归
         if (index * 2 + 1 < arr.Length)
         {
             PreOrder(2 * index + 1);
         }

         //向右递归
         if (index * 2 + 2 < arr.Length)
         {
             PreOrder(index * 2 + 2);
         }
     }

     public void InfixOrder(int index = 0)
     {
         if (arr == null || arr.Length == 0)
         {
             Console.WriteLine("数组为空");
             return;
         }

         if (2 * index + 1 < arr.Length)
         {
             InfixOrder(2 * index + 1);
         }

         Console.WriteLine(arr[index]);

         if (2 * index + 2 < arr.Length)
         {
             InfixOrder(2 * index + 2);
         }
     }

     public void PostOrder(int index = 0)
     {
         if (arr == null || arr.Length == 0)
         {
             Console.WriteLine("数组为空");
             return;
         }

         if (index * 2 + 1 < arr.Length)
         {
             PostOrder(index * 2 + 1);
         }

         if (index * 2 + 2 < arr.Length)
         {
             PostOrder(index * 2 + 2);
         }

         Console.WriteLine(arr[index]);
     }
 }

线索化二叉树

介绍

  1. n个节点的二叉链表中含有 n+1 个空指针域。利用二叉链表的空指针域，存放指向该节点在某种遍历次序下的前驱和后继节点的指针(这种附加的指针称为“线索”)
    [注]： 二叉树中有n个节点，则有 2n 个指针域。除了根节点外每个节点占一个指针域，故含有 2n-(n-1) = n+1 个空指针域
  2. 这种加上了线索的二叉链表称为线索链表，对应的二叉树称为线索二叉树（Threaded Binarytree) 根据线索性质的不同，线索二叉树可以分为前序线索二叉树，中序线索二叉树和后序线索二叉树三种。

当线索化二叉树后，node节点的属性Left 和Right 有如下情况

  1. Left指向的是左子树，也可能是指向的前驱节点
  2. Right指向的是右子树，也可能是指向后继节点

代码

此时需向Node中添加两个属性 LeftType 和 RightType
//1.如果leftType是0 表示指向的是左子树，如果是1则表示指向前驱节点
//2.如果rightType是0 表示指向的是右子树，如果是1则表示指向后继节点

 class ThreadedBinaryTree
 {
     private Node root;

     //为了实现线索化，需要创建指向当前结点的前驱结点的指针
     private Node pre;
     public Node Root
     {
         set { root = value; }
     }

     public void ThreadNodes()
     {
         this.ThreadNodes(root);
     }

     //遍历线索化二叉树
     public void TraverseThreadedTree()
     {
         Node node = root;
         while (node != null)
         {
             //循环找到leftType == 1 的结点
             while (node.LeftType == 0)
             {
                 node = node.Left;
             }

             //打印当前节点
             Console.WriteLine(node);

             //如果当前结点的右指针指向后继结点，就一直输出
             while (node.RightType == 1)
             {
                 node = node.Right;
                 Console.WriteLine(node);
             }

             //替换遍历的结点
             node = node.Right;
         }
     }

     /// <summary>
     /// 
     /// </summary>
     /// <param name="node">线索化当前结点</param>
     public void ThreadNodes(Node node)
     {
         if (node == null)
             return;

         //(1) 线索化左子树
         ThreadNodes(node.Left);

         //(2) 线索化当前结点
         //处理当前结点的前驱
         if (node.Left == null)
         {
             //让当前结点的左指针指向前驱结点，并修改leftType
             node.Left = pre;
             node.LeftType = 1;
         }

         //处理后继结点
         if (pre != null && pre.Right == null)
         {
             pre.Right = node;
             pre.RightType = 1;
         }
         //后移pre
         pre = node;


         //(3) 线索化右子树
         ThreadNodes(node.Right);
     }

    
 }

补充全部代码

二叉树

using System;

namespace DeleteMethod
{
    class Program
    {
        static void Main(string[] args)
        {
            BinaryTree binaryTree = new BinaryTree();
            Node node1 = new Node(1, "Roy");
            Node node2 = new Node(2, "Summy");
            Node node3 = new Node(3, "Shane");
            Node node4 = new Node(4, "mezz");

            node1.Left = node2;
            node1.Right = node3;
            node3.Right = node4;

            binaryTree.Root = node1;

            Console.WriteLine("删除前");
            binaryTree.PreOrder();

            Console.WriteLine("\n\n");
            Console.WriteLine("删除后");
            binaryTree.Delete(4);
            binaryTree.PreOrder();

        }
    }

    class Node
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public Node Left { get; set; }
        public Node Right { get; set; }

        public Node(int id, string name)
        {
            this.ID = id;
            this.Name = name;
        }

        public void PreOrder()
        {
            Console.WriteLine(this);
            if (this.Left != null)
                this.Left.PreOrder();
            if (this.Right != null)
                this.Right.PreOrder();
        }

        public void InfixOrder()
        {
            if (this.Left != null)
                this.Left.InfixOrder();
            Console.WriteLine(this);
            if (this.Right != null)
                this.Right.InfixOrder();
        }

        public void PostOrder()
        {
            if (this.Left != null)
                this.Left.PostOrder();
            if (this.Right != null)
                this.Right.PostOrder();
            Console.WriteLine(this);
        }

        public Node PreOrderSearch(int id)
        {
            if (this.ID == id)
                return this;

            Node res = null;
            if (this.Left != null)
                res = this.Left.PreOrderSearch(id);

            //说明在左子树找到
            if (res != null)
                return res;

            if (this.Right != null)
                res = this.Right.PreOrderSearch(id);

            return res;
        }

        public Node InfixOrderSearch(int id)
        {
            Node res = null;
            if (this.Left != null)
                res = this.Left.InfixOrderSearch(id);
            if (res != null)
                return res;

            if (this.ID == id)
                return this;

            if (this.Right != null)
                res = this.Right.InfixOrderSearch(id);

            return res;
        }

        public Node PostOrderSearch(int id)
        {
            Node res = null;
            if (this.Left != null)
                res = this.Left.PostOrderSearch(id);
            if (res != null)
                return res;

            if (this.Right != null)
                res = this.Right.PostOrderSearch(id);
            if (res != null)
                return res;

            if (this.ID == id)
                return this;

            return null;
        }

        public void Delete(int id)
        {
            if (this.Left != null && this.Left.ID == id)
            {
                this.Left = null;
                return;
            }
            if (this.Right != null && this.Right.ID == id)
            {
                this.Right = null;
                return;
            }

            if (this.Left != null)
                this.Left.Delete(id);

            if (this.Right != null)
                this.Right.Delete(id);


        }

        public override string ToString()
        {
            return $"Node [ID = {ID}, Name = {Name}].";
        }
    }

    class BinaryTree
    {
        private Node root;

        public Node Root
        {
            set { root = value; }
        }

        public void PreOrder()
        {
            if (this.root != null)
                this.root.PreOrder();
            else
                Console.WriteLine("二叉树为空");
        }

        public void InfixOrder()
        {
            if (this.root != null)
                this.root.InfixOrder();
            else
                Console.WriteLine("二叉树为空");
        }

        public void PostOrder()
        {
            if (this.root != null)
                this.root.PostOrder();
            else
                Console.WriteLine("二叉树为空");
        }

        public Node PreOrderSearch(int id)
        {
            if (root != null)
                return root.PreOrderSearch(id);
            return null;
        }

        public Node InfixOrderSearch(int id)
        {
            if (root != null)
                return root.InfixOrderSearch(id);
            return null;
        }

        public Node PostOrderSearch(int id)
        {
            if (root != null)
                return root.PostOrderSearch(id);
            return null;
        }

        public void Delete(int id)
        {
            if (root != null)
            {
                if (root.ID == id)
                    root = null;
                else
                    root.Delete(id);
            }
            else
                Console.WriteLine("树为空,无法删除");
        }
    }
}

顺序存储二叉树

using System;

namespace ArrBinaryTree
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
            ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(arr);
            arrayBinaryTree.PreOrder();
            Console.WriteLine();
            arrayBinaryTree.InfixOrder();
            Console.WriteLine();
            arrayBinaryTree.PostOrder();
        }
    }

    class ArrayBinaryTree
    {
        private int[] arr;  //存储节点的数组

        public ArrayBinaryTree(int[] arr)
        {
            this.arr = arr;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="index">数组的下标</param>
        public void PreOrder(int index = 0)
        {
            //如果数组为空或者arr.length == 0
            if (arr == null || arr.Length == 0)
            {
                Console.WriteLine("数组为空");
                return;
            }

            Console.WriteLine(arr[index]);

            //向左递归
            if (index * 2 + 1 < arr.Length)
            {
                PreOrder(2 * index + 1);
            }

            //向右递归
            if (index * 2 + 2 < arr.Length)
            {
                PreOrder(index * 2 + 2);
            }
        }

        public void InfixOrder(int index = 0)
        {
            if (arr == null || arr.Length == 0)
            {
                Console.WriteLine("数组为空");
                return;
            }

            if (2 * index + 1 < arr.Length)
            {
                InfixOrder(2 * index + 1);
            }

            Console.WriteLine(arr[index]);

            if (2 * index + 2 < arr.Length)
            {
                InfixOrder(2 * index + 2);
            }
        }

        public void PostOrder(int index = 0)
        {
            if (arr == null || arr.Length == 0)
            {
                Console.WriteLine("数组为空");
                return;
            }

            if (index * 2 + 1 < arr.Length)
            {
                PostOrder(index * 2 + 1);
            }

            if (index * 2 + 2 < arr.Length)
            {
                PostOrder(index * 2 + 2);
            }

            Console.WriteLine(arr[index]);
        }
    }
}

线索二叉树

using System;

namespace ThreadedBinaryTreeDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Node root = new Node(1, "Roy");
            Node node2 = new Node(3, "Jack");
            Node node3 = new Node(6, "Smith");
            Node node4 = new Node(8, "Mary");
            Node node5 = new Node(10, "Tim");
            Node node6 = new Node(14, "Summy");

            root.Left = node2;
            root.Right = node3;
            node2.Left = node4;
            node2.Right = node5;
            node3.Left = node6;

            ThreadedBinaryTree tree = new ThreadedBinaryTree();
            tree.Root = root;

            tree.ThreadNodes();

            tree.TraverseThreadedTree();

        }
    }

    class Node
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public Node Left { get; set; }
        public Node Right { get; set; }
        //说明：
        //1.如果leftType是0 表示指向的是左子树，如果是1则表示指向前驱节点
        //2.如果rightType是0 表示指向的是右子树，如果是1则表示指向后继节点
        public int LeftType { get; set; }
        public int RightType { get; set; }

        public Node(int id, string name)
        {
            this.ID = id;
            this.Name = name;
        }

        public void PreOrder()
        {
            Console.WriteLine(this);
            if (this.Left != null)
                this.Left.PreOrder();
            if (this.Right != null)
                this.Right.PreOrder();
        }

        public void InfixOrder()
        {
            if (this.Left != null)
                this.Left.InfixOrder();
            Console.WriteLine(this);
            if (this.Right != null)
                this.Right.InfixOrder();
        }

        public void PostOrder()
        {
            if (this.Left != null)
                this.Left.PostOrder();
            if (this.Right != null)
                this.Right.PostOrder();
            Console.WriteLine(this);
        }

        public Node PreOrderSearch(int id)
        {
            if (this.ID == id)
                return this;

            Node res = null;
            if (this.Left != null)
                res = this.Left.PreOrderSearch(id);

            //说明在左子树找到
            if (res != null)
                return res;

            if (this.Right != null)
                res = this.Right.PreOrderSearch(id);

            return res;
        }

        public Node InfixOrderSearch(int id)
        {
            Node res = null;
            if (this.Left != null)
                res = this.Left.InfixOrderSearch(id);
            if (res != null)
                return res;

            if (this.ID == id)
                return this;

            if (this.Right != null)
                res = this.Right.InfixOrderSearch(id);

            return res;
        }

        public Node PostOrderSearch(int id)
        {
            Node res = null;
            if (this.Left != null)
                res = this.Left.PostOrderSearch(id);
            if (res != null)
                return res;

            if (this.Right != null)
                res = this.Right.PostOrderSearch(id);
            if (res != null)
                return res;

            if (this.ID == id)
                return this;

            return null;
        }

        public void Delete(int id)
        {
            if (this.Left != null && this.Left.ID == id)
            {
                this.Left = null;
                return;
            }
            if (this.Right != null && this.Right.ID == id)
            {
                this.Right = null;
                return;
            }

            if (this.Left != null)
                this.Left.Delete(id);

            if (this.Right != null)
                this.Right.Delete(id);
        }

        public override string ToString()
        {
            return $"Node [ID = {ID}, Name = {Name}].";
        }
    }

    class ThreadedBinaryTree
    {
        private Node root;

        //为了实现线索化，需要创建指向当前结点的前驱结点的指针
        private Node pre;
        public Node Root
        {
            set { root = value; }
        }

        public void ThreadNodes()
        {
            this.ThreadNodes(root);
        }

        //遍历线索化二叉树
        public void TraverseThreadedTree()
        {
            Node node = root;
            while (node != null)
            {
                //循环找到leftType == 1 的结点
                while (node.LeftType == 0)
                {
                    node = node.Left;
                }

                //打印当前节点
                Console.WriteLine(node);

                //如果当前结点的右指针指向后继结点，就一直输出
                while (node.RightType == 1)
                {
                    node = node.Right;
                    Console.WriteLine(node);
                }

                //替换遍历的结点
                node = node.Right;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="node">线索化当前结点</param>
        public void ThreadNodes(Node node)
        {
            if (node == null)
                return;

            //(1) 线索化左子树
            ThreadNodes(node.Left);

            //(2) 线索化当前结点
            //处理当前结点的前驱
            if (node.Left == null)
            {
                //让当前结点的左指针指向前驱结点，并修改leftType
                node.Left = pre;
                node.LeftType = 1;
            }

            //处理后继结点
            if (pre != null && pre.Right == null)
            {
                pre.Right = node;
                pre.RightType = 1;
            }
            //后移pre
            pre = node;


            //(3) 线索化右子树
            ThreadNodes(node.Right);
        }

        public void PreOrder()
        {
            if (this.root != null)
                this.root.PreOrder();
            else
                Console.WriteLine("二叉树为空");
        }

        public void InfixOrder()
        {
            if (this.root != null)
                this.root.InfixOrder();
            else
                Console.WriteLine("二叉树为空");
        }

        public void PostOrder()
        {
            if (this.root != null)
                this.root.PostOrder();
            else
                Console.WriteLine("二叉树为空");
        }

        public Node PreOrderSearch(int id)
        {
            if (root != null)
                return root.PreOrderSearch(id);
            return null;
        }

        public Node InfixOrderSearch(int id)
        {
            if (root != null)
                return root.InfixOrderSearch(id);
            return null;
        }

        public Node PostOrderSearch(int id)
        {
            if (root != null)
                return root.PostOrderSearch(id);
            return null;
        }

        public void Delete(int id)
        {
            if (root != null)
            {
                if (root.ID == id)
                    root = null;
                else
                    root.Delete(id);
            }
            else
                Console.WriteLine("树为空,无法删除");
        }
    }

}
Roy Summy
关注
专栏目录
二叉树顺序存储与线索二叉树
Zllvincent的博客
06-01 1023
一.顺序存储二叉树 将二叉树存储在一个数组中，通过存储元素的下标反映元素之间的父子关系。 按照二叉树结点自上向下、自左向右的顺序存储。使用此存储方式，结点的前驱和后继不一定是它们在逻辑上的邻接关系，非常适用于满二又树和完全二又树。 顺序存储到数组中父节点与左右节点索引关系： 二.线索化二叉树 对于二叉链表，不管二叉树的形态如何，n个结点的二叉链表共有2n个链域，非空链域为n-1个(从根节点开始一个指针链接一个节点)，故其中的空链域有n+1个。 为提高空指针利用率提出了一种方法，利用原来的空链域存放指针，
二叉树（顺序存储二叉树，线索化二叉树）
笔记别偷看
10-29 1319
顺序存储二叉树 顺序存储二叉树的概念 a.基本说明 从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组，看下面的示意图。 b. 要求: 右图的二叉树的结点，要求以数组的方式来存放arr : [1, 2, 3, 4, 5, 6, 6] 要求在遍历数组arr 时，仍然可以以前序遍历，中序遍历和后序遍历的方式完成结点的遍历 c.顺序存储二叉树的特点: 顺序二叉树通常只考虑完全二叉树 第n 个元素的左子节点为2 * n + 1 第n 个元素的右子节点为2 * n
数据结构—二叉树的顺序存储结构
qq_43627079的博客
11-24 3292
二叉树的顺序存储结构 二叉树的顺序存储结构就是用一维数组存储二叉树中的节点，并且节点的存储位置（下标）应能体现节点之间的逻辑关系——父子关系。 普通二叉树需按照完全二叉树的编号方式编号,然后以完全二叉树的形式存储到一维数组中,造成很多浪费,故二叉树的顺序存储结构一般仅存储完全二叉树. 二叉树的链式存储表示 二叉链表 基本思想 令二叉树的每个节点对应一个链表节点，链表节点除了存放与二叉树节点有关的数...
二叉树的顺序存储结构
热门推荐
qq_44111805的博客
02-05 1万+
一、顺序存储结构 二叉树的顺序存储结构是指用一组地址连续的存储单元依次自上而下、自左至右存储完全二叉树上的结点元素，即将完全二叉树上编号为 i 的结点元素存储在一维数组下标为 i-1 的分量中。 依据二叉树的性质，完全二叉树和满二叉树采用顺序存储比较合适，树中结点的序号可以唯一地反映结点之间的逻辑关系，这样既能最大地节省存储了空间，又能利用数组元素的下标值确定结点在二叉树中的位置，以及结点之间的关系。 从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树可以转换成数组。 二、顺序存
课堂笔记：二叉树的存储结构及实现
qq_43628959的博客
11-17 486
顺序存储结构 二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置（下标）应能体现结点之间的逻辑关系——父子关系。 ...
头歌数据结构二叉树的顺序存储及基本操作
05-18
总的来说，顺序存储的二叉树是一种简化了内存管理的数据结构，适用于静态二叉树或已知结构的二叉树，它可以简化存储和遍历操作，但灵活性较低。在实际应用中，我们还需要考虑其他存储方式，如链式存储，以适应更复杂...
Python实现顺序存储二叉树 顺序存储二叉树的遍历
storyfull
12-28 1476
Python实现顺序存储二叉树 顺序存储二叉树的遍历
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
先序线索二叉树、中序线索二叉树和后序线索二叉树
最新发布
01-01
对先序线索二叉树、中序线索二叉树和后序线索二叉树进行了 C 语言实现，主要包括线索二叉树的建立和遍历过程。
数据结构-二叉树的顺序存储
weixin_45599288的博客
09-13 3292
二叉树的顺序存储二叉树的概念及结构二叉树的性质顺序存储堆的初始化 二叉树的概念及结构 概念 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树 的二叉树组成。 二叉树的特点： 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。 二叉树的子树有左右之分，其子树的次序不能颠倒。 现实中的二叉树 数据结构中的二叉树 3.特殊的二叉树 3.1满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结
二叉树的存储结构
xuechanba的博客
10-19 491
本文部分图片截取自B站懒猫老师。 视频链接为：https://www.bilibili.com/video/BV1Gz411b7Rq?spm_id_from=333.999.0.0. 二叉树的存储结构 顺序存储结构 看下图 1、完全二叉树的顺序存储 2、一般二叉树的顺序存储 看上图中的编号是否有些迷惑，注意细节，这个是按照完成二叉树编号来进行的。 如下图的右斜树所示。 如果我们也按照完成二叉树编号的方式进行呢？ 这样势必会造成存储空间的浪费。 所以 二叉链表 ...
二叉树的顺序存储
keven03的博客
11-06 7670
二叉树的顺序存储： 二叉树是一种常用的树结构，它是树结构的另一种重要类型，其特征是树中每个结点最多有两个子树。 要存储一颗二叉树，必须存储其所有结点的数据信息，左孩子和右孩子地址，即可用顺序结构存储，也可以链接结构存储。 二叉树的顺序存储是指将二叉树中所有结点按层次顺序存放在一块地址连续的存储空间中，同时反映出二叉树中结点间的逻辑关系。 对于完全二叉树，结点的层次顺序反映了其结构，可按层次顺序给出一颗完全二叉树之结点的编号。对于下面这棵二叉树，其中A[1]存储该二叉树的根结点，A[i]存储二叉树中.
树结构_二叉树基础，顺序存储二叉树，线索化二叉树
泥煤少年的博客
07-24 441
目录 【树结构】 【二叉树基础】 简易二叉树 顺序存储二叉树 线索化二叉树 【树结构】 数组下标查找数据速度很快，但插入数据需要拷贝数组，数组扩容，数据全体向后移动，所以插入数据效率低下。 链表在插入方面表现优良，但查找数据仍要遍历这个链表，查找效率低下。 哈希表（散列表）hash表其实是结合了数组和链表的优点，进行的折中方案。平衡了数组和链表的优缺点。但其存在哈希关键值的冲突（两个以上数据经过哈希运算得到了同一个哈希值），此时要采取方案，如：数组+链表 的形式处理冲突。且哈希表数组长度.
二叉树(二) -- 二叉树的顺序存储
JeremyIverson的博客
02-26 606
1.顺序存储二叉树 1.1 顺序存储二叉树的概念 从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组， 看下面的示意图 要求: 上图的二叉树的结点，要求以数组的方式来存放 arr : [1, 2, 3, 4, 5, 6, 6] 要求在遍历数组 arr 时，仍然可以以前序遍历，中序遍历和后序遍历的方式完成结点的遍历 由上图可知顺序存储二叉树的特点...
树和二叉树：二叉树的存储结构
weixin_51958878的博客
06-02 2282
树和二叉树：二叉树的存储结构 二叉树的顺序存储结构 回顾二叉树的性质4，完全二叉树节点按层序编号： 完全二叉树的顺序存储结构 非完全二叉树的顺序存储结构 二叉树顺序存储结构的特点： 对于完全二叉树来说，其顺序存储是十分合适的 对于一般的二叉树，特别是对于那些单分支节点较多的二叉树来说是很不合适的，因为可能只有少数存储单元被利用，特别是对退化的二叉树（即每个分支节点都是单分支的），空间浪费更是惊人 在顺序存储结构中，找一个节点的双亲和孩子都很容易 二叉树的链式存储结构 借鉴树的孩子链存储结构 - 二
C#实现队列及环形队列(数组)
RoySummy的博客
09-04 2840
队列(Queue) 介绍 队列是一种有序列表，只允许对队尾(rear)进行删除操作，对队首(front)进行删除操作，即先入先出(FIFO)。 实现队列需要的内部元素 元素 含义 maxSize 代表能够存储的数据的个数 front 指向队首 rear 指向队尾 array[] 用于存储数据 void Enqueue(int n) 将元素n入队 int Dequeue() 将队尾元素出队，同时元素个数-1 int Peek() 返回队尾元素，元素个数不变 bool
c# 实现栈
RoySummy的博客
09-09 1474
栈 目录栈简要介绍图解内部成员成员代码构造器IsFullIsEmptyPush(int value)Pop()Peek()完整代码补充(链表实现栈)尾插法单链表实现栈头插法单链表实现栈 简要介绍 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。 允许插入和删除的一端称为栈顶。 另一端为固定的一端，称作栈底。 遵循先入后出(FILO)的原则 图解 内部成员 [注]本例使用数组存储数据，链表实现栈代码在最后 修饰符 变量名 含义 private int top 指
线索二叉树的存储结构与遍历
"线索二叉树是二叉树的一种特殊存储结构，通过在二叉链表的空链域中添加线索来记录节点的前驱和后继信息，使得在遍历时可以直接获取这些关系，而无需动态查找。线索二叉树包含两个额外的标志字段LTag和RTag，用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值