精华内容
下载资源
问答
  • 二叉链表遍历实现

    2015-06-28 12:10:15
    数据结构二叉链表
    //二叉链表的实现
    #include<iostream>
    #include<string>
    #include<stack>
    using namespace std;
    typedef char TElemType;
    typedef struct BiNode {
    	TElemType data;
    	BiNode *lchild, *rchild;
    }BiNode, *BiTree;
    void CreateBiTree(BiTree &T)
    {
    	T = (BiTree)malloc(sizeof(BiNode));
    
    
    	char ch;
    	cin >> ch;
    	if (ch != '#')
    	{
    		T->data = ch;
    		CreateBiTree(T->lchild);
    		CreateBiTree(T->rchild);
    
    
    	}
    	else
    		T = NULL;
    }
    TElemType Visit(BiTree &T)
    {
    	return T->data;
    }
    void PreOrder(BiTree &T)
    {
    	if (T != NULL)
    	{
    		cout << Visit(T);
    		PreOrder(T->lchild);
    		PreOrder(T->rchild);
    	}
    }
    void InOrder(BiTree &T)
    {
    	if (T != NULL)
    	{
    
    
    		InOrder(T->lchild);
    		cout << Visit(T);
    		InOrder(T->rchild);
    	}
    }
    void Postrder(BiTree &T)
    {
    	if (T != NULL)
    	{
    
    
    		Postrder(T->lchild);
    		Postrder(T->rchild);
    		cout << Visit(T);
    	}
    }
    //前序遍历的非递归算法
    void Pre_Order(BiTree &T)
    {
    	stack<BiTree> s;
    	BiTree p = T;
    	while (p||!s.empty())
    	{
    		if (p)
    		{
    			s.push(p);
    			cout << p->data;
    			p=p->lchild;
    		}
    		else
    		{
    			p =s.top();
    			s.pop();
    			p = p->rchild;
    		}
    	}
    }
    //中序遍历的非递归算法
    void In_Order(BiTree &T)
    {
    	stack<BiTree> s;
    	BiTree p = T;
    	while (p || !s.empty())
    	{
    		if (p)
    		{
    			s.push(p);
    			p = p->lchild;
    		}
    		else
    		{
    			p = s.top();
    			s.pop();
    			cout << p->data;
    			p = p->rchild;
    			
    		}
    	}
    }
    //后序遍历的非递归算法
    void Post_Order(BiTree &T)
    {
    	stack<BiTree> s;
    	BiTree p = T;
    	BiTree pre_p=NULL;
    	while (p ||!s.empty())
    	{
    		if (p)
    		{
    			s.push(p);
    			p = p->lchild;
    		}
    		else
    		{
    			p = s.top();
    		   //如果存在右子树并且右子树没有访问过
    			if ((p->rchild) && !(s.top()->rchild == pre_p))
    			{
    				p = p->rchild;
    			}
    			else
    			{			
    				//输出结点并且设置前置结点,此时只要全部退出输入就可以
    			    	cout << p->data;
    					pre_p = p;
    					p = NULL;
    					s.pop();		
    			
    			}
    		
    			
    		}
    
    
    	}
    }
    void main()
    {
    	BiTree RT;
    	CreateBiTree(RT);
    	//PreOrder(RT);
    	//cout << endl;
    	//Pre_Order(RT);
    
    
    	//InOrder(RT);
    
    
    	//cout << endl;
    	//In_Order(RT);
    	Postrder(RT);
    	cout << endl; Post_Order(RT);
    
    
    }

    展开全文
  • (1)建立二叉树的二叉...(3)写出对用二叉链表存储的二叉树进行层次遍历算法。 (4)求二叉树的所有叶子及结点总数。 include #include #define N 20 #define SIZE 100 #define MORE 10 typedef struct BiTNode{ ch

    欢迎加qq群:453398542 学习讨论,会定期分享资料课程,解答问题。

    (1)建立二叉树的二叉链表。

    (2)写出对用二叉链表存储的二叉树进行先序、中序和后序遍历的递归和非递归算法。

    (3)写出对用二叉链表存储的二叉树进行层次遍历算法。

    (4)求二叉树的所有叶子及结点总数。

    include<stdio.h>

    #include<stdlib.h>

    #define N 20

    #define SIZE 100

    #define MORE 10

    typedef struct BiTNode{

    char data; //数据域

    struct BiTNode *lchild, *rchild; //左、右孩子指针

    }BiTNode, *BiTree;

     

    //栈 

    typedef struct{

    BiTree *base;

    int top;

    int stacksize;

    }SqStack;

     

    //队列 

    typedef struct {

    BiTree *base; //初始化动态分配空间

    int front;

    int rear;

    } SqQueue;

    //栈 

    void InitStack(SqStack &S){

    //构造一个空栈 

    S.base=(BiTree*)malloc(SIZE*sizeof(BiTree));

    if(!S.base) return ;

    S.top=0;

    S.stacksize=SIZE;

    }

    int StackEmpty(SqStack &S){

    //判空 是返回1 否返回0

    if(S.top==0) return 1;

    else return 0;

    void Push(SqStack &S,BiTree e){

    //入栈 

    if(S.top>=S.stacksize){

    S.base=(BiTree *)realloc(S.base,(S.stacksize+MORE)*sizeof(BiTree));

    if(!S.base) exit(0);

    S.stacksize+=MORE;

    }

    S.base[S.top++]=e;

    }

    void Pop(SqStack &S,BiTree &e){

    //出栈

    if(S.top==0) exit(0);

    else

    e=S.base[--S.top]; 

    }

    int GetTop(SqStack &S,BiTree &e){

    //取栈顶元素 

    if(S.top==0)  

    return 0;

    else

    e=S.base[S.top-1];

    return 1;

    }//栈 

     

    //队列 

    void InitQueue(SqQueue &Q){

    //构造一个空队列

    Q.base=(BiTree *)malloc(SIZE*sizeof(BiTree));

    if (!Q.base) exit(0);

    else

    Q.front=Q.rear=0;

    }

    int QueueEmpty(SqQueue Q){

    //判空

    if (Q.rear==Q.front) return 1;

    else

    return 0;

    }

    void EnQueue(SqQueue &Q,BiTree e){

    //插入元素e为Q的新的队尾元素

    if ((Q.rear+1)%SIZE==Q.front) 

    exit(0);

    else

    Q.base[Q.rear]=e;

    Q.rear=(Q.rear+1)%SIZE;

    }

    void DeQueue(SqQueue &Q,BiTree &e){

    // 删除Q的队头元素, 并用e返回其值

    if ((Q.rear+1)%SIZE==Q.front) 

    exit(0);

    else

    e=Q.base[Q.front];

    Q.front=(Q.front+1)%SIZE;

    } //队列

     

    void visit(char data){

    printf("%3c",data);

    }

    void CreatBiTree(BiTree &bt){

    //构造二叉树

    char ch;

    ch=getchar();

    if(ch=='#')

    bt=NULL;

    else{

    bt=(BiTree)malloc(sizeof(BiTNode));

    bt->data=ch;

    CreatBiTree(bt->lchild);

    CreatBiTree(bt->rchild);

    //二叉树三种遍历的递归算法 

    void PreOrderTraverse(BiTree bt){

    //先序遍历

    if(bt){

    visit(bt->data);

    PreOrderTraverse(bt->lchild);

    PreOrderTraverse(bt->rchild);

    void InOrderTraverse(BiTree bt){

    //中序遍历

    if(bt){

    InOrderTraverse(bt->lchild);

    visit(bt->data);

    InOrderTraverse(bt->rchild);

    }

    }

    void PostOrderTraverse(BiTree bt){

    //后序遍历

    if(bt){

    PostOrderTraverse(bt->lchild);

    PostOrderTraverse(bt->rchild);

    visit(bt->data);

    }

    }

    //二叉树三种遍历的非递归算法,栈 

    void PreOrderTraverse2(BiTree bt){

      //先序遍历

      BiTree p;

      SqStack S;

    if(bt){ 

    InitStack(S); 

    Push(S,bt); 

    while(!StackEmpty(S)){ 

    while(GetTop(S,p)&&p){ 

    visit(p->data); 

    Push(S,p->lchild); 

    Pop(S,p); 

    if(!StackEmpty(S)){ 

    Pop(S,p); 

    Push(S,p->rchild); 

    }

    }

    }

    }

    void InOrderTraverse2(BiTree bt){

    //中序遍历

    BiTree p;

    SqStack S;

    if(bt){ 

    InitStack(S); 

    Push(S, bt); 

    while(!StackEmpty(S)){ 

    while(GetTop(S,p)&&p){

    Push(S, p->lchild); 

    Pop(S, p); 

    if(!StackEmpty(S)){ 

    Pop(S,p); 

    visit(p->data); 

    Push(S, p->rchild); 

    }

    }

    }

    }

    void PostOrderTraverse2(BiTree bt){

    //后序遍历

    BiTree p,q;

    SqStack S;

    InitStack(S); 

    Push(S,bt); 

    while(!StackEmpty(S)){ 

    while(GetTop(S,p)&&p){

    Push(S,p->lchild); 

    Pop(S,p); 

    if(!StackEmpty(S)){ 

    GetTop(S,p); 

    if(p->rchild)

    Push(S,p->rchild);

    else{ 

    Pop(S,p); 

    visit(p->data);

    while(!StackEmpty(S)&&GetTop(S,q)&&q->rchild==p){ 

    Pop(S,p); 

    visit(p->data);

    }

    if(!StackEmpty(S)){ 

    GetTop(S,p); Push(S,p->rchild); 

    }

                }

    }

    }

    }

     

    void LevelOrderTraverse(BiTree bt){

    //层次遍历,队列 

    BiTree p;

    SqQueue Q;

    if(bt){

    InitQueue(Q); 

    EnQueue(Q,bt);

    while(!QueueEmpty(Q)){

    DeQueue(Q,p);

    visit(bt->data);

    if(p->lchild){

    EnQueue(Q,p->lchild);

    }

    if(p->rchild){

    EnQueue(Q,p->rchild);

    }

    }

    }

    int NodeNum(BiTree bt){

    //求结点个数 

    int count=0;

    BiTree p;

    SqQueue Q;

    if(bt){

    InitQueue(Q); 

    EnQueue(Q,bt);

    while(!QueueEmpty(Q)){

    DeQueue(Q,p);

    count++;

    if(p->lchild){

    EnQueue(Q,p->lchild);

    }

    if(p->rchild){

    EnQueue(Q,p->rchild);

    }

    }

    return count;

    }

    int LeaNum(BiTree bt){

    //求叶子总数

    if(!bt){

    return 0;

    else if(!(bt->lchild)&&!(bt->rchild)){

    return 1;

    }

    else{

    return (LeaNum(bt->lchild)+LeaNum(bt->rchild));

    }

    int main(){

    int a,b;

    BiTree bt;

    printf("输入数据:\n");

    CreatBiTree(bt);

    a=NodeNum(bt);

    printf("结点个数为:%d\n",a);

    b=LeaNum(bt);

    printf("叶子个数为:%d\n",b);

    return 0;

    }

    展开全文
  • 二叉链表遍历二叉链表 各种 操作的 基础,例如 :创建 二叉树;求树的 长度;求树的 叶子节点数;求 节点的 层 数;求 树的 深度,宽度 等等。 总之 不掌握 遍历,就没有 掌握 二叉树; 二叉链表遍历 根据 ...

    二叉链表的 遍历 是 二叉链表 各种 操作的 基础,例如 :创建 二叉树;求树的 长度;求树的 叶子节点数;求 节点的 层 数;求 树的 深度,宽度 等等。

    总之 不掌握 遍历,就没有 掌握 二叉树;

    二叉链表的 遍历 根据 根节点的访问顺序有:先(根节点)序,中(根节点)序,后(根节点)序, 和 层序;

    算法思路 有两类:

    1. 递归 算法,算法 清晰,容易 证明算法的正确性,但是 效率较低 和 受 系统 栈区 大小的限制,不能 递归太多层次

    2.非 递归算法,算法 较复杂一些,但是效率高,又 不受 栈区大小的限制

    下面 讲解 这两种 算法:

    1.递归算法 ,递归没什么 说的,比较 简单

    //递归算法 先序
    void preOrderTraverse(Tree tree){
    	if (tree != NULL)
    	{
    		printf("%d\t",tree->data);
    		preOrderTraverse(tree->leftChild);
    		preOrderTraverse(tree->rightChild);
    	}
    }
    //递归算法 中序
    void inOrderTraverse(Tree tree){
    	if (tree != NULL)
    	{
    		inOrderTraverse(tree->leftChild);
    		printf("%d\t",tree->data);
    		inOrderTraverse(tree->rightChild);
    	}
    }
    //递归算法 后序
    void postOrderTraverse(Tree tree){
    	if (tree != NULL)
    	{
    		postOrderTraverse(tree->leftChild);
    		postOrderTraverse(tree->rightChild);
    		printf("%d\t",tree->data);
    	}
    }


    2.重点 讲解 非 递归算法,非递归 算法 需要 借助 栈 (先,中,后序) 或者 队列(层序) 来进行遍历。

    2.1 非递归 先序 算法 总共 有 三种 方法:

     下面 的两种算法 思路一致,都是 找左子树最左下角节点的同时访问节点,然后 将 节点的 右子树入栈。然后 重复寻找..

    void preOrderTraverse1(Tree t){
    	linkStack stack;
    	stackInit(&stack);
    	stackPush(&stack,t);
    	while (!stackEmpty(stack))
    	{
    		while (stackGetTop(stack,&t) && t)
    		{
    			printf("%d\t",t->data);
    			stackPush(&stack,t->leftChild);
    		}
    		stackPop(&stack,&t);//NULL 出栈
    		if (!stackEmpty(stack))
    		{
    			stackPop(&stack,&t);
    			stackPush(&stack,t->rightChild);
    		}
    	}
    	stackDestory(&stack);
    }
    
    void preOrderTraverse2(Tree tree){
    	linkStack stack;
    	stackInit(&stack);
    	while (tree || !stackEmpty(stack))
    	{
    		if (tree)
    		{
    			printf("%d\t",tree->data);
    			stackPush(&stack,tree);
    			tree = tree->leftChild;
    		}
    		else
    		{
    			stackPop(&stack,&tree);
    			tree = tree->rightChild;
    		}
    	}
    	stackDestory(&stack);
    }
    第三种 思路 较 前两种 清晰,更加 易懂

    1.空树 不操作 2.将 树根入栈 3.访问  根 节点 ,将根节点出栈 4. 右子树不为空,将 右子树 入栈 5. 左子树 不为空,将左子树入栈 6.重复 3~ 5 步

    比较 奇思妙想的是 先 将 右子树入栈 ,再将 左子树入栈,这样每次 都 先 访问 栈顶 的 左子树。

    void preOrderTraverse3(Tree tree){
    	if (tree != NULL)
    	{
    		linkStack stack;
    		stackInit(&stack);
    		stackPush(&stack,tree);
    		while (!stackEmpty(stack))
    		{
    			stackPop(&stack,&tree);
    			printf("%d\t",tree->data);
    			if (tree->rightChild != NULL)
    			{
    				stackPush(&stack,tree->rightChild);
    			}
    			if (tree->leftChild != NULL)
    			{
    				stackPush(&stack,tree->leftChild);
    			}
    		}
    	}
    }

    2.2 非递归 中序 有两种算法

    算法 思路 同 先序 前两种 算法 的思路 一致,只是 先序是在 在 找 左子树的时候 访问,而中序 是 在 退栈的时候访问

    //中序非递归
    void inOrderTraverse1(Tree tree){
    	linkStack stack;
    	stackInit(&stack);
    	stackPush(&stack,tree);
    	while (!stackEmpty(stack))
    	{
    		while (stackGetTop(stack,&tree) && tree) stackPush(&stack,tree->leftChild);
    		stackPop(&stack,&tree);
    		if (!stackEmpty(stack))
    		{
    			stackPop(&stack,&tree);
    			printf("%d\t",tree->data);
    			stackPush(&stack,tree->rightChild);
    		}
    	}
    	stackDestory(&stack);
    }
    
    void inOrderTraverse2(Tree tree){
    	linkStack stack;
    	stackInit(&stack);
    	while (tree || !stackEmpty(stack))
    	{
    		if (tree)
    		{
    			stackPush(&stack,tree);
    			tree = tree->leftChild;
    		}
    		else
    		{
    			stackPop(&stack,&tree);
    			printf("%d\t",tree->data);
    			tree = tree->rightChild;
    		}
    	}
    	stackDestory(&stack);
    }


    2.3 后序遍历 是 所有遍历中 最难的 一种
    我在网上 研究了 一番,发现了 一种 思路 比较 清晰的算法。

    大致 的思路 是 :只有 底下 三种情况的时候 访问 根节点。

     1. 节点的 左子树 为空 并且 右 子树 为空 ,2. 刚访问过 右子树  3. 刚访问过左子树 并且 右子树 为空的 时候 

    这个算法 需要 记住 上一个 访问的 节点 和 利用 先 右子树 入栈 后 左子树 入栈,始终 先访问 左子树。

    void postOrderTraverse1(Tree tree){
    	if (tree != NULL)
    	{
    		linkStack stack;
    		stackInit(&stack);
    		stackPush(&stack,tree);
    		Tree pre = NULL;
    		while (!stackEmpty(stack))
    		{
    			stackGetTop(stack,&tree);
    			//左右子树都为空,或者 左子树刚访问过,并且 右子树为空,或者 刚访问过 右子树. 可以直接访问
    			if ((tree->leftChild == NULL && tree->rightChild == NULL) || (pre != NULL && (tree->leftChild == pre || tree->rightChild == pre)))
    			{
    				printf("%d\t",tree->data);
    				stackPop(&stack,&tree);
    				pre = tree;
    			}
    			else
    			{
    				if (tree->rightChild != NULL)
    				{
    					stackPush(&stack,tree->rightChild);
    				}
    			        if(tree->leftChild != NULL)
    				{
    					stackPush(&stack,tree->leftChild);
    				}
    			}
    		}
    	}
    }

    2.4 层序 访问, 是 按 从 上 到下,从左 到右 的顺序 访问树。这时候 我们 需要 借助 队列。

    这个算法 有一个特点,左子树 一定 在 右子树 前 访问,左子树的  孩子  一定 在 右子树的 孩子前 访问。

    大概的思路:1. 将根节点入队列,访问 根节点 2. 将左 子树 入队列, 3.将 右子树 入队列 4.重复 1~3

    //层序
    //利用队列
    void levelOrderTraverse(Tree tree){
    	if (tree != NULL)
    	{
    		LinkQueue queue;
    		queueInit(&queue);
    		enqueue(&queue,tree);
    		while (dequeue(&queue,&tree) && tree)
    		{
    			printf("%d\t",tree->data);
    			if (tree->leftChild != NULL)
    			{
    				enqueue(&queue,tree->leftChild);
    			}
    			if (tree->rightChild != NULL)
    			{
    				enqueue(&queue,tree->rightChild);
    			}
    		}
    		queueDestory(&queue);
    	}
    }

    下面 给出 完整 代码,其中 栈 和 队列 的部分代码 没有 贴出,可以 从 我以前的 代码中 摘取。

    // binaryTree.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <cstdlib>
    #include "stack.h"
    #include "queue.h"
    
    typedef int ElementType;
    
    typedef  struct TreeNode
    {
    	ElementType data;
    	TreeNode * leftChild;
    	TreeNode * rightChild;
    } * Tree;
    
    void treeInit(Tree * tree){
    	*tree = NULL;
    }
    //其实 自己 不懂 这个 函数 初始化...
    E_State treeCreate(Tree *tree){
    	ElementType data;
    	scanf("%d",&data);
    	if (data == 0)
    	{
    		*tree = NULL;
    	}else
    	{
    		*tree = (Tree)malloc(sizeof(TreeNode));
    		(*tree)->data = data;
    		treeCreate(&(*tree)->leftChild);
    		treeCreate(&(*tree)->rightChild);
    	}
    	return E_State_Ok;
    }
    
    
    //后序遍历
    void treeClear(Tree * tree){
    	if (tree != NULL)
    	{
    		if ((*tree)->leftChild != NULL)
    		{
    			treeClear(&(*tree)->leftChild);
    		}
    		else if((*tree)->rightChild != NULL)
    		{
    			treeClear(&(*tree)->rightChild);
    		}
    		free(*tree);
    		*tree = NULL;
    	}
    }
    
    void treeDestory(Tree * tree){
    	treeClear(tree);
    }
    //递归算法 先序
    void preOrderTraverse(Tree tree){
    	if (tree != NULL)
    	{
    		printf("%d\t",tree->data);
    		preOrderTraverse(tree->leftChild);
    		preOrderTraverse(tree->rightChild);
    	}
    }
    //递归算法 中序
    void inOrderTraverse(Tree tree){
    	if (tree != NULL)
    	{
    		inOrderTraverse(tree->leftChild);
    		printf("%d\t",tree->data);
    		inOrderTraverse(tree->rightChild);
    	}
    }
    //递归算法 后序
    void postOrderTraverse(Tree tree){
    	if (tree != NULL)
    	{
    		postOrderTraverse(tree->leftChild);
    		postOrderTraverse(tree->rightChild);
    		printf("%d\t",tree->data);
    	}
    }
    
    //非递归 算法
    
    void preOrderTraverse1(Tree t){
    	linkStack stack;
    	stackInit(&stack);
    	stackPush(&stack,t);
    	while (!stackEmpty(stack))
    	{
    		while (stackGetTop(stack,&t) && t)
    		{
    			printf("%d\t",t->data);
    			stackPush(&stack,t->leftChild);
    		}
    		stackPop(&stack,&t);//NULL 出栈
    		if (!stackEmpty(stack))
    		{
    			stackPop(&stack,&t);
    			stackPush(&stack,t->rightChild);
    		}
    	}
    	stackDestory(&stack);
    }
    
    void preOrderTraverse2(Tree tree){
    	linkStack stack;
    	stackInit(&stack);
    	while (tree || !stackEmpty(stack))
    	{
    		if (tree)
    		{
    			printf("%d\t",tree->data);
    			stackPush(&stack,tree);
    			tree = tree->leftChild;
    		}
    		else
    		{
    			stackPop(&stack,&tree);
    			tree = tree->rightChild;
    		}
    	}
    	stackDestory(&stack);
    }
    
    void preOrderTraverse3(Tree tree){
    	if (tree != NULL)
    	{
    		linkStack stack;
    		stackInit(&stack);
    		stackPush(&stack,tree);
    		while (!stackEmpty(stack))
    		{
    			stackPop(&stack,&tree);
    			printf("%d\t",tree->data);
    			if (tree->rightChild != NULL)
    			{
    				stackPush(&stack,tree->rightChild);
    			}
    			if (tree->leftChild != NULL)
    			{
    				stackPush(&stack,tree->leftChild);
    			}
    		}
    	}
    }
    
    //中序非递归
    void inOrderTraverse1(Tree tree){
    	linkStack stack;
    	stackInit(&stack);
    	stackPush(&stack,tree);
    	while (!stackEmpty(stack))
    	{
    		while (stackGetTop(stack,&tree) && tree) stackPush(&stack,tree->leftChild);
    		stackPop(&stack,&tree);
    		if (!stackEmpty(stack))
    		{
    			stackPop(&stack,&tree);
    			printf("%d\t",tree->data);
    			stackPush(&stack,tree->rightChild);
    		}
    	}
    	stackDestory(&stack);
    }
    
    void inOrderTraverse2(Tree tree){
    	linkStack stack;
    	stackInit(&stack);
    	while (tree || !stackEmpty(stack))
    	{
    		if (tree)
    		{
    			stackPush(&stack,tree);
    			tree = tree->leftChild;
    		}
    		else
    		{
    			stackPop(&stack,&tree);
    			printf("%d\t",tree->data);
    			tree = tree->rightChild;
    		}
    	}
    	stackDestory(&stack);
    }
    
    
    
    void postOrderTraverse1(Tree tree){
    	if (tree != NULL)
    	{
    		linkStack stack;
    		stackInit(&stack);
    		stackPush(&stack,tree);
    		Tree pre = NULL;
    		while (!stackEmpty(stack))
    		{
    			stackGetTop(stack,&tree);
    			//左右子树都为空,或者 左子树刚访问过,并且 右子树为空,或者 刚访问过 右子树. 可以直接访问
    			if ((tree->leftChild == NULL && tree->rightChild == NULL) || (pre != NULL && (tree->leftChild == pre || tree->rightChild == pre)))
    			{
    				printf("%d\t",tree->data);
    				stackPop(&stack,&tree);
    				pre = tree;
    			}
    			else
    			{
    				if (tree->rightChild != NULL)
    				{
    					stackPush(&stack,tree->rightChild);
    				}
    			    if(tree->leftChild != NULL)
    				{
    					stackPush(&stack,tree->leftChild);
    				}
    			}
    		}
    	}
    }
    
    //层序
    //利用队列
    void levelOrderTraverse(Tree tree){
    	if (tree != NULL)
    	{
    		LinkQueue queue;
    		queueInit(&queue);
    		enqueue(&queue,tree);
    		while (dequeue(&queue,&tree) && tree)
    		{
    			printf("%d\t",tree->data);
    			if (tree->leftChild != NULL)
    			{
    				enqueue(&queue,tree->leftChild);
    			}
    			if (tree->rightChild != NULL)
    			{
    				enqueue(&queue,tree->rightChild);
    			}
    		}
    		queueDestory(&queue);
    	}
    }
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	Tree tree;
    	printf("---------------创建树(先序,0代表子树为空)-----------------\n");
    	treeCreate(&tree);
    	printf("------------先序递归遍历----------------\n");
    	preOrderTraverse(tree);
    	printf("------------先序非递归遍历1----------------\n");
    	preOrderTraverse1(tree);
    	printf("------------先序非递归遍历2----------------\n");
    	preOrderTraverse2(tree);
    	printf("------------先序非递归遍历3----------------\n");
    	preOrderTraverse3(tree);
    	printf("\n------------中序递归遍历----------------\n");
    	inOrderTraverse(tree);
    	printf("\n------------中序非递归遍历1----------------\n");
    	inOrderTraverse1(tree);
    	printf("\n------------中序非递归遍历2----------------\n");
    	inOrderTraverse2(tree);
    	printf("\n------------后序递归遍历----------------\n");
    	postOrderTraverse(tree);
    	printf("\n------------后序非递归遍历1----------------\n");
    	postOrderTraverse1(tree);
    	printf("\n------------层序遍历----------------\n");
    	levelOrderTraverse(tree);
    	//及时释放内存是个好习惯..
    	treeDestory(&tree);
    	return 0;
    }
    
    运行截图:



    展开全文
  • 数据结构-二叉树-二叉链表-先序遍历-中序遍历-后序遍历-递归-非递归 //代码附有详细注释,完整代码在我的资源中有 定义常量 #define stackinitsize 100 #define OK 1 #define ERROR 0 #define OVERFLOW -1 给元素起...

    数据结构-二叉树-二叉链表-先序遍历-中序遍历-后序遍历-递归-非递归
    //代码附有详细注释,完整代码在文章最后。

    定义常量

    #define stackinitsize 100
    #define OK 1
    #define ERROR 0
    #define OVERFLOW -1
    

    给元素起一个别名,如果需要更换元素类型只需要更改一处地方,并且写代码时ElemType比int更容易理解。

    typedef int TElemType ;   //元素类型 int 
    typedef int Status;       //状态
    

    二叉树的二叉链表存储表示

    //二叉树的二叉链表存储表示	
    typedef struct BiTNode
    {
    	TElemType data;
    	struct BiTNode *lchild, *rchild; //左右孩子指针
    }BiTnode,*BiTree;
    
    typedef struct{
    //该堆栈的元素是指针类型的
    //base和top均是指向指针的指针
    	BiTnode **base;    //二级指针
    	BiTnode **top;
    	int stacksize;
    }sqstack;              //堆栈结构
    

    基本操作的函数原型说明(部分)

    //	基本操作的函数原型说明(部分)	
    Status CreateBitree(BiTree &T);
         //按先序次序输入二叉树中结点的值(一个字符),#字符表示空树。 
         //构造二叉链表表示的二叉树T.
    Status PreOrderTraverse(BiTree T,Status(*Visit)(TElemType e));
         //采用二叉链表存储结构,visit是对结点操作的应用函数。
         //先序遍历二叉树T,对每个结点调用函数Visit 一次且仅一次。 
         //一旦visit()失败,则操作失败。
    Status lnorderTraverse(BiTree T,Status(*Visit)(TElemType e));
         //采用二叉链表存储结构,Visit是对结点操作的应用函数。
         //中序遍历二叉树T,对每个结点调用函数Visit 一次且仅一次。 
         //一旦visit()失败,则操作失败。
    Status PostorderTraverse(BiTree T,Status(*Visit)(TElemType e));
         //采用二叉链表存储结构,visit是对结点操作的应用函数。
         //后序遍历二叉树T,对每个结点调用函数Visit 一次且仅一次。 
         //一旦visit()失败,则操作失败。
    Status LevellOrderTraverse(BiTree T,Status(*Visit)(TElemType e));
         //采用二又链表存储结构,Visit是对结点操作的应用函数。 
         //层序遍历二叉树T,对每个结点调用函数Visit 一次且仅一次。
         //—旦visit()失败,则操作失败
    

    初始化堆栈

    //初始化堆栈
    void lnitStack(sqstack &s) //形参s为引用
    {
    	s.base=(BiTnode**) malloc (stackinitsize* sizeof (BiTree)); //生成stackinitsize数量内存空间来存放二级指针
    	if (!s.base) return ;
    	s.top=s.base;  //空栈:栈底和栈顶相等
    	s.stacksize=100;
    	return ;
    }
    

    压栈,出栈函数以及栈空判别

    //将元素压入堆栈 
    void Push(sqstack &s, BiTnode *e) //形参e为指针变量
    {
    	*s.top++=e;
    }
    
    //弹栈
    void Pop(sqstack &s, BiTnode **e) //e为二级指针,因为栈中存放的是指针
    {
    	*e=*--s.top;
    }
    
    int StackEmpty(sqstack s) //栈空判别
    {
    	return (s.top==s.base);//栈顶和栈底相等时栈为空
    }
    

    取栈顶元素

    //取栈顶元素
    Status GetTop(sqstack s, BiTnode **e)
    {
    	if (s.top==s.base) return ERROR;
    	*e=*(s.top-1);
    	return OK;
    }
    

    创建二叉树,输入按先序次序输入(一个字符),#表示空字符

    //按先序次序输入二叉树中结点的值(一个字符),#字符表示空树。 
    //构造二叉链表表示的二叉树T.
    Status CreateBiTree(BiTree &T)//引用
    {
    	char ch;
    	ch=getchar();
    	if ( ch == '#' )T=NULL;
    	else 
    	{
    		if (!(T=(BiTnode *) malloc (sizeof(BiTnode)))) return (OVERFLOW);
    		T->data=ch;	             //生成根结点
    		CreateBiTree(T->lchild); //构造左子树
    		CreateBiTree(T->rchild); //构造右子树
    	}
    	return OK;
    } 
    

    先序遍历二叉树的递归算法

    Status PreOrderTraverse(BiTree T, Status(*Visit)(TElemType e) )   //第二个参数为调用函数
         //采用二叉链表存储结构,visit是对数据元素操作的应用函数
         //先序遍历二叉树T的递归算法,对每个数据元素调用函数visit.
         //调用实例:PreOrderTraverse(T,printElement);
    {
    	if(T)
    	{
    		if (Visit(T->data))                            //访问根节点的数据域
    			if ( PreOrderTraverse(T->lchild, Visit) )  //前序遍历左子树
    				if (PreOrderTraverse(T->rchild,Visit)) //前序遍历右子树
    					return OK;                         //表示根节点左孩子和右孩子都存在
    				return ERROR;                          //碰到叶子结点即终端节点
    	}else return OK;        
    }
    

    中序遍历二叉树的递归算法

    //中序遍历二叉树T的递归算法
    Status lnOrderTraverse(BiTree T, Status(*Visit)(TElemType e) )
    {
    	if (T)
    	{
    		if (lnOrderTraverse(T->lchild,Visit))        //遍历左子树
    			if (Visit(T->data))                      //访问根节点的数据域
    				if (lnOrderTraverse(T->rchild,Visit))//遍历右子树
    					return OK;
    				return ERROR;
    	}
    	else return OK;
    } //preOrderTraVerse
    

    后序遍历二叉树的递归算法

    //后序遍历二叉树T的递归算法
    Status PostOrderTraverse(BiTree T, Status(*Visit)(TElemType e))
    {
    	if(T){
    		if (PostOrderTraverse(T->lchild,Visit))      //遍历左子树
    			if (PostOrderTraverse(T->rchild,Visit))  //遍历右子树
    				if (Visit(T->data))                  //访问根节点的数据域
    					return OK;        
    				return ERROR;
    	}else return OK;
    }
    

    输出元素的值

    //输出元素e的值
    Status PrintElement(TElemType e)
    { 
    	printf("%c",e);
    	return OK;
    }
    

    中序遍历二叉树T的非递归算法1

    //中序遍历二叉树T的非递归算法
    Status lnorderTraverseNoRecursion1(BiTree T, Status(*Visit)(TElemType e))
    {
    	sqstack s;
    	BiTree p;
    	lnitStack(s);  //初始化链表
    	p=T;
    	while (p || !StackEmpty(s))
    	{
    		if (p)
    		{ 
    			Push(s,p);  //根指针进栈
    			p=p->lchild;//遍历左子树
    		} 
    			else
    		{
    			Pop(s, &p);         //根指针退栈
    			if (!Visit(p->data))//访问根结点
    				return ERROR; 
    			p=p->rchild;        //遍历右子树
    		}//else
    	}//while
    	return OK;
    } 
    

    中序遍历二叉树的非递归算法2

    //中序遍历二叉树T的非递归算法2
    Status lnorderTraverseNoRecursion2(BiTree T,Status(*Visit)(TElemType e))
    {
    	sqstack s;
    	BiTree p;
    	lnitStack(s);
    	Push(s, T);
    	while (!StackEmpty(s))
    	{
    		while (GetTop(s, &p) && p) 
    			Push(s, p->lchild);   //向左走到尽头
    		Pop(s, &p);	              //空指针退栈
    		if (!StackEmpty(s))
    		{	                       //访问结点,向右一步
    			Pop(s, &p); 
    			if (!Visit(p->data)) 
    				return ERROR;
    			Push(s, p->rchild);
    		}//if
    	} //while
    	return OK;
    }
    

    主函数,输入实例:ab##c##

    void main()
    {
    	BiTree t;
    	printf("\n请按先序遍历输入二叉树(当左右子树为空时用#输入)\n");
    	CreateBiTree(t);
    	printf ("\n该二叉树的先序遍历为:\n"); 
    	PreOrderTraverse(t,PrintElement);
    	printf ("\n该二叉树的中序遍历为:\n");
    	lnOrderTraverse(t,PrintElement);
    	printf ("\n该二叉树的后序遍历为:\n");
    	PostOrderTraverse(t,PrintElement);
    	printf ("\n该二叉树的中序遍历为:(用非递归调用l)\n");
    	lnorderTraverseNoRecursion1(t,PrintElement);
    	printf ("\n该二叉树的中序遍历为:(用非递归调用2)\n");
    	lnorderTraverseNoRecursion2(t,PrintElement);
    	printf("\n");
    }
    

    最后,如果觉得这篇博客能帮助到你,请点个小小的支持一下我(收藏也行呀,嘻嘻),这是我继续更新的动力呀,关注我可以得到第一时间的更新,更加快人一步哦。
    如果有问题请在评论区留言,一起交流进步。
    附完整代码

    #include "stdio.h"
    #include "stdlib.h"
    
    #define stackinitsize 100
    #define OK 1
    #define ERROR 0
    #define OVERFLOW -1
    
    typedef int TElemType ;   //元素类型 int 
    typedef int Status;       //状态
    
    //二叉树的二叉链表存储表示	
    typedef struct BiTNode
    {
    	TElemType data;
    	struct BiTNode *lchild, *rchild; //左右孩子指针
    }BiTnode,*BiTree;
    
    typedef struct{
    //该堆栈的元素是指针类型的
    //base和top均是指向指针的指针
    	BiTnode **base;    //二级指针
    	BiTnode **top;
    	int stacksize;
    }sqstack;              //堆栈结构
    
    //	基本操作的函数原型说明(部分)	
    Status CreateBitree(BiTree &T);
         //按先序次序输入二叉树中结点的值(一个字符),#字符表示空树。 
         //构造二叉链表表示的二叉树T.
    Status PreOrderTraverse(BiTree T,Status(*Visit)(TElemType e));
         //采用二叉链表存储结构,visit是对结点操作的应用函数。
         //先序遍历二叉树T,对每个结点调用函数Visit 一次且仅一次。 
         //一旦visit()失败,则操作失败。
    Status lnorderTraverse(BiTree T,Status(*Visit)(TElemType e));
         //采用二叉链表存储结构,Visit是对结点操作的应用函数。
         //中序遍历二叉树T,对每个结点调用函数Visit 一次且仅一次。 
         //一旦visit()失败,则操作失败。
    Status PostorderTraverse(BiTree T,Status(*Visit)(TElemType e));
         //采用二叉链表存储结构,visit是对结点操作的应用函数。
         //后序遍历二叉树T,对每个结点调用函数Visit 一次且仅一次。 
         //一旦visit()失败,则操作失败。
    Status LevellOrderTraverse(BiTree T,Status(*Visit)(TElemType e));
         //采用二又链表存储结构,Visit是对结点操作的应用函数。 
         //层序遍历二叉树T,对每个结点调用函数Visit 一次且仅一次。
         //—旦visit()失败,则操作失败
    
    //初始化堆栈
    void lnitStack(sqstack &s) //形参s为引用
    {
    	s.base=(BiTnode**) malloc (stackinitsize* sizeof (BiTree)); //生成stackinitsize数量内存空间来存放二级指针
    	if (!s.base) return ;
    	s.top=s.base;  //空栈:栈底和栈顶相等
    	s.stacksize=100;
    	return ;
    }
    
    //将元素压入堆栈 
    void Push(sqstack &s, BiTnode *e) //形参e为指针变量
    {
    	*s.top++=e;
    }
    
    //弹栈
    void Pop(sqstack &s, BiTnode **e) //e为二级指针,因为栈中存放的是指针
    {
    	*e=*--s.top;
    }
    
    
    int StackEmpty(sqstack s) //栈空判别
    {
    	return (s.top==s.base);//栈顶和栈底相等时栈为空
    }
    
    //取栈顶元素,即指针
    Status GetTop(sqstack s, BiTnode **e)
    {
    	if (s.top==s.base) return ERROR;
    	*e=*(s.top-1);
    	return OK;
    }
    
    //按先序次序输入二叉树中结点的值(一个字符),#字符表示空树。 
    //构造二叉链表表示的二叉树T.
    Status CreateBiTree(BiTree &T)//引用
    {
    	char ch;
    	ch=getchar();
    	if ( ch == '#' )T=NULL;
    	else 
    	{
    		if (!(T=(BiTnode *) malloc (sizeof(BiTnode)))) return (OVERFLOW);
    		T->data=ch;	             //生成根结点
    		CreateBiTree(T->lchild); //构造左子树
    		CreateBiTree(T->rchild); //构造右子树
    	}
    	return OK;
    } 
    
    
    Status PreOrderTraverse(BiTree T, Status(*Visit)(TElemType e) )   //第二个参数为调用函数
         //采用二叉链表存储结构,visit是对数据元素操作的应用函数
         //先序遍历二叉树T的递归算法,对每个数据元素调用函数visit.
         //调用实例:PreOrderTraverse(T,printElement);
    {
    	if(T)
    	{
    		if (Visit(T->data))                            //访问根节点的数据域
    			if ( PreOrderTraverse(T->lchild, Visit) )  //前序遍历左子树
    				if (PreOrderTraverse(T->rchild,Visit)) //前序遍历右子树
    					return OK;                         //表示根节点左孩子和右孩子都存在
    				return ERROR;                          //碰到叶子结点即终端节点
    	}else return OK;        
    }
    
    //中序遍历二叉树T的递归算法
    Status lnOrderTraverse(BiTree T, Status(*Visit)(TElemType e) )
    {
    	if (T)
    	{
    		if (lnOrderTraverse(T->lchild,Visit))        //遍历左子树
    			if (Visit(T->data))                      //访问根节点的数据域
    				if (lnOrderTraverse(T->rchild,Visit))//遍历右子树
    					return OK;
    				return ERROR;
    	}
    	else return OK;
    } //preOrderTraVerse
    
    //后序遍历二叉树T的递归算法
    Status PostOrderTraverse(BiTree T, Status(*Visit)(TElemType e))
    {
    	if(T){
    		if (PostOrderTraverse(T->lchild,Visit))      //遍历左子树
    			if (PostOrderTraverse(T->rchild,Visit))  //遍历右子树
    				if (Visit(T->data))                  //访问根节点的数据域
    					return OK;        
    				return ERROR;
    	}else return OK;
    }
    
    //输出元素e的值
    Status PrintElement(TElemType e)
    { 
    	printf("%c",e);
    	return OK;
    }
    
    //中序遍历二叉树T的非递归算法
    Status lnorderTraverseNoRecursion1(BiTree T, Status(*Visit)(TElemType e))
    {
    	sqstack s;
    	BiTree p;
    	lnitStack(s);  //初始化链表
    	p=T;
    	while (p || !StackEmpty(s))
    	{
    		if (p)
    		{ 
    			Push(s,p);  //根指针进栈
    			p=p->lchild;//遍历左子树
    		} 
    			else
    		{
    			Pop(s, &p);         //根指针退栈
    			if (!Visit(p->data))//访问根结点
    				return ERROR; 
    			p=p->rchild;        //遍历右子树
    		}//else
    	}//while
    	return OK;
    } 
    
    //中序遍历二叉树T的非递归算法2
    Status lnorderTraverseNoRecursion2(BiTree T,Status(*Visit)(TElemType e))
    {
    	sqstack s;
    	BiTree p;
    	lnitStack(s);
    	Push(s, T);
    	while (!StackEmpty(s))
    	{
    		while (GetTop(s, &p) && p) 
    			Push(s, p->lchild);   //向左走到尽头
    		Pop(s, &p);	              //空指针退栈
    		if (!StackEmpty(s))
    		{	                       //访问结点,向右一步
    			Pop(s, &p); 
    			if (!Visit(p->data)) 
    				return ERROR;
    			Push(s, p->rchild);
    		}//if
    	} //while
    	return OK;
    }
    
    void main()
    {
    	BiTree t;
    	printf("\n请按先序遍历输入二叉树(当左右子树为空时用#输入)\n");
    	CreateBiTree(t);
    	printf ("\n该二叉树的先序遍历为:\n"); 
    	PreOrderTraverse(t,PrintElement);
    	printf ("\n该二叉树的中序遍历为:\n");
    	lnOrderTraverse(t,PrintElement);
    	printf ("\n该二叉树的后序遍历为:\n");
    	PostOrderTraverse(t,PrintElement);
    	printf ("\n该二叉树的中序遍历为:(用非递归调用l)\n");
    	lnorderTraverseNoRecursion1(t,PrintElement);
    	printf ("\n该二叉树的中序遍历为:(用非递归调用2)\n");
    	lnorderTraverseNoRecursion2(t,PrintElement);
    	printf("\n");
    }
    
    展开全文
  • 使用二叉树的层次遍历改造二叉链表
  • 创建一个有十二个节点的二叉树,先序遍历的实现,中序遍历的递归实现,后序遍历的递归实现,层次遍历的实现
  • 采用二叉链表结构实现二叉树,并以递归遍历思想实现二叉树的创建、二叉树的遍历(先序、中序、后序和层次遍历)、二叉树叶子节点统计、二叉树深度统计的算法;同时,结合课件和实例代码,实现二叉树的中序非递归遍历...
  • 用递归方法将一个按照层次遍历顺序存放在数组的二叉树转换为按照二叉链表存储的二叉树。 #include<iostream> #include<cstring> char BT[] = "ABCD#EF"; int n = strlen(BT); using namespace std; ...
  • 非递归解法如下: 输入:ABD^^EG^^^C^F^^ ...△层次遍历 A B C D E F G   #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;stack&gt; #include&lt...
  • 对于二叉树,有深度遍历和广度遍历,深度遍历有前序、中序以及后序三种遍历方法,广度遍历即我们寻常所说的层次遍历,如图: 因为树的定义本身就是递归定义,所以对于前序、中序以及后序这三种遍历...
  • 利用二叉树的二叉链表存储结构实现二叉树层次遍历操作 二叉树采用二叉链表结构表示。设计并实现如下算法:输入某棵二叉树的广义表形式,建立该二叉树,并按层次遍历该二叉树----队列形式   #include #include ...
  • 已知二叉树的中序遍历序列与层次遍历序列分别将值存于数组A[1-n]、B[1-n]中,请编程建立二叉树的二叉链表。 二叉树结点定义 typedef struct { Elemtype data; BiNode* lchild,rchild; }BiNode,*BiTree;
  • /* 基于层次遍历的非递归复制二叉链表 */ 二叉链表类型定义: typedef char TElemType; // 设二叉树的元素为char类型 typedef struct BiTNode {  TElemType data;  BiTNode *lchild, *rchild; } ...
  • 层序遍历二叉链表 (25 分)

    千次阅读 2018-10-31 21:27:12
    层序遍历二叉链表 (25 分) 设计程序,按先序创建二叉树的二叉链表;然后层序遍历二叉树。 输入格式: 按先序输入一棵二叉树。二叉树中每个结点的键值用字符表示,字符之间不含空格。注意空树信息也要提供,以#字符...
  • } void PrintfTree(BiTree root, int h) //按树状打印二叉树,先右后左中序遍历树 { //结点的横向位置有结点在树中的层次决定,h表示结点的层次,控制结点输出左右位置 if(root == NULL) return; PrintfTree(root->...
  • 103.二叉树的锯齿形层次遍历 给定一个二叉树,返回其节点值的锯齿形层次遍历。(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。 广度优先遍历,用到队列,不同的层遍历顺序不同,所以要...
  • PAGE PAGE #/ 8 一实验题目建立二叉树二叉链表存储结构实现有关操作 二...(5)层次遍历二叉树 三需求分析 我选做以上的 2.3 两小问 (1)建立二叉链表树 先序遍历二叉树 : 若二叉树为空 ,则空操作 ;否则先访问根结点 ,再先
  • 二叉链表的链式数据结构为: typedef struct BTreeNode { DataType data; struct BTreeNode * lchild; struct BTreeNode * rchild; }*BTree,BTreeNode; 在对二叉树进行非递归遍历的时候需要用到栈来保存结点或者...
  • //层次遍历建立一棵树(孩子兄弟二叉链表) CSTree CreateTree() {  CSTree T,p,r;  int fa,ch;  LinkQueue Q;  int n;  printf("请输入创建树的结点的个数\n");  scanf("%d",&n);  if(n==...
  • . 实 验 报 告 一 实验目的 1.... 将一颗二叉树的所有左右子树进行交换 三 实验与算法分析 二叉树的遍历 二叉树的层次遍历采用的是队列本题用一个一维数组来代替队列同时设置队列的对头指针和队尾指针 算法分析自定义3
  • 二叉树的先序递归,后序递归,中序递归遍历,按层次遍历
  • 创建一棵二叉树,以二叉链表作存储结构,实现先根遍历算法
  • 用二叉树链表作为存储结构,完成二叉树的建立,先序、中序和后序以及按层次遍历的操作,求所有叶子及结点总数的操作 #include #include #include using namespace std; typedef int Elemtype; typedef ...
  • 层序建立二叉链表 (20 分) 本题要求实现一个函数,给定一棵二叉树的层序序列,创建该树的二叉链表。 函数接口定义: BinTree CreatBinTree(); 函数CreatBinTree从标准输入读入一棵二叉树的层序序列,创建二叉树的...
  • 1.二叉树的存储结构之二叉链表 1.1以先序序列输入二叉树中结点的值,并构建该二叉树! 2.遍历二叉树 2.1前、中、后序的递归遍历算法 2.2前、中、后序的非递归遍历算法(栈) 2.3按层遍历二叉树(队列)     ...
  • 1 二叉树的二叉链表示意图   二叉链表的每个结点由三个域组成:数据域,左指针域和右指针域。左右指针分别用来保存左右孩子结点的存储地址。 2 二叉链表实现二叉树 2.1 头文件及其定义
  • #include<stdio.h> #include<stdlib.h> #define SIZE sizeof(struct tree) struct tree { char data; struct tree *rchild,*lchild; }; void creattree(struct tree**...void printtree1(struct tree*...
  • 建立二叉链表.cpp

    2019-11-04 10:29:43
    数据结构二叉树算法相关包括建立二叉树,和前序遍历二叉树,中序遍历二叉树,后序遍历二叉树,层次遍历二叉树,求二叉树高度,求二叉树子叶。。。
  • 二叉链表

    2011-06-08 14:03:00
    二叉树数据元素类型为整型,以二叉链表为存储结构。试编程实现: ⑴ 生成一棵二叉树. ⑵ 用递归算法、非递归算法实现二叉树的遍历; ⑶ 求度分别为0、1、2的结点的数目,分别用递归算法、非递归算法实现; ⑷ 按层次...
  • 7-9 玩转二叉链表 (25分) 设计程序,按先序创建二叉树的二叉链表;然后先序、中序、后序遍历二叉树。 输入格式: 按先序输入一棵二叉树。二叉树中每个结点的键值用字符表示,字符之间不含空格。注意空树信息也要提供...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,607
精华内容 4,242
关键字:

二叉链表层次遍历