精华内容
下载资源
问答
  • 设计算法,将给定二叉树的叶子结点连成一个带头结点单链表,并要求叶子结点按照从左到右顺序插入,而排列顺序为从右到左(逆置)单链表。 #include<stdio.h> #include<iostream> using namespace ...

    @【数据结构】(二叉树叶子节点构造单链表)

    设计算法,将给定二叉树的叶子结点连成一个带头结点的单链表,并要求叶子结点按照从左到右的顺序插入,而排列顺序为从右到左(逆置)的单链表。

    #include<stdio.h>
    #include<iostream>
    using namespace std;
    
    #define MAX 100
    
    typedef char Elemtype;
    typedef struct tNode
    {
    	Elemtype data;
    	struct tNode *lchild, *rchild;
    }BiTNode, *BiTree;
    typedef struct node
    {
    	Elemtype data;
    	struct node *next;
    }StackNode, *LinkStack;
    LinkStack push(LinkStack top, Elemtype x)
    {
    	StackNode *s;
    	s = (StackNode*)malloc(sizeof(StackNode));
    	s->data = x;
    	s->next = top; top = s;   //新结点插入链表
    	return top;
    }
    LinkStack top = NULL;
    BiTNode *createtree()
    {
    	BiTNode *T;
    	char str;
    	str = getchar();
    	if (str == '#')
    		return NULL;
    	else
    	{
    		T = (BiTNode*)malloc(sizeof(BiTNode));
    		T->data = str;
    		T->lchild = createtree();
    		T->rchild = createtree();
    		return T;
    	}
    
    }
    void OutputLinkstack(LinkStack top)
    {
    	StackNode *s;
    	s = top;
    	while (s != NULL)
    	{
    		cout << s->data << "   ";
    		s = s->next;
    	}
    
    	cout << endl;
    }
    void preorder(BiTNode *bt, LinkStack &top)
    {
    	if (bt == NULL)
    		return;
    	if (bt->rchild == NULL && bt->lchild == NULL)
    		top=push(top, bt->data);
    	preorder(bt->lchild,top);
    	preorder(bt->rchild,top);
    	
    }
    void main()
    {
    	LinkStack top = NULL;
    	BiTNode *bt;
    	cout << "创建二叉树" << endl;
    	cout << "请以先序序列输入节点的值,为空时输入'#':" << endl;
    	bt = createtree();
    	cout << "二叉树的叶子结点置逆链表为:" << endl;
    	preorder(bt, top);
    	OutputLinkstack(top);
    	cout << endl;
    	system("pause");
    }
    
    

    测试二叉树:
    在这里插入图片描述
    结果:
    在这里插入图片描述

    展开全文
  • Java构造二叉树,遍历,叶子节点,高度,二叉树左右视图节点node构造二叉树方法 遍历,叶子节点,高度,二叉树左右视图 节点node package Study_1; public class Node { private Object val; Node left; ...

    Java构造二叉树,遍历,叶子节点,高度,二叉树的左右视图

    节点node

    package Study_1;
    
    public class Node {
        private Object  val;
        Node left;
        public Node right;
        public Node(Object val) {
            this.val = val;
        }
        public Node(Node left, Node node, Node right, Object val) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
        public String toString(){
            return "[ "+val+" ]";
        }
    }
    
    
    

    构造二叉树方法 遍历,叶子节点,高度,二叉树的左右视图

    package Study_1;
    
    import javax.swing.tree.TreeNode;
    import java.util.ArrayList;
    import java.util.List;
    
    public class BinaryTree {
        private Node root;
    
        public BinaryTree(Object Data) {
            this.root = new Node(Data);
        }
        //二叉树的右视图
        List<Object> num = new ArrayList<>();
        public List<Object> rightSideView(Node root) {
    
            dfs(root,0);
            return num;
        }
        public void dfs(Node root,int depth){
            if(root==null){
                return;
            }
            if(depth == num.size()){
                num.add(root.getVal());
            }
            depth++;
            dfs(root.left,depth);
            dfs(root.right,depth);
    
        }
    
        //
        public Node add(Node parentNode, Object data, Boolean isLeft) {
            if (parentNode == null) {
                throw new RuntimeException("父节点为空,无法添加子节点");
            }
            if (isLeft && parentNode.left != null) {
                throw new RuntimeException("左节点已存在,无法添加");
            }
            if (!isLeft && parentNode.right != null) {
                throw new RuntimeException("右节点已存在,添加失败");
            }
            Node newNode = new Node(data);
            if (isLeft) {
                parentNode.left = newNode;
            } else {
                parentNode.right = newNode;
            }
            return newNode;
        }
        //先序遍历
        public List<Node> preBinaryTree() {
            return preTrase(root);
        }
    
        public List<Node> preTrase(Node node) {
            List<Node> list = new ArrayList<>();
            list.add(node);
            if(node.left!=null){
                list.addAll(preTrase(node.left));
            }
            if(node.right!=null){
                list.addAll(preTrase(node.right));
            }
            return list;
        }
        //后序遍历
        public List<Node> last_tree(){
            return last(root);
        }
        public List<Node> last(Node root){
            List<Node> list = new ArrayList<>();
            if(root.left!=null){
                list.addAll(last(root.left));
            }
            if(root.right!=null){
                list.addAll(last(root.right));
            }
            list.add(root);
            return list;
        }
        //中序遍历
        public List<Node> middle(){
            return middleTree(root);
        }
        public List middleTree(Node root){
            List<Node> list = new ArrayList<>();
    
            if(root.left!=null){
                list.addAll(middleTree(root.left));
            }
            list.add(root);
            if(root.right!=null){
                list.addAll(middleTree(root.right));
            }
            return list;
    
        }
        public int numLeaves(Node root){
            if(root==null){
                return 0;
            }
            if(root.left==null&&root.right==null)
            {
                System.out.println(root);
                return 1;
            }
            return (root.left==null?0:numLeaves(root.left))+(root.right==null?0:numLeaves(root.right));
        }
        public int height(Node root){
    
            if(root==null)
                return -1;
            int leftHeight = root.left==null?0:height(root.left);
            int rightHeight = root.right==null?0:height(root.right);
            return Math.max(leftHeight,rightHeight)+1;
        }
        public static void main(String[] args) {
            BinaryTree binaryTree = new BinaryTree("根节点");
            Node t1 = binaryTree.add(binaryTree.root,"左节点",true);
            Node t2 = binaryTree.add(binaryTree.root,"右节点",false);
            Node t12 = binaryTree.add(t1,"左节点的右节点",false);
            Node t21  = binaryTree.add(t2,"右节点的左节点",true);
            Node t3  = binaryTree.add(t21,"右节点的左节点的左节点",true);
           System.out.println(binaryTree.preBinaryTree());
            System.out.println(binaryTree.middle());
            System.out.println(binaryTree.last_tree());
            System.out.println("叶子节点数为:"+binaryTree.numLeaves(binaryTree.root));
            System.out.println("树的高度为:"+binaryTree.height(binaryTree.root));
            System.out.println("树的右视图"+binaryTree.rightSideView(binaryTree.root));
        }
    }
    
    
    展开全文
  • 二叉树的构造方法不一,这里根据存储结点次序的数字关系来构造父节点和孩子结点的关系(parentIndex*2+1==leftChildIndex,parentIndex*2+2==leftRightIndex),关于二叉树非递归遍历的详细介绍请看 二叉树的建立与...

    二叉树的构造方法不一,这里根据存储结点次序的数字关系来构造父节点和孩子结点的关系(parentIndex*2+1==leftChildIndex,parentIndex*2+2==leftRightIndex),关于二叉树非递归遍历的详细介绍请看 二叉树的建立与遍历,下面程序还实现了查找叶子节点、查找某一元素是否存在的功能。

    import java.util.LinkedList;
    import java.util.List;
    import java.util.Scanner;
    import java.util.Stack;
    
    public class TestBinaryTree {
    	private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    	private static List<Node> nodeList = null;
    
    	private static class Node {
    		int value;
    		Node leftChild;
    		Node rightChild;
    
    		public Node(int value) {
    			this.value = value;
    			leftChild = null;
    			rightChild = null;
    		}
    	}
    
    	/*
    	 * 将给定的数组元素作为节点赋值到链表nodeList, 然后按照 array.length/2-1 个父节点与其孩子节点在链表的下标关系,
    	 * 构造二叉树。注意最后一个父节点可能没有右孩子节点,需特殊处理。
    	 */
    	public Node createBinTree() {
    		nodeList = new LinkedList<Node>();
    		for (int i = 0; i < array.length; i++) {
    			nodeList.add(new Node(array[i]));
    		}
    		for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {
    			nodeList.get(parentIndex).leftChild = nodeList.get(parentIndex * 2 + 1);
    			nodeList.get(parentIndex).rightChild = nodeList.get(parentIndex * 2 + 2);
    		}
    
    		int lastParentIndex = array.length / 2 - 1;
    		nodeList.get(lastParentIndex).leftChild = nodeList.get(lastParentIndex * 2 + 1);
    		if (array.length % 2 == 1) {
    			nodeList.get(lastParentIndex).rightChild = nodeList.get(lastParentIndex * 2 + 2);
    		}
    		return nodeList.get(0);
    	}
    
    	/*
    	 * 0 对二叉树进行先根、中根和后根顺序深度地遍历并输出(非递归), 这里借助栈来保存遍历过程中的节点
    	 */
    	public void preOderTraverse(Node root) {
    		if (root == null)
    			return;
    		Stack<Node> nodeStack = new Stack<>();
    		Node temp = root;
    		nodeStack.push(temp);
    		while (!nodeStack.isEmpty()) {
    			temp = nodeStack.pop();
    			if (temp != null) {
    				System.out.print(temp.value + " ");
    				nodeStack.push(temp.rightChild);
    				nodeStack.push(temp.leftChild);
    			}
    		}
    	}
    
    	public void inOderTraverse(Node root) {
    		if (root == null)
    			return;
    		Stack<Node> nodeStack = new Stack<>();
    		Node temp = root;
    		while ((temp != null) || (!nodeStack.empty())) {
    			while (temp != null) {
    				nodeStack.push(temp);
    				temp = temp.leftChild;
    			}
    			temp = nodeStack.pop();
    			System.out.print(temp.value + " ");
    			temp = temp.rightChild;
    		}
    	}
    
    	private void aftOderTraverse(Node root) {
    		if (root == null)
    			return;
    		Stack<Node> nodeStack = new Stack<>();
    		Node temp = root;
    		while ((temp != null) || (!nodeStack.empty())) {
    			while (temp != null) {
    				nodeStack.push(temp);
    				temp = temp.leftChild != null ? temp.leftChild : temp.rightChild;
    			}
    			temp = nodeStack.pop();
    			System.out.print(temp.value + " ");
    			if ((!nodeStack.empty()) && (temp == nodeStack.peek().leftChild)) {
    				temp = nodeStack.peek().rightChild;
    			} else {
    				temp = null;
    			}
    		}
    	}
    
    	/*
    	 * 统计二叉树的叶子节点个数并输出叶子节点的数据, 思路是递归地访问所有结点,判定其是否是叶子节点(有无孩子节点)
    	 */
    	public int findLeafNode(Node root) {
    		int count;
    		if (root == null)
    			count = 0;
    		else if ((root.leftChild == null) && (root.rightChild == null)) {
    			count = 1;
    			System.out.print(root.value + " ");
    		} else
    			count = findLeafNode(root.leftChild) + findLeafNode(root.rightChild);
    		return count;
    	}
    
    	/*
    	 * 查找某元素在二叉树中是否存在,是则输出1,否则输出0, 思路是按某种遍历顺序访问所有结点,查找是否存在给定元素
    	 */
    	public int findNode(Node root, int key) {
    		int flag = 0;
    		if (root == null)
    			return flag;
    		Stack<Node> nodeStack = new Stack<>();
    		Node temp = root;
    		nodeStack.push(temp);
    		while (!nodeStack.isEmpty()) {
    			temp = nodeStack.pop();
    			if (temp != null) {
    //				System.out.print(temp.value + " ");
    				if(temp.value==key) {
    					flag=1;
    					break;
    				}
    				nodeStack.push(temp.rightChild);
    				nodeStack.push(temp.leftChild);
    			}
    		}
    		return flag;
    	}
    
    	public static void main(String[] args) {
    		TestBinaryTree test = new TestBinaryTree();
    		Node root = test.createBinTree();
    		System.out.println("先根遍历:");
    		test.preOderTraverse(root);
    		System.out.println("\n中根遍历:");
    		test.inOderTraverse(root);
    		System.out.println("\n后根遍历:");
    		test.aftOderTraverse(root);
    		System.out.println("\n叶子节点:");
    		int count = test.findLeafNode(root);
    		System.out.println(" , 共有" + count + "个");
    		System.out.println("输入你要查找的元素:");
    		Scanner input=new Scanner(System.in);
    		int key=input.nextInt();
    		input.close();
    		System.out.println("结果:"+test.findNode(root, key));
    	}
    }
    

    二叉树样例:

    运行截图:

    展开全文
  • //构造哈夫曼树并求哈夫曼编码void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n){ //构造哈夫曼树 if ( n ) { return; } m = 2 * n - 1; HT = (HuffmanTree)malloc((m+1)*sizeof(HTNode));
    展开全文
  • 在人工气候室和温室条件下,控制不同土壤水势梯度,从叶解剖构造及叶的运动和脱落等方面研究了1~3年生油松...在干旱条件下,叶子的运动和脱落与叶水势临界值有关,而且,在不同的干旱阶段,树木叶子的主要运动形式是不同的.
  • #include #include #include #include #include using namespace std;int tree[400][4];///四叉树数组 int leaf[350];///存储叶子节点 int image[16][16];///图像矩阵 int m;///叶
  • 对于一组给定的叶子结点,他们权值集合为w={4,2,1,7,3},给出由此集合构造哈夫曼树过程</p>
  • 二叉树的构造

    2013-11-04 15:13:19
    的构造与删除以及各种遍历,求叶子数,以及相互交换
  • 在哈夫曼树中,没有度为1结点,结点总数是n0+n2(其中n0表示二叉树中度为0结点数,n2表示度为2结点数),而由二叉树性质知道n0=n2+1,所以一棵哈夫曼树中结点总数是2n0-1。 由此可以得出:任何n个字符...
  • 树算法习题 1.树前序遍历建立树,访问顺序相当于二叉树中序遍历 2.求孩子兄弟表示法存储森林的叶子节点数目 3. 前序访问树节点 ...9.已知一颗树层次序列及每个节点度, 编写算法构造这个树孩子兄弟链表
  • 哈弗曼树
  • 哈夫曼树的构造

    2019-04-04 15:06:00
     依据哈弗曼树定义,一棵二叉树要使其WPL值最小,必须使权值越大的叶子结点越靠近根结点,而权值越小的叶子结点越远离根结点。 哈弗曼根据这一特点提出了一种构造最优二叉树方法,其基本思想如下: 1。...
  • huffman树的构造

    2009-08-25 20:16:22
    编码算法,在构造haffman树过程中,使用一个辅助数组记录haffman树中每个结点左孩子、右孩子、双亲在数组中下标,编码时从叶子结点开始往上直到根结点,左子树为0,右子树为1。数组中元素存放顺序先写入每...
  • 文章目录一. 赫夫曼树(最优二叉树)二. 构造赫夫曼树三. 赫夫曼编码四....从根结点到各个叶子结点路径长度与相应结点权值乘积和称为该二叉树带权路径长度,记作 其中,Wi为第i个叶子结点权值,L...
  • 二叉树的构造与遍历

    2017-11-16 18:29:22
    #include /* 构造链式二叉树 输出先序遍历 中序遍历 后序遍历结果 统计叶子节点的个数和二叉树的深度 */ struct Tree{ ...//用于统计叶子的数目 struct Tree *creat(struct Tree *t)//根据先序建立
  • 哈夫曼树的构造: 假设有n个权值,则构造出的哈夫曼树有n个叶子结点。n个权值分别设为w1、w2、…、wn,则哈夫曼树的构造规则: (1)将w1、w2、…、wn看成是有n棵树的森林(每棵树仅有一个结点);
  • 计算给定二叉树所有左叶子之和。 示例: 思路:其实刷到这里对于前中后遍历应该比较熟悉了,这里就用后序遍历非常好,然后加几个边界条件设置。 后序遍历,从后面开始算== class Solution { public: int sumOf...
  • 今天来写一下二叉查找树的构造算法 二叉查找树:二叉查找树的的特点是所有节点的值要大于其左节点的值,小于其右节点的值。。。 因此我们在构造二叉查找树的查找算法的时候总是用要查找的数来和节点的值做一个比较...
  • 这篇文档只能说是构造LDAPMessage基本流程或者说是枝干,其构造的具体方法或者说叶子是比较复杂。希望大家看了这个之后能有一个构造的思路,具体实现需要对代码进行详细研读理解。
  • 该算法中使用二叉树结构进行码字的构造,并分析了二叉树中可逆变长码的构造条件。提出了一个代价函数,用它来决定各层中叶子节点的数量,并且在选择叶子节点的位置时,充分考虑到不同叶子结点位置的组合对于下层可用节点...
  • 组合树结构 组合树代码实现 从集合构造树 求树最左边的叶子节点 求树最右边的叶子节点 树节点前序遍历 树节点后序遍历 ...//构造入库 构造一个虚拟根节点 public Node getTTree(List<Elem.
  • 哈夫曼树Java构造

    2019-01-11 10:43:40
    (1)定义:假设有n个权值{w1, w2, …, wn},试构造一棵含有n个叶子结点二叉树,每个叶子节点带权威wi,则其中带权路径长度WPL最小二叉树叫做最优二叉树或者哈夫曼树。 (2)特点:哈夫曼树中没有度为1结点,...
  • 已知第5层有3个叶子结点完全二叉树,可以构造出多少种?各自有多少个结点?
  • 实验内容 1、假设二叉树中每个结点值为单个字符,采用二叉链存储结构存储。设计一个算法,计算一棵给定二叉树b中所有单...(1)由图7.33所示二叉树创建对应二叉链存储结构b,该二叉树括号表示串为“A(B(...
  • DS之求解二叉树的叶子结点和深度

    千次阅读 2015-05-15 23:09:13
     如果实现上面功能就先要构造二叉树以及创造二叉树,还需要求解叶子结点个数函数以及深度函数,这都需要自己去在数据结构要求中实现。  首先来看二叉树二叉链表存储表示: typedef struct BiTNode//重新...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,323
精华内容 929
关键字:

叶子的构造