二叉树的一些基础算法

最新推荐文章于 2024-02-14 21:49:57 发布
最新推荐文章于 2024-02-14 21:49:57 发布
阅读量653 收藏
点赞数
分类专栏： .NET 文章标签： 算法 null string list class input
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iwteih/article/details/5404375
版权

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BitTree
{
    //TODO:打印二叉树

    class Constant
    {
        public static readonly string Space = " ";
    }

    class Program
    {
        static void Main(string[] args)
        {
           //" "表示叶子结点

            string preorder = "ABC  DE G  F  ";
            //string preorder = "ABDH  I  EJ  K  CFL   G  ";

            Console.WriteLine("树结点：{0}", preorder);
            BitTree bt = new BitTree(preorder);
            Node root = bt.CreateBitTreePreOrder();

            int width = bt.GetTreeWidth(root);

            Console.WriteLine("树宽：{0}", width);            

            //树高
            int depth = bt.GetTreeDepth(root);
            Console.WriteLine("树高递归算法：{0}", depth);

            depth = bt.GetTreeDepthNoneRecursion(root);
            Console.WriteLine("树高非递归算法：{0}", depth);

            //先序
            Console.WriteLine("先序递归遍历：");
            bt.PreTraverse(root);
            Console.WriteLine();
            Console.WriteLine("先序非递归遍历：");
            bt.PreTraverseNoneRecursion(root);
            Console.WriteLine();

            //中序
            Console.WriteLine("中序递归遍历：");
            bt.MidTraverse(root);
            Console.WriteLine();
            Console.WriteLine("中序非递归遍历：");
            bt.MidTraverseNoneRecursion(root);
            Console.WriteLine();

            //后序
            Console.WriteLine("后序递归遍历：");
            bt.PostTraverse(root);
            Console.WriteLine();

            Console.WriteLine("后序非递归遍历：");
            bt.PostTraverseNoneRecursion(root);
            Console.WriteLine();

            //层次遍历
            Console.WriteLine("层次遍历：");
            bt.TopToBottomReserver(root);
            Console.ReadLine();
        }
    }

    internal class Node
    {
        internal Node Left { get; set; }
        internal Node Right { get; set; }
        internal string Value { get; set; }
    }

    class BitTree
    {
        string inputSequence;

        public BitTree(string input)
        {
            inputSequence = input;
        }

        #region 先序算法
        //先序创建二叉树
        public Node CreateBitTreePreOrder()
        {
            return CreateBitTreePreOrder(null);
        }

        private Node CreateBitTreePreOrder(Node node)
        {
            if (string.IsNullOrEmpty(inputSequence))
            {
                return null;
            }

            string value = inputSequence.Substring(0, 1);
            inputSequence = inputSequence.Substring(1);

            if (string.IsNullOrEmpty(value) || value == Constant.Space)
            {
                return null;
            }

            node = new Node();
            node.Value = value;
            node.Left = CreateBitTreePreOrder(node.Left);
            node.Right = CreateBitTreePreOrder(node.Right);

            return node;
        }

        //先序遍历二叉树，递归
        public void PreTraverse(Node node)
        {
            if (node != null)
            {
                Console.Write(node.Value);
                PreTraverse(node.Left);
                PreTraverse(node.Right);
            }
        }

        //先序遍历二叉树，非递归
        public void PreTraverseNoneRecursion(Node node)
        {
            Stack stack = new Stack();

            while (node != null || stack.Count > 0)//while用的很牛
            {
                if (node != null)//压栈同时访问
                {
                    Console.Write(node.Value);
                    stack.Push(node);
                    node = node.Left;
                }
                else//处理右边
                {
                    node = stack.Pop();
                    node = node.Right;
                }
            }
        }

        #endregion

        #region 中序遍历算法

        //中序不能唯一确定一颗二叉树

        //中序遍历二叉树，递归
        public void MidTraverse(Node node)
        {
            if (node != null)
            {
                MidTraverse(node.Left);
                Console.Write(node.Value);
                MidTraverse(node.Right);
            }
        }

        //中序遍历二叉树，非递归
        public void MidTraverseNoneRecursion(Node node)
        {
            Stack stack = new Stack();

            while (node != null || stack.Count > 0)//while用的很牛
            {
                if (node != null)//压栈
                {
                    stack.Push(node);
                    node = node.Left;
                }
                else//弹出后访问
                {
                    node = stack.Pop();
                    Console.Write(node.Value);
                    node = node.Right;
                }
            }
        }

        #endregion

        #region 后序遍历算法

        //后序遍历二叉树，递归
        public void PostTraverse(Node node)
        {
            if (node != null)
            {
                PostTraverse(node.Left);
                PostTraverse(node.Right);
                Console.Write(node.Value);
            }
        }

        //后序遍历二叉树，非递归
        public void PostTraverseNoneRecursion(Node node)
        {
            Stack stack = new Stack();

            Node lastvisit = node;//最后访问的结点

            while (node != null || stack.Count > 0)
            {
                if (node != null)
                {
                    stack.Push(node);
                    node = node.Left;
                }
                else
                {
                    Node p = stack.Peek();//取而不出

                    //    || (p.Right == lastvisit))//若右边为空，或已经访问过，则返回到父结点
                    if(p.Right == null || p.Right == lastvisit)
                    {
                        stack.Pop();
                        Console.Write(p.Value);
                        lastvisit = p;
                    }
                    else//非叶结点，右边未访问过，访问右边
                    {
                        node = p.Right;
                    }
                }
            }
        }

        #endregion

        #region 层次遍历

        public void TopToBottomReserver(Node node)
        {
            Queue queue = new Queue();

            queue.Enqueue(node);
            while (queue.Count > 0)
            {
                node = queue.Dequeue();

                if (node != null)
                {
                    Console.Write(node.Value);

                    queue.Enqueue(node.Left);
                    queue.Enqueue(node.Right);
                }
            }
        }

        #endregion

        #region 树高
        public int GetTreeDepth(Node node)
        {
            if (node == null)
            {
                return 0;
            }
            else if (node.Left == null && node.Right == null)
            {
                return 1;
            }
            else
            {
                int ldepth = GetTreeDepth(node.Left);
                int rdepth = GetTreeDepth(node.Right);
                return ldepth > rdepth ? 1 + ldepth : 1 + rdepth;
            }
        }

        //方法和遍历一样，用两个int作标记
        public int GetTreeDepthNoneRecursion(Node root)
        {
            int depth = 0;

            Stack stack = new Stack();

            Node lastvisit = root;//最后访问的结点

            while (root != null || stack.Count > 0)
            {
                if (root != null)
                {
                    stack.Push(root);

                    depth = stack.Count > depth ? stack.Count : depth;
                    root = root.Left;
                }
                else
                {
                    Node p = stack.Peek();//取而不出

                    if (p.Right == null || p.Right == lastvisit)
                    {
                        stack.Pop();
                        lastvisit = p;
                    }
                    else//非叶结点，右边未访问过，访问右边
                    {
                        root = p.Right;
                    }
                }
            }

            return depth;
        }
        #endregion

        public int GetTreeWidth(Node root)
        {
            if (root == null)
            {
                return 0;
            }
            else if (root.Left == null && root.Right == null)
            {
                return 1;
            }
            else
            {
                int lwidth = GetTreeWidth(root.Left);
                int rwidth = GetTreeWidth(root.Right);

                return 1 + lwidth - rwidth;
            }
        }

        //返回结点总数
        public int GetNodeCount(Node root)
        {
            if (root == null)
            {
                return 0;
            }
            else if (root.Left == null && root.Right == null)
            {
                return 1;
            }
            else
            {
                int lwidth = GetNodeCount(root.Left);
                int rwidth = GetNodeCount(root.Right);

                return 1 + lwidth + rwidth;
            }
        }

        //得到指定层上所有结点
        private List GetNodeListInDepth(Node root, int depthNum)
        {
            int treeheight = GetTreeDepth(root);

            if (root == null || depthNum > treeheight)
            {
                return new List();
            }

            List sumNode = new List();

            if(depthNum == 1)
            {
                sumNode.Add(root);
                return sumNode;
            }

            Node node = root;

            List lchilrenlist = new List();
            lchilrenlist = GetNodeListInDepth(node.Left, depthNum - 1);

            List rchilrenlist = new List();
            rchilrenlist = GetNodeListInDepth(node.Right, depthNum - 1);

            sumNode.AddRange(lchilrenlist);
            sumNode.AddRange(rchilrenlist);

            return sumNode;
        }

    }
}

iwteih
关注
专栏目录
算法分析之二叉树遍历
小朱小朱绝不认输的博客
12-14 3032
二叉树的基础知识已经在上一篇文章算法分析之二叉树学习过了，这篇文章主要是二叉树的遍历方式，包括递归和迭代版本。 文章目录一、二叉树的遍历二、二叉树的递归遍历1. 二叉树的前序遍历2. 二叉树的中序遍历3. 二叉树的后序遍历三、二叉树的迭代遍历1. 二叉树的前序遍历2. 二叉树的中序遍历3. 二叉树的后序遍历四、二叉树的层序遍历1. 层序遍历的迭代实现2. leetcode关于层序遍历的算法107. 二叉树的层序遍历 II199. 二叉树的右视图 一、二叉树的遍历 二叉树的遍历方式主要有两种： 深度优先遍历
二叉树的基础算法综述
sigd的博客
04-12 1491
二叉树是一种递归定义的数据结构，自然而然地其算法大多也都采用递归的形式。二叉树的基础算法包括且不限于： （1）二叉树的建立 （2）二叉树的三种遍历 （3）二叉树各类结点数计算（度为2,1,0的个数） （4）二叉树的高度 （5）二叉树的宽度 （6）二叉树的直径 （7）二叉树的公共祖先 （8）二叉树的两种遍历序列推出第三种序列 二叉树的这些算法使用的是相同的算法模板，本文将会依次介绍这几种算法的具体写法。 二叉树的二叉链表存储结构定义与基础算法模板： typedef struct B..
详解二叉树经典基础算法
lingxu6的博客
02-17 1412
二叉树是我们平时学习当中一种常见的数据结构。在面试和学习当中我们难免会遇到一些跟二叉树有关的算法题。今天我为大家带来了几题经典的二叉树基础算法题，我们一起来看看吧！ 目录 1.检查两棵树是否相同 ①题目描述 ②思路分析 ③题解代码 2.另一颗树的子树 ①题目描述 ②思路分析 ③题解代码 3.二叉树最大的深度 ①题目描述 ②思路分析 ③题解代码 4.平衡二叉树 ①题目描述 ②思路分析 ③题解代码 5.对称二叉树 ①题目描述 ②思路分析 ③题解代码 6....
二叉树基础算法
weixin_45079974的博客
03-21 875
二叉树基本算法
二叉树的基本算法
weixin_38216573的博客
11-09 1290
二叉树的先序遍历 就是每棵子树，都是先出现头结点、再左子树、再右子树。 递归序列！！！ 一定会到达这个Node节点三次，也表明了有三个位置进行Node数据的处理，前中后 每个节点都是这样。 先序就是第一次到达某个节点就打印 中序就是第二次到达某个节点就打印 后序就是第三次到达某个节点再打印。 二叉树可以先去左边树上转一圈，再回到中间节点，再去右边树上转一圈，可以进行信息的整合。 f(Node) { if(Node==NULL) return; // 1 ...
常见二叉树基础算法汇总
qrlhl的博客
09-18 1380
1、二叉树的深度class Solution { public: int TreeDepth(TreeNode* pRoot) { if(!pRoot){ return 0; } int a = 1+TreeDepth(pRoot->left); int b = 1+TreeDepth(pRoot
算法 - 二叉树的基本算法
weixin_40459875的博客
09-28 6397
目录 一、二叉树 二、二叉树的先序、中序、后序遍历 （一）、递归遍历 （二）、非递归遍历 （1）先序：头左右 （2）中序：左头右 （3）后序：左右头 三、实现二叉树的按层遍历 （一）、遍历-队列 （二）、求最大层的宽度 四、二叉树的序列化和反序列化 （一）、递归 （二）、按层 一、二叉树 图示： 结构： public class BtreeNode { public int value; public BtreeNode left; pub..
遍历二叉树的递归算法
kxbdys的博客
05-04 1597
目录 一、遍历二叉树的相关概念 二、四种遍历二叉树的方式 三、遍历二叉树的算法 四、遍历算法的分析 一、遍历二叉树的相关概念 1、遍历定义:顺着某 一条搜索路径巡访二叉树中的结点，使得每个结点均被访问一次，而且仅被访问一次(又称周游)。“访问”的含义很广，可以是对结点作各种处理，如:输出结点的信息、修改结点的数据值等，但要求这种访问不破坏原来的数据结构。 2、遍历目的:得到树中所有结点的一个线性排列。 3、遍历用途:它是树结构插入、 删除、修改、查找和排序运算的前提，是二叉树...
二叉树算法题汇总
一念永恒
05-19 1万+
目录 二叉树的遍历 前序遍历 中序遍历 后序遍历 层次遍历 基础算法 求二叉树中的节点个数 求二叉树的深度（高度） 求二叉树第k层的节点个数 求二叉树中叶子节点的个数 判断两棵二叉树是否相同的树 判断二叉树是不是平衡二叉树 求二叉树的镜像 判断两个二叉树是否互相镜像 判断是否为二分查找树BST 本文的实例代码基于JAVA编写 首先给出节点的数据结构 publi...
二叉树基础总结
2301_80841939的博客
02-14 2618
树（层级结构）是一种重要的非线性数据结构（递归的数据结构），它由n（n≥0）个有限节点组成一个具有层次关系的集合。这些节点具有如下特性：（在一个有效的树中，如果有n个节点，就会有n-1条边。每个节点有零个或多个子节点。没有父节点的节点称为根节点。根：树的最顶部的节点，唯一没有双亲的节点。每一个非根节点有且只有一个父节点。除了根节点外，每个子节点可以分为多个不相交的子树。树的术语结点：使用树结构存储的每一个数据元素都被称为“结点”。森林：多棵互不相交的树的集合称为森林。
python二叉树基础算法实现.pdf
最新发布
05-07
### Python二叉树基础算法实现详解 #### 一、引言 在计算机科学领域，二叉树是一种重要的数据结构，广泛应用于多种算法和技术之中。它不仅有助于数据的组织与存储，还能有效地支持诸如查找、排序等功能。Python作为...
基础算法-python实现二叉树遍历
11-20
【基础算法】-python实现二叉树遍历 # -*- coding: gb2312 -*- class Queue(object): def __init__(self): self.q = [] def enqueue(self, item): self.q.append(item) def dequeue(self): # if self....
二叉树基础知识和遍历算法等
04-24
### 二叉树基础知识与遍历算法详解 #### 一、二叉树基本概念 **二叉树**是一种特殊的树形结构，在计算机科学领域极为常见。它是一种数据结构，其中每个节点最多有两个子节点，通常被称为左子节点和右子节点。 ###...
二叉树常见的一些操作算法实现
04-06
内容概要：通过c语言以及队列的知识，用c代码完成二叉树的构建、销毁、遍历、高度、密度、添加、删除、查询、求左、求右、求根等操作 ...能学到什么：掌握二叉树的一些常见的基本算法，有助于后续的算法结构学习
二叉树遍历算法
08-04
综上所述，二叉树遍历是理解数据结构和算法的基础，熟练掌握这三种遍历方法对提升编程能力具有重要意义。在`BinaryTreeDemo`这个项目中，你可能会找到关于如何实现这些遍历方法的具体示例代码，进一步加深对二叉树...
C#查找指定窗口的子窗口的句柄
热门推荐
iwteih的专栏
01-15 2万+
用axWebBrowser加载HTML网页时，真正显示内容的窗体并不是axWebBrowser，而是其子窗口的子窗口一个名为Internet Explorer_Server的类。从spy++可知：  公司需要在网页上进行手写，需要对Internet Explorer_Server进行操作，而通过axWebBrowser的Handle不能直接操作Internet Explorer_Serve
C#控制鼠标动作
iwteih的专栏
04-15 7617
可以通过两个函数操作鼠标：[DllImport("user32.dll")] static extern bool SetCursorPos(int X, int Y); [DllImport("user32.dll")] static extern void mouse_event(MouseEventFlag flags, int dx
Object转化成JSON字符串
iwteih的专栏
01-06 6399
有关JSON的介绍，请参见http://www.json.org/json-zh.html对于一个类，其中可能包括field, property，方法不做JSON序列化。我们可以去field和property进行JSON转化。模仿反射中的FieldInfo和PropertyInfo， 两者都继承于MemberInfo，我们定义三个类，用来存储field，property的信息：JsonMember
TransactionScope 之分布式配置
iwteih的专栏
08-25 4466
TransactionScope是个好东西，可以自动管理transaction，即使是对分布式数据库也可以，但是需要一些配置（摸索了2天。。。）， 本文的环境为windows 2003： 1. 对跑代码的机器和sql所在的服务器进行Component Services的配置Administative Tools -> Component Services -> 点开Component
链表、栈与二叉树基础算法详解及操作
本文档详细介绍了计算机科学中常见的数据结构和算法，主要包括链表、栈、队列、递归、排序方法以及...这份文档提供了丰富的数据结构和基础算法知识，有助于程序员深入理解和实现这些核心概念，并在实际项目中灵活运用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值