精华内容
下载资源
问答
  • 用数组表示二叉树

    万次阅读 2016-07-08 11:21:24
    传统的二叉树是使用链表的形式,其优点是便于插入和删除,但是查找速度很慢,占用空间也很大.所以现在用数组的形式来构建二叉树,节点存在数组中,而不是由引用相连,节点在数组中的位置对应它在树中的位置,下标为0 的节点...

    传统的二叉树是使用链表的形式,其优点是便于插入和删除,但是查找速度很慢,占用空间也很大.所以现在用数组的形式来构建二叉树,节点存在数组中,而不是由引用相连,节点在数组中的位置对应它在树中的位置,下标为0 的节点为根节点,下标为1是根的左节点,2为根节点的右节点,依次类推,从左到右的顺序存储树的每一层,包括空节点.如下图:


                                                                                                                                  

    找节点的子节点和父节点可以利用简单的算术计算它们在数组中的索引值

    设某个节点索引值为index,则节点的左子节点索引为:

    2*index+1

    右子节点索引为:

    2*index+2

    父节点索引为:

    (index-1)/2


    总结:

    大多数情况下用数组表示数不是很有效率,除非是完全二叉树.但是普通的二叉树,特别是有很多空节点的.会有很多空洞,浪费存储空间.用数组表示树,删除节点是很费时费力的.

    所以用数组表示树适合用于 完全二叉树查找,和插入.下面是我自己写的代码,比较简单:

    public class ArrayTree {
    
        private int[] arrayTree;
        private int size = 0;
    
        public ArrayTree() {
    	super();
    	arrayTree = new int[10];
        }
    
        public void insert(int num) {
    	if (search(0, num) != -1)
    	    return;
    	if (arrayTree.length == 0) {
    	    arrayTree[0] = num;
    	} else {
    	    insert(0, num);
    	}
    
        }
    
        public void insert(int index, int num) {
    	if (arrayTree.length < 2 * index + 2) {
    	    reSize(2 * index + 2);
    	}
    	if (arrayTree[index] == 0) {
    	    arrayTree[index] = num;
    	    size++;
    	    return;
    	}
    
    	if (num > arrayTree[index]) {
    	    insert(2 * index + 2, num);
    	} else {
    	    insert(2 * index + 1, num);
    	}
    
        }
    
        public void reSize(int length) {
    	int[] newArrayTree = new int[length];
    	System.arraycopy(arrayTree, 0, newArrayTree, 0, arrayTree.length);
    	arrayTree = newArrayTree;
        }
    
        public int search(int num) {
    	return search(0, num);
        }
    
        public int search(int index, int num) {
    	if (arrayTree.length <= index)
    	    return -1;
    
    	if (arrayTree[index] == num)
    	    return index;
    
    	if (num > arrayTree[index]) {
    	    return search(2 * index + 2, num);
    	} else {
    	    return search(2 * index + 1, num);
    	}
    
        }
    
        public int get(int index) {
    	if (arrayTree.length > index) {
    	    return arrayTree[index];
    	} else {
    	    return -1;
    	}
    
        }
    
        public static void main(String[] args) {
    
    	ArrayTree arrayTree = new ArrayTree();
    	arrayTree.insert(50);
    	arrayTree.insert(25);
    	arrayTree.insert(76);
    	arrayTree.insert(37);
    	arrayTree.insert(62);
    	arrayTree.insert(84);
    	arrayTree.insert(31);
    	arrayTree.insert(43);
    	arrayTree.insert(55);
    	arrayTree.insert(92);
    
    	System.out.println("get:" + arrayTree.get(10));
    	System.out.println("index:" + arrayTree.search(24));
    	System.out.println("size:" + arrayTree.size);
    
        }
    
    }
    

    输出:

    get:43
    index:3
    size:11

    参考:java数据结构(第二版)第八章




              

    展开全文
  • /* 二叉树的链接表示*/ #include #include typedef char DataType; struct BinTreeNode; typedef struct BinTreeNode *PBinTreeNode;/* 二叉树中结点 */ typedef struct BinTreeNode { DataType info;

    头文件,定义栈和结构体的功能:

    /* 二叉树的链接表示*/
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef char DataType;
    
    struct BinTreeNode;	 
    typedef  struct BinTreeNode	 *PBinTreeNode;/* 二叉树中结点 */
    typedef struct BinTreeNode { 
    	DataType  info;	                        /* 数据域 */
    	PBinTreeNode llink;                     /* 指向左子女 */
    	PBinTreeNode rlink;                     /* 指向右子女 */
    }BTnode;
    typedef struct BinTreeNode *PBinTree;
    
    /*队列的结构体定义*/
    #define  queueSize 20
    struct Sequeue{
    	int r,f;
    	PBinTree q[queueSize];
    };
    typedef struct Sequeue *Pqueue;
    //声明队列函数
    Pqueue creatEmptyQueue(void);
    int isEmptySqueue(Pqueue qu);
    void insertQueue(Pqueue qu,PBinTree x);
    void deleteQueue(Pqueue qu);
    PBinTree topQueueElement(Pqueue qu);
    
    //创建空队列
    Pqueue creatEmptyQueue(void){
    	Pqueue qu=(Pqueue)malloc(sizeof(struct Sequeue));
    	if (qu==NULL)
    	{
    		printf("out of space");
    	} 
    	else
    	{
    		qu->f=qu->r=0;
    		return qu;
    	}
    }
    
    
    //判断队列是否为空
    int isEmptySqueue(Pqueue qu){
    	return qu->f==qu->r;//队尾=队头,则队列为空
    }
    
    //在队列中插入某一个元素
    void insertQueue(Pqueue qu,PBinTree x){
    	//首先判断队列是否已满
    	if ((qu->r+1)%queueSize==qu->f)
    	{
    		printf("full queue");
    	} 
    	else
    	{    //尾进头出
    		qu->q[qu->r]=x;//x插入当前队尾所指的位置
    		//qu->r=qu->r+1;
    		qu->r=(qu->r+1)%queueSize;//循环队列的长度加一
    	}
    }
    
    //删除队列头部元素
    void deleteQueue(Pqueue qu){
    	//首先判断队列是否已空
    	if (isEmptySqueue(qu))
    	{
    		printf("queue is empty");
    	} 
    	else
    	{
    		qu->f=qu->f+1;//使队头的下一个结点成为队头,那么当前的队头就出栈了
    	}
    }
    
    //对于非空队列,求队头元素
    PBinTree topQueueElement(Pqueue qu){
    	return qu->q[qu->f];//返回队头指向的当前元素
    }
    
    //*******************************************************************/
    
    //判断队列是否已满
    int isFullQueue(Pqueue qu){
    	return (qu->r+1)%queueSize==qu->f;//队尾加一等于队头,则满
    }
    
    
    /* 结点的指针类型 */
    
    #define  stackSize 100//定义常量不需加分号
     struct stack{
    	int top;//指向栈顶元素的指针
    	PBinTree s[stackSize];//栈的空间大小
    }Seqstack;
    typedef struct stack *Pstack;
    
    /*声明函数*/
    Pstack createEmptyStack_ps();
    int isEmptyStack_ps(Pstack s);
    void pushStack(Pstack ps,PBinTree x);
    void pop_stack(Pstack s);
    PBinTree topStack(Pstack s);
    
    //创建一个空栈并初始化
    
    Pstack createEmptyStack_ps(){
    	Pstack s=(Pstack)malloc(sizeof(struct stack));
    	if (s==NULL)
    	{
    		printf("out of space!");
    	}else{
    		s->top=-1;//栈顶元素赋值为-1
    	}
    	return s;
    }
    
    //判断栈是否为空
    int isEmptyStack_ps(Pstack s){
    	return s->top==-1;//空栈返回1,否则返回0
    }
    
    //进栈
    void pushStack(Pstack ps,PBinTree x){
    	if (ps->top>=stackSize-1)
    	{
    		printf("over flow");
    	} 
    		ps->top++;//栈顶元素指针加1
    		ps->s[ps->top]=x;
    }
    
    
    
    //取栈顶元素
    PBinTree topStack(Pstack s){
    	return (s->s[s->top]);
    }
    
    //出栈
    void pop_stack(Pstack s){
    	if (isEmptyStack_ps(s))
    	{
    		printf("under flow");
    	}
    	else{
    		s->top--;//栈顶指针减1
    	}
    }
    
    
    
    

    源文件:

    #include "PStack.h"
    
    /* 递归创建从根开始的二叉树 ,中序遍历创建二叉树*/
    PBinTree createRest_BTree() { 
    	PBinTree  pbnode;
    	char ch;
    	scanf("%c", &ch);
    	if(ch == '@') {
    		pbnode = NULL;
    	}
    	else { 
    		pbnode = (PBinTree)malloc(sizeof(struct BinTreeNode));
    		if( pbnode == NULL )         {
    			printf("Out of space!\n");
    			return pbnode;
    		}
    		pbnode->info = ch;
    		pbnode->llink = createRest_BTree();	/* 构造左子树 */
    		pbnode->rlink = createRest_BTree();	/* 构造右子树 */
    	}
    	return pbnode;
    }
    
    
    //用栈实现二叉树的先序遍历
    /*void FristReadBinTree(PBinTree t){
    	PBinTree p;
    	Pstack s;
    	if (t==NULL)
    	{
    		return;
    	}
    	 s=createEmptyStack_ps();
    	pushStack(s,t);
    	while (!isEmptyStack_ps(s))
    	{
    		p=topStack(s);
    		pop_stack(s);
    		if (p!=NULL)
    		{
    			printf("%c ",p->info);
    			pushStack(s,p->rlink);
    			pushStack(s,p->llink);
    		}
    	}
    }
    //中序遍历二叉树
    void minReadBinTree(PBinTree t){
    	PBinTree p=t;
    	Pstack s=createEmptyStack_ps();
    	if (p==NULL)
    	{
    		return;
    	}
    	do
    	{
    		while (p!=NULL)
    		{
    			
    			pushStack(s,p);
    			p=p->llink;
    		}
    			p=topStack(s);
    			pop_stack(s);
    			printf("%c ",p->info);
    			p=p->rlink;
    	}while (p!=NULL||!isEmptyStack_ps(s));
    
    }*/
    
    //层次遍历
    void chengciReadBinTree(PBinTree t){
    	PBinTree c,cc;
    	Pqueue q=creatEmptyQueue();
    	if (t==NULL)
    	{
    		return;
    	}
    	c=t;insertQueue(q,c);
    	while (!isEmptySqueue(q))
    	{
    		c=topQueueElement(q);
    		deleteQueue(q);
    		printf("%c ",c->info);
    
    		cc=c->llink;if (cc!=NULL)
    		{
    			insertQueue(q,cc);
    		}
    
    		cc=c->rlink;if (cc!=NULL)
    		{
    			insertQueue(q,cc);
    		}
    	}
    }
    
    //中序遍历统计叶子结点的个数
    int countLea(PBinTree p){
    	static int count;
    	if (p!=NULL)
    	{
    	countLea(p->llink);
    	if ((!p->llink)&&(!p->rlink))
    	{
    		count++;
    	}
    	countLea(p->rlink);
    	}
    	return count;
    	printf("fuck");
    }
    
    void main(){
    	int count;
    	printf("输入字符创建二叉树:\n");
    	PBinTree p=createRest_BTree();
    	printf("层次遍历二叉树:\n");
    	//FristReadBinTree(p);//先序遍历
    	//minReadBinTree(p);//中序遍历
    	chengciReadBinTree(p);//层次遍历
    	printf("叶子结点个数:\n");
    	count=countLea(p);
    	printf("%d\n",count);
    }



    展开全文
  • 利用JAVA结合数据结构的思想实现二叉树的应用,用户可以在界面里任意输入数据,可以实现数据二叉树图形表示,还可以实现增加,删除,查找节点等操作..
  • #把数组值放入二叉树 length = 9 data = [ 0 , 6 , 3 , 5 , 4 , 7 , 8 , 9 , 2 ] #原始数组 btree = [ 0 ] * 16 print ( "原始数组内容:" ) for i in range ( length ) : print ( '[%2d]' % data [ ...
    # @File  : tree.py
    # @Author: Wang Zhimin
    # @Date  :  2019/10/25
    def Btree_create(btree,data,length):
    
        for i in range(1,length):
            level = 1
            while btree[level]!=0:
                if data[i]>btree[level]:
                    level=level*2+1  #如果数组值大于树根,就往右子树比较
                else:
                    level=level*2    #如果数组值小于或等于树根,就往左子树比较
            btree[level]=data[i]     #把数组值放入二叉树
    
    length=9
    data=[0,6,3,5,4,7,8,9,2]#原始数组
    btree=[0]*16
    print("原始数组内容:")
    for i in range(length):
        print('[%2d]'%data[i],end='')
    print('')
    Btree_create(btree,data,9)
    print('二叉树内容:')
    for i in range(1,16):
        print('[%2d]'%btree[i],end='')
    print()
    展开全文
  • 数据结构 - 二叉树的遍历

    万次阅读 多人点赞 2019-02-18 14:32:52
    分享一个大牛的人工智能教程。...给定一棵二叉树的前序遍历序列和中序遍历序列可以惟一确定一棵二叉树二叉树的深度优先遍历的非递归的通用做法是采用栈,广度优先遍历的非递归的通用做法是采用队列。 ...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net 

    二叉树的遍历

    N:访问根结点,L:遍历根结点的左子树,R:遍历根结点的右子树。

    给定一棵二叉树的前序遍历序列和中序遍历序列可以惟一确定一棵二叉树。

    二叉树的深度优先遍历的非递归的通用做法是采用栈,广度优先遍历的非递归的通用做法是采用队列。

    深度优先遍历二叉树

    1. 中序遍历(LNR)的递归算法:

    若二叉树为空,则算法结束;否则:

    中序遍历根结点的左子树;

    访问根结点;

    中序遍历根结点的右子树。

    2. 前序遍历(NLR)的递归算法:

    若二叉树为空,则算法结束,否则:

    访问根结点;

    前序遍历根结点的左子树;

    前序遍历根结点的右子树。

    3. 后序遍历(LRN)的递归算法:

    若二叉树为空,则算法结束,否则:

    后序遍历根结点的左子树;

    后序遍历根结点的右子树;

    访问根结点。

    非递归深度优先遍历二叉树

    栈是实现递归最常用的结构,利用一个栈来记下尚待遍历的结点或子树,以备以后访问,可以将递归的深度优先遍历改为非递归的算法。

    1. 非递归前序遍历:遇到一个结点,就访问该结点,并把此结点推入栈中,然后下降去遍历它的左子树。遍历完它的左子树后,从栈顶托出这个结点,并按照它的右链接指示的地址再去遍历该结点的右子树结构。

    2. 非递归中序遍历:遇到一个结点,就把它推入栈中,并去遍历它的左子树。遍历完左子树后,从栈顶托出这个结点并访问之,然后按照它的右链接指示的地址再去遍历该结点的右子树。

    3. 非递归后序遍历:遇到一个结点,把它推入栈中,遍历它的左子树。遍历结束后,还不能马上访问处于栈顶的该结点,而是要再按照它的右链接结构指示的地址去遍历该结点的右子树。遍历完右子树后才能从栈顶托出该结点并访问之。另外,还需要给栈中的每个元素加上一个特征位,以便当从栈顶托出一个结点时区别是从栈顶元素左边回来的(则要继续遍历右子树),还是从右边回来的(则该结点的左、右子树均已遍历)。特征为Left表示已进入该结点的左子树,将从左边回来;特征为Right表示已进入该结点的右子树,将从右边回来。

    非递归广度优先遍历二叉树

    非递归广度优先遍历二叉树(层序遍历)是用队列来实现的。从二叉树的第一层(根结点)开始,自上至下逐层遍历;在同一层中,按照从左到右的顺序对结点逐一访问。

    按照从根结点至叶结点、从左子树至右子树的次序访问二叉树的结点。算法如下:

    1. 初始化一个队列,并把根结点入队列;

    2. 当队列为非空时,循环执行步骤3到步骤5,否则执行6;

    3. 出队列取得一个结点,访问该结点;

    4. 若该结点的左子树为非空,则将该结点的左子树入队列;

    5. 若该结点的右子树为非空,则将该结点的右子树入队列;

    6. 结束。

    /*
     * Binary Tree Breadth-First Traverse - by Chimomo
     */
    
    #include <iostream>
    
    #define _OK 1
    #define _ERROR 0
    
    using namespace std;
    
    // Define node element type in binary tree.
    typedef char Element;
    
    // Binary tree node.
    typedef struct BTNode {
        Element data;
        BTNode *lChild, *rChild; // Define left, right subtree.
    } BTNode, *BTree;
    
    // Define node element type in queue. (The node element type in queue is the pointer to binary tree node)
    typedef BTNode *QElementType;
    typedef int status;
    
    // We need use queue to perform level traverse. So, define queue first.
    typedef struct QNode {
        QElementType data;
        QNode *next;
    } QNode, *QueuePtr;
    
    // Definition of queue.
    typedef struct {
        QueuePtr front;
        QueuePtr rear;
    } LinkQueue;
    
    status InitQueue(LinkQueue &Q) {
        Q.front = NULL;
        Q.rear = NULL;
        return _OK;
    }
    
    bool IsEmpty(LinkQueue Q) {
        return Q.front == NULL;
    }
    
    /**
     * Enqueue.
     * @param Q The queue.
     * @param e The queue element.
     * @return 1 for ok, 0 for error.
     */
    status EnQueue(LinkQueue &Q, QElementType e) {
        // Construct queue node.
        QNode *ptrNode = (QNode *) malloc(sizeof(QNode));
        if (!ptrNode) {
            return _ERROR;
        }
    
        ptrNode->data = e;
        ptrNode->next = NULL;
        if (IsEmpty(Q)) {
            Q.front = Q.rear = ptrNode;
            return _OK;
        }
    
        Q.rear->next = ptrNode;
        Q.rear = ptrNode;
        return _OK;
    }
    
    /**
     * Dequeue.
     * @param Q The queue.
     * @param e The queue element.
     * @return 1 for ok, 0 for error.
     */
    status DeQueue(LinkQueue &Q, QElementType &e) {
        if (IsEmpty(Q)) {
            return _ERROR;
        }
    
        QNode *tempPtr = Q.front;
        e = tempPtr->data;
        Q.front = tempPtr->next;
        free(tempPtr);
        return _OK;
    }
    
    /**
     * Create binary tree.
     * @param T The binary tree address.
     * @return 1 for success, 0 for fail.
     */
    int CreateBTree(BTree &T) {
        char ch;
        cout << "Please input a character:" << endl;
        cin >> ch;
        if (ch == '#') {
            T = NULL;
        } else {
            // Allocate memory for new node.
            if (!(T = (BTNode *) malloc(sizeof(BTNode)))) {
                return 0; // Allocation fails.
            }
    
            T->data = ch;
    
            // Create left subtree.
            CreateBTree(T->lChild);
    
            // Create right subtree.
            CreateBTree(T->rChild);
        }
    
        return 1;
    }
    
    void VisitBTNode(BTNode *BT) {
        cout << BT->data << " ";
    }
    
    void VisitQNode(QNode *Q) {
        VisitBTNode(Q->data);
    }
    
    /**
     * Breadth-first traverse.
     * @param T The binary tree.
     */
    void LevelTraverse(BTree T) {
        QElementType e;
        LinkQueue Q;
        InitQueue(Q);
        EnQueue(Q, T);
        while (!IsEmpty(Q)) {
            VisitQNode(Q.front);
            if (Q.front->data->lChild != NULL) {
                EnQueue(Q, Q.front->data->lChild);
            }
            if (Q.front->data->rChild != NULL) {
                EnQueue(Q, Q.front->data->rChild);
            }
            DeQueue(Q, e);
        }
    }
    
    int main() {
        BTree T;
        CreateBTree(T);
        cout << "Breadth-first traverse: ";
        LevelTraverse(T);
        return 0;
    }
    
    // Output:
    /*
    Please input a character:
    1
    1
    Please input a character:
    2
    2
    Please input a character:
    3
    3
    Please input a character:
    4
    4
    Please input a character:
    5
    5
    Please input a character:
    6
    6
    Please input a character:
    #
    #
    Please input a character:
    #
    #
    Please input a character:
    #
    #
    Please input a character:
    #
    #
    Please input a character:
    #
    #
    Please input a character:
    #
    #
    Please input a character:
    #
    #
    Breadth-first traverse: 1 2 3 4 5 6
    */

     

    展开全文
  • C++语言描述,实现三叉链表表示二叉树,包括创建,插入,删除和循环算法遍历二叉树等!
  • 二叉树(3)——三叉链表示二叉树

    千次阅读 2013-06-13 20:38:28
    所畏的三叉链表示是指二叉树由指向左孩子结点、右孩子结点、父亲结点【三叉】的引用(指针)数据数据组成。 package datastructure.tree.btree; /** * 三叉链表示二叉树定义 * @author Administrator * */ ...
  • 数据结构 - 二叉树(C++)

    万次阅读 多人点赞 2019-02-26 18:10:43
    分享一个大牛的人工智能教程。...=0)个结点的有限集,它或者是空集(n=0),或者由一个根结点及两棵互不相交的、分别称为这个根的左子树和右子树的二叉树组成。 二叉树的性质 性质1 二叉树第i层上的...
  • 数据结构(十二) 学习数据结构与算法过程中的心得体会以及知识点的整理,方便我自己查找,也希望可以和大家一起交流。...第一行是一个整数n,表示二叉树的结点个数。二叉树结点编号从1到n,根结点为1,n &...
  • 二叉树的各类表示法 来自
  • 二叉树

    2018-11-25 15:36:15
    文章目录二叉树表示二叉树的二叉链表表示二叉树的创建二叉树遍历前序遍历二叉树前序递归遍历二叉树前序非递归遍历中序遍历二叉树中序递归遍历二叉树中序非递归遍历后序遍历二叉树后序递归遍历二叉树后序非递归遍历...
  • 1.链表表示法struct TreeNode { int val; TreeNode *left; TreeNode *right;...2.数组表示法:将二叉树看作完全二叉树缺点,如果树很稀疏的话,空间浪费比较大。优点,父子结点、兄弟结点之间通过下标...
  • 数据结构二叉树家谱

    2015-12-17 16:47:54
    数据结构二叉树家谱:文件操作功能,家谱操作功能
  • 根据括号表达式构造二叉树,对二叉树进行前序,中序,后序,层序遍历,并用树形方式打印输出,有详细注释,供C++数据结构课程学习与交流使用。
  • 表达式的二叉树表示

    2020-03-24 12:29:40
    1. 表达式的二叉树表示 2. 如何求前缀表达式、中缀表达式、后缀表达式 3. 如何利用后缀表达式求值。
  • 参考资料:《数据结构(C语言版)严蔚敏著》 版权说明:未经作者允许,禁止转载。如引用本文内容,需标明...使用链表来表示二叉树,则结点结构中至少含有3个域:数据域、左指针域和右指针域。有时,为了便于找到结...
  • 二叉树的数组表示

    2019-05-08 16:21:00
    二叉树的数组表示 二叉树的数组表示: 一、数据结构的本质 二叉树在很多应用的地方,其实很多时候并不需要去建树。大多数学生陷入一个误区,二叉树一定要形如下面的样子。 package tree; ...
  • 二叉树基本概念
  • 数据结构 二叉树遍历

    2011-05-14 00:14:44
    数据结构第七章二叉树遍历的源代码,有用有用~~按先序次序输入二叉树中结点的值(一个字符),空格字符表示空树...
  • 按满二叉树的结点层次编号,依次存放二叉树中的数据元素。 若有空节点则不能连续存储,空出位置! 二叉树顺序存储缺点 最坏情况:右单支树,深度为k的且只有k个结点的单支树需要长度为2k-1的一维数组。 特点:结点...
  • 数据结构——遍历二叉树和线索二叉树

    千次阅读 多人点赞 2020-10-30 20:04:04
    数据结构——遍历二叉树和线索二叉树】 目录【数据结构——遍历二叉树和线索二叉树】一、遍历二叉树二级目录三级目录二、线索二叉树二级目录三级目录 一、遍历二叉树 二级目录 三级目录 二、线索二叉树 二级目录 ...
  • 4.一棵树采用 firstChild-nextSibling 表示方法可以转换为二叉树 5.二叉树的子树有左右之分,二叉树有5中基本形式 6.满二叉树:深度为k,共有2^k-1个结点 7.完全二叉树:按序号对应 二、二叉树遍历 typedef ...
  • 这是数据结构课程设计,二叉树表示的算术表达式
  • 数据结构——二叉树

    2019-02-06 22:56:29
    该文件包括二叉树的头文件(BitTree开头)和堆栈的头文件(Seq开头),另外还实现了编写按层次顺序(同一层自左至右)遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树(通过...
  • 二叉树数值表达式

    2020-10-22 12:41:17
    二叉树数值表达式 问题描述 给定一个二叉树,这个二叉树对应一个有效的数值表达式。树的每一个叶子结点都是一个整数,非叶子结点都是加 + 减 - 乘 * 除 \ 这几个运算符之一。算法返回表达式计算的结果。 测试样例 # ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 108,553
精华内容 43,421
关键字:

数据表示二叉树