二叉树及其实例 三 ( Binary Tree c.)

最新推荐文章于 2024-07-20 22:34:59 发布
最新推荐文章于 2024-07-20 22:34:59 发布
阅读量87 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/netfuns/archive/2011/07/29/2120953.html
版权

表达式求值

1. 验证字符串为表达式

2.分拆表达式为操作符，操作数，括号

       确定操作符是二元或一元操作符

3.将操作符序列建立二叉树

4.对二叉树进行求值

    叶子节点为操作数，父节点为操作符，递归求值

 

Test ：

[TestMethod()]
       public void CalculateTest()
       {
           BinTree<string> target = new BinTree<string>(); // TODO: Initialize to an appropriate value
           string src = "";

           double actual;
           double a;
         

           src = "-1.1+-2.2+3.3";
           a = -1.1+-2.2+3.3;
           actual = target.Calculate(src);
           Assert.IsTrue(Math.Abs(actual - a) < 0.001);

           src = "1+2 * 3 - -(-(3 + 2 - 4 * (2 + 5 + 3)))";
           a = 1 + 2 * 3 - -(-(3 + 2 - 4 * (2 + 5 + 3)));
           actual = target.Calculate(src);
          
           Assert.IsTrue(Math.Abs(actual - a) < 0.001);

           src = "-1.1--2.2";
           a = -1.1-(-2.2);
           actual = target.Calculate(src);
           Assert.IsTrue(Math.Abs(actual - a) < 0.001);

           src = "10.999+201*30--400*(5+60)+700.0/3+4%2 ";
               //"10.999+201*30--400*(5+60)+700/3+4%2";
           a = 10.999 + 201 * 30 - (-400 * (5 + 60)) + 700.0/3  + 4 % 2;
           actual = target.Calculate(src);
           Assert.IsTrue(Math.Abs(actual - a) < 0.001);

           src = "700.0/3+(-1.1)";           
           a = 700.0/ 3+(-1.1);
           actual = target.Calculate(src);
           Assert.IsTrue(Math.Abs(actual - a) < 0.001);

           src = "";
           a = 0;
           actual = target.Calculate(src);
           Assert.IsTrue(Math.Abs(actual - a) < 0.001);

           //not support number type ,treat all item as double
           //src = "10.999+201*30--400*(5+60)+7000/3+4%2 ";           
           //a = 10.999 + 201 * 30 - (-400 * (5 + 60)) + 7000 / 3 + 4 % 2;
           //actual = target.Calculate(src);
           //Assert.IsTrue(Math.Abs(actual - a) < 0.001);
       }

 

实现

public List<ExpressionItem> SpliteExpression(string src)
      {
          src = src.Replace(" ", "");
          List<ExpressionItem> ret = new List<ExpressionItem>();
          StringBuilder sb = new StringBuilder();

          StringReader sr = new StringReader(src);
          int val = sr.Read();

          ExpressionCellType currentType = ExpressionCellType.Unkown;
          ExpressionCellType nextType = ExpressionCellType.Unkown;
          ExpressionCellType prevType = ExpressionCellType.Unkown;

          while (val > 0)
          {
              char c = (char)val;

              sb.Append(c);
              currentType = GetExpressionItemType(sb.ToString());

              int nextVal = sr.Peek();
              char nextChar = (char)nextVal;
              string nextString = nextChar.ToString();
              nextType = GetExpressionItemType(nextString);

              if (IsOperand(sb.ToString() + nextString))
              {
                  nextType = ExpressionCellType.Operand;
              }

              if (nextType != currentType
                  ||
                  (
                   currentType == nextType
                   && currentType == ExpressionCellType.Operator
                  )
                )
              {
                  ExpressionItem item = new ExpressionItem();

                  item.Value = sb.ToString();
                  item.CellType = currentType;

                  if (currentType == ExpressionCellType.Operator)
                  {
                      item.CombineType = OperatorCombineType.Two;
                      if (prevType == ExpressionCellType.Unkown
                          || prevType == ExpressionCellType.Operator)
                      {
                          if (item.Value == "("
                              || item.Value == ")"
                              )
                          {
                              item.CombineType = OperatorCombineType.Bracket;
                          }
                          else if (item.Value == "-")
                          {
                              item.CombineType = OperatorCombineType.One;
                          }
                      }

                  }

                  prevType = currentType;
                  ret.Add(item);
                  sb.Clear();
              }

              val = sr.Read();
          }

          return ret;
      }

public Int32 GetPriority(ExpressionItem item)
      {
          Int32 priority = -1;

          if (item.CombineType == OperatorCombineType.One)
          {
              priority += 100;
          }
          else if (item.CombineType == OperatorCombineType.Two)
          {
              if ("+-".IndexOf(item.Value) > -1)
              {
                  priority += 5;
              }
              else if ("*/%".IndexOf(item.Value) > -1)
              {
                  priority += 10;
              }
          }

          return priority;
      }

 

private ExpressionCellType GetExpressionItemType(string p)
       {
           if (IsOperand(p))
           {
               return ExpressionCellType.Operand;
           }
           else if (IsOperator(p))
           {
               return ExpressionCellType.Operator;
           }
           else
           {
               return ExpressionCellType.Unkown;
           }
       }

public bool IsOperand(string src)
      {
          double d;
          bool result = double.TryParse(src, out d);

          return result;

      }

      public bool IsOperator(string src)
      {
          if (src == null)
          {
              return false;
          }

          if (src.Equals("+", StringComparison.OrdinalIgnoreCase)
              || src.Equals("-", StringComparison.OrdinalIgnoreCase)
              || src.Equals("*", StringComparison.OrdinalIgnoreCase)
              || src.Equals("/", StringComparison.OrdinalIgnoreCase)
              || src.Equals("%", StringComparison.OrdinalIgnoreCase)
              || src.Equals("(", StringComparison.OrdinalIgnoreCase)
              || src.Equals(")", StringComparison.OrdinalIgnoreCase)
              // || src.Equals("-(", StringComparison.OrdinalIgnoreCase)
              )
          {
              return true;
          }

          else
          {
              return false;
          }

      }

 

/// <summary>
      /// support unary operator
      /// </summary>
      /// <param name="expressionString"></param>
      /// <returns></returns>
      public BinTree<ExpressionItem> Expression2Bintree2(string expressionString)
      {
          List<ExpressionItem> items = SpliteExpression(expressionString);

          if (items == null || items.Count == 0)
          {
              return null;
          }

          BinTree<ExpressionItem> result = new BinTree<ExpressionItem>();
          BinTreeNode<ExpressionItem> parent = null;

          Stack<BinTreeNode<ExpressionItem>> operators = new Stack<BinTreeNode<ExpressionItem>>();
          Stack<BinTreeNode<ExpressionItem>> operands = new Stack<BinTreeNode<ExpressionItem>>();
          int i = 0;
          while (i < items.Count)
          {
              ExpressionItem item = items[i];
              BinTreeNode<ExpressionItem> itemNode = new BinTreeNode<ExpressionItem>();
              itemNode.Value = item;

              if (item.CellType == ExpressionCellType.Operand)
              {
                  operands.Push(itemNode);
              }
              else if (item.CellType == ExpressionCellType.Operator)
              {
                  if (item.Value == "("
                      )
                  {
                      operators.Push(itemNode);
                  }
                  else if (item.Value == ")")
                  {
                      //collapse untill (
                      //todo
                      bool notReachPrevBracket = true;
                      do
                      {
                          parent = operators.Pop();
                          if (parent.Value.CombineType == OperatorCombineType.Two)
                          {
                              BinTreeNode<ExpressionItem> oprand2 = operands.Pop();
                              BinTreeNode<ExpressionItem> oprand1 = operands.Pop();
                              parent.LeftChild = oprand1;
                              parent.RightChild = oprand2;
                          }
                          else if (parent.Value.CombineType == OperatorCombineType.One)
                          {
                              BinTreeNode<ExpressionItem> oprand1 = operands.Pop();
                              parent.LeftChild = oprand1;
                          }

                          operands.Push(parent);

                          if (operators.Count > 0)
                          {
                              BinTreeNode<ExpressionItem> prevNode = operators.Peek();//"("
                              if (prevNode.Value.Value == "("
                                  )
                              {
                                  notReachPrevBracket = false;
                                  operators.Pop();
                              }
                          }

                      } while (notReachPrevBracket && operators.Count > 0);
                  }
                  else
                  {
                      //while

                      while (operators.Count > 0
                            &&
                            (
                              GetPriority(item) <=
                              GetPriority(operators.Peek().Value)
                              )
                          )
                      {
                          parent = operators.Pop();
                          if (parent.Value.CombineType == OperatorCombineType.Two)
                          {
                              BinTreeNode<ExpressionItem> oprand2 = operands.Pop();
                              BinTreeNode<ExpressionItem> oprand1 = operands.Pop();
                              parent.LeftChild = oprand1;
                              parent.RightChild = oprand2;

                          }
                          else if (parent.Value.CombineType == OperatorCombineType.One)
                          {
                              BinTreeNode<ExpressionItem> oprand1 = operands.Pop();
                              parent.LeftChild = oprand1;
                          }

                          operands.Push(parent);
                      }

                      operators.Push(itemNode);
                  }
              }

              i++;
          }

          while (operators.Count > 0)
          {
              parent = operators.Pop();
              if (parent.Value.CombineType == OperatorCombineType.Two)
              {
                  BinTreeNode<ExpressionItem> oprand2 = operands.Pop();
                  BinTreeNode<ExpressionItem> oprand1 = operands.Pop();
                  parent.LeftChild = oprand1;
                  parent.RightChild = oprand2;
              }
              else if (parent.Value.CombineType == OperatorCombineType.One)
              {
                  BinTreeNode<ExpressionItem> oprand1 = operands.Pop();
                  parent.LeftChild = oprand1;
              }

              operands.Push(parent);
          }

          result.Root = operands.Pop();

          return result;

      }

 

public double BintreeNodeCollapseRecursive(BinTreeNode<string> parent)
       {
           double result = double.MinValue;

           if (parent.LeftChild == null
                && parent.RightChild == null
               )
           {
               return double.Parse(parent.Value);
           }
           else
           {
               double left = BintreeNodeCollapseRecursive(parent.LeftChild);
               double right = BintreeNodeCollapseRecursive(parent.RightChild);
               result = Calculate(left, parent.Value, right);
           }

           return result;
       }

       public double BintreeNodeCollapseRecursive2(BinTreeNode<ExpressionItem> parent)
       {
           double result = double.MinValue;

           if (parent == null)
           {
               return double.MinValue;
           }

           if (parent.LeftChild == null
                && parent.RightChild == null
               )
           {
               return double.Parse(parent.Value.Value);
           }
           else
           {
               double left = BintreeNodeCollapseRecursive2(parent.LeftChild);
               double right = BintreeNodeCollapseRecursive2(parent.RightChild);

               if (parent.Value.CombineType == OperatorCombineType.Two)
               {
                   result = Calculate(left, parent.Value.Value, right);
               }
               else if (parent.Value.CombineType == OperatorCombineType.One)
               {
                   result = Calculate(left, parent.Value.Value);
               }
           }

           return result;
       }

 

private double Calculate(double left, string operatorString)
       {
           double result = 0;
           switch (operatorString)
           {

               case "-":
                   result = -1 * left;
                   break;
               default:
                   break;
           }

           return result;
       }

       private double Calculate(double left, string operatorString, double right)
       {
           double result = 0;
           switch (operatorString)
           {
               case "+":
                   result = left + right;
                   break;
               case "-":
                   result = left - right;
                   break;
               case "*":
                   result = left * right;
                   break;
               case "/":
                   result = left / right;
                   break;
               case "%":
                   result = left % right;
                   break;
               default:
                   break;
           }

           return result;

 

       }

转载于:https://www.cnblogs.com/netfuns/archive/2011/07/29/2120953.html

weixin_30588729
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法与数据结构（c语言）——BinaryTree（三）
掉了根毛的博客
01-26 289
线索二叉树： 二叉树添加了直接指向节点的前驱和后继的指针的二叉树称为线索二叉树。 线索化的实质其实就是将二叉链表中的空指针改为指向其前驱或后继的线索。 也就是在遍历的过程中修改空的指针（非线性结构的线性化操作）。                                                                                          ...
数据结构-二叉树(binaryTree)-C语言实现
NICE__FUTURE的博客
08-22 1178
用C语言实现二叉树基本功能 接口部分 “binaryTree.h” /*二叉树接口*/ #ifndef _BINARY_TREE_H_ #define _BINARY_TREE_H_ #include &amp;lt;stdbool.h&amp;gt; #define NAME_LENGTH 20 #define MAX_TRNODES 15 //测试用定义的最大节点数量，根据情况设定 /*实体定义*...
二叉树的前中后序的遍历（Binary Tree）c语言实现
qq_30677815的博客
03-22 952
先准备一个二叉树 如图所示 下面是该二叉树的实现，以及调用测试 #include "BinaryTree.h" int main() { BTNode* A = (BTNode*)malloc(sizeof(BTNode)); A->data='A'; A->left = NULL; A->right = NULL; BTNode* B = (BTNode*)malloc(sizeof(BTNode)); B->data='B'; B->left .
数据结构_二叉树（binary tree）基本定义、性质、理解总结+代码实现（C/C++）
mootun‘s技术笔记
02-27 2121
二叉树（binary tree）基本定义、性质、理解、总结+代码实现 约定：层序编号：二叉树从根结点开始按照从上到下，从左到右的顺序从1开始给结点编号。 二叉树(binary tree) 定义： 一个有限的结点集合。这个集合或者为空，或者由一个根结点和两棵互不相交的称为左子树（subtree）和右子树的二叉树组成。 二叉树是一种特殊的树形数据结构，二叉树的定义也是递归的，这决定了对二叉树的算法设计...
Binary Tree(C++)
风吹无迹雨落无痕
04-26 535
#include #include using namespace std ;template class BinaryTree ;              //forward declarationtemplate class BTnode {               //Node of BinaryTree public :  BTnode( ) ;  BTnode( const val
树和二叉树(Tree&Binary Tree)
Hacket_Xu的博客
08-23 238
树是一种非线性的数据结构，它在表示机构的组织关系图等方面非常好用，树的示意图如图1所示。图1 - 树的示意图。
二叉树的实现及三种遍历（递归实现）
尼伯龙根
08-04 1041
今天大佬群里开始每天出一道数据结构的小题目，我最近也准备学习一下，所以下午闲着没事就做了一下还是很有意思的。 题目如下： 首先需要构建二叉链表结构，是一个数据域加两个指针域（左孩子跟右孩子） 这次实现的是前序遍历、中序遍历和后序遍历。 前序遍历：先是根节点，再是左子树，最后是右子树。 中序遍历：先是左子树，再是根节点，最后是右子树。 后序遍历：先是左子树，再是右子树，最后是根节点。...
Balanced-binary-tree.rar_Balanced Binary Tree
09-23
在本项目中，“Balanced-binary-tree.rar”是一个压缩包，包含了一个C++实现平衡二叉树的实例，对于学习C++编程以及理解数据结构的深度是很有帮助的。 平衡二叉树分为几种类型，如AVL树和红黑树。AVL树是最先被提出...
test_binary_tree.rar_tree
09-14
总的来说，"test_binary_tree"可能提供了一个实践二叉树操作的实例，包括基本操作的实现和可能的优化策略。掌握二叉树及其操作对于提升编程能力和理解算法至关重要。通过学习和实践这个代码，你可以更好地理解和运用...
Code-for-binary-tree.zip_tree
09-24
在计算机科学领域，二叉树（Binary Tree）是一种基本的数据结构，它由节点（或称为顶点）和连接这些节点的边构成。每个节点最多有两个子节点，通常被标记为左子节点和右子节点。二叉树的概念是构建算法和数据结构的...
Algorithm-binarytree.zip
09-17
"Algorithm-binarytree.zip"这个压缩包文件显然是为了研究和实践二叉树相关算法而准备的，包含了一个名为"binarytree-master"的项目目录，很可能是包含源代码和相关示例的仓库。 二叉树的基本概念： 1. 节点：...
binaryTree.zip_Java编程_Java_
08-10
本资料包"binaryTree.zip"主要涵盖了如何使用先根遍历、中根遍历和后根遍历这三种方法来建立二叉树。 先根遍历（Preorder Traversal）是二叉树遍历的一种，其顺序为：先访问根节点，然后遍历左子树，最后遍历右子树...
二叉树 | Binary Tree | C/C++实现
qq_40998706的博客
01-30 348
问题描述 给定有根二叉树T，请编写一个程序，输出其各结点u的如下信息： u的结点编号 u的深度 u的父结点 u的高 u的兄弟结点 结点的种类（根、内部结点、叶） u的子结点数 设给定二叉树拥有n个结点，编号分别为0至n-1。 输入： 第1行输入结点的个数n。接下来n行按照下述格式输入各结点的信息，每个结点占1行。 id left right id为结点编号，left为左子结点编号，right为右子...
二叉树(Binary Tree)的建立与遍历——C语言实现
qq_43351159的博客
07-08 1254
一、运行环境简介 编辑器：VSCode + MicroSoft原生插件; ????‍????运行环境： MinGW ; ????‍????常用指令： gcc mian.c -o mian.exe 二、二叉树的定义 这里我们直接采用浙大数据结构课程中的代码。因为这种写法清晰明了，且便于后续扩展。 typedef char ElementType; typedef struct TNode *Position; /* 结构体指针 */ typedef Position BinTree; /* 二叉树类型 */
树和二叉树BinaryTree基础讲解C
TT_run的博客
07-11 515
二叉树和树的基本概念及代码
Binary Tree （构造）
a1046765624的博客
10-01 666
The Old Frog King lives on the root of an infinite tree. According to the law, each node should connect to exactly two nodes on the next level, forming a full binary tree. Since the king is profession...
HDU 1710 （二叉树的前序和中序，求后序）
-- bird --
05-17 2426
 Binary Tree TraversalsTime Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 549    Accepted Submission(s): 222Problem DescriptionA binary tree
【LeetCode】分隔链表
最新发布
qq_26521261的博客
07-20 408
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
val binarytree = new binarytree( rootvalue = 1)
09-18
在创建二叉树时，使用了关键字new来实例化一个BinaryTree类。 在括号内，`rootvalue = 1`表示指定了根节点的值为1。这意味着创建的二叉树的根节点的值为1。 所以，上述代码的含义是创建一棵二叉树，其中包含一个根...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值