精华内容
下载资源
问答
  • 的划分问题:将给定的一棵划分为若干棵子树,使其能够满足一定的条件或是使得某个特定的函数达到最值。
  • 列出给定目录的形目录结构

    千次阅读 2011-09-20 14:59:43
    列出给定目录的形目录结构: package com.wansha; import java.io.File; import java.util.LinkedList; import java.util.List; /** * * @author sharp *递归列

    列出给定目录的树形目录结构:

    package com.wansha;
    
    import java.io.File;
    import java.util.LinkedList;
    import java.util.List;
    /**
     * 
     * @author sharp
     *递归列出给定目录的树形目录结构
     */
    public class FileItem {
    	private int times = 0;//计算当前文件在目录的层次
    	
    	public void listFileItem(File file){
    		if(file.isFile() || file.listFiles().length==0){ //递归出口
    			return ;
    		}else{
    			for(File f :fileSort(file.listFiles())){
    				StringBuffer sb = new StringBuffer();
    				if(f.isFile()){
    					sb.append(tab(times));
    					sb.append(f.getName());
    					System.out.println(sb);
    				}else{
    					sb.append(tab(times));
    					sb.append(f.getName()+"\\");
    					System.out.println(sb);
    					times++;
    					listFileItem(f);
    					times--;
    				}
    			}
    		}
    	}
    	//对目录列表进行排序,目录在上,文件在下
    	public File[] fileSort(File[] file){ 
    		List<File> list = new LinkedList<File>();
    		for(File f : file){
    			if(f.isFile())continue;
    			list.add(f);
    		}
    		for(File f : file){
    			if(!f.isFile())continue;
    			list.add(f);
    		}
    		return list.toArray(new File[file.length]);
    	}
    	//计算缩进
    	public String tab(int times){
    		StringBuffer sb = new StringBuffer();
    		for(int i=0;i<times;i++){
    			sb.append("\t");
    		}
    		return sb.toString();
    	}
    	
    	public static void main(String[] args) {
    		FileItem item = new FileItem();
    		item.listFileItem(new File("C:/BOOT"));
    	}
    }
    


    展开全文
  • 给定权值的赫夫曼进行编码,使用01前缀编码的方式避免编码的重复,使译码过程准确进行
  • 现在有一棵合法的二叉树,的节点都是用数字表示,现在给定这棵上所有的父子关系,求这棵的高度

    现在有一棵合法的二叉树,树的节点都是用数字表示,现在给定这棵树上所有的父子关系,求这棵树的高度
    输入描述:
    输入的第一行表示节点的个数n(1 ≤ n ≤ 1000,节点的编号为0到n-1)组成,
    下面是n-1行,每行有两个整数,第一个数表示父节点的编号,第二个数表示子节点的编号
    输出描述:
    输出树的高度,为一个整数

    示例1
    输入

    5
    0 1
    0 2
    1 3
    1 4
    输出

    3

    一段时间没写java了,竟然连建树都不会了。。。
    这个题并不难,大体思路是:对给定的一棵树root,Height=max(root.left,root.right)+1。
    感觉困难的就是输入困难一点

    import java.util.Scanner;
    import java.util.HashMap;
    public class Main {
        public static class TreeNode{
            TreeNode left=null;
            TreeNode right=null;
            int value;
            public TreeNode(int v){
                this.value=v;
            }
        }
        public int Height(TreeNode root){   
            if(root==null){
                return 0;
            }
            int left=0,right=0;
            if(root.left!=null){
                left=Height(root.left);
            }
            if(root.right!=null){
                right=Height(root.right);
            }
            return ((left>=right)?left:right)+1;
        }
        public static void main(String[] args) {
            Main m=new Main();
            Scanner s=new Scanner(System.in);
            int num=s.nextInt();
            int rootval=s.nextInt();
            int rootfirst=s.nextInt();
    
            TreeNode root=new TreeNode(rootval);
            TreeNode rootLeft=new TreeNode(rootfirst);
            root.left=rootLeft;
    
            HashMap<Integer,TreeNode> nodeMap=new HashMap<Integer,TreeNode>();
            nodeMap.put(rootval, root);
            nodeMap.put(rootfirst,rootLeft);
    
            for(int i=0;i<num-2;i++){
                int parentval=s.nextInt();
                int childval=s.nextInt();
                TreeNode parent=nodeMap.get(parentval);
                TreeNode child=new TreeNode(childval);
                if(parent!=null){
                    if(parent.left==null){
                        parent.left=child;
                    }else if(parent.right==null){
                        parent.right=child;
                    }
                }else{
                    parent=new TreeNode(parentval);
                    parent.left=child;
                }
                nodeMap.put(parentval, parent);
                nodeMap.put(childval, child);
            }
            System.out.println(m.Height(root));
            s.close();
        }
    }
    
    展开全文
  • BinarySearchTree 二叉搜索的实现和一种在给定范围内打印中元素的方法。
  • 美团2017笔试题 给定一颗多叉

    千次阅读 2016-10-06 18:33:33
    给定一刻多叉,每个节点保存一个int类型数字且节点数字不重复,要求从上到下按层次打印每个节点的数字,每一层按从左到右的顺序。 要求: (1)实现一颗多叉 (2)根据自定义输入,构造多叉 (3)从左到右...

    给定一刻多叉树,每个节点保存一个int类型数字且节点数字不重复,要求从上到下按层次打印每个节点的数字,每一层按从左到右的顺序。
    要求:
    (1)实现一颗多叉树
    (2)根据自定义输入,构造多叉树
    (3)从左到右按层输出多叉树
    输入包含多行,每行有空格隔开的多个数字,第一个数字为某一个父节点的值,后面N个数字为该父节点的所有子节点的值,按从左到右的顺序排列。所有节点的值为整数,取值范围[0,100]。
    如:
    5 2 3
    2 6 7 8
    (5为根节点,有两个子节点;2为5的第一个子节点,包含三个子节点)
    输出包含一行,用空格隔开。
    如:
    5 2 3 6 7 8

    代码如下:

    #include <iostream>
    #include <string>
    #include <sstream>
    using namespace std;
    
    class MultiTree
    {
    public:
        int data;
        MultiTree *brother;
        MultiTree *child;
    
        MultiTree(int val);
        ~MultiTree();
    
        MultiTree* Find(int value);
        void Print();
    };
    
    MultiTree::MultiTree(int val)
        :data(val)
        ,brother(NULL)
        ,child(NULL)
    {
    }
    
    MultiTree::~MultiTree()
    {
        if (brother)
        {
            delete brother;
            brother = NULL;
        }
        if (child)
        {
            delete child;
            child = NULL;
        }
    }
    
    MultiTree* MultiTree::Find(int value)
    {
        if (data == value)
            return this;
        else
        {
            MultiTree* res = NULL;
            if (child) res = child->Find(value);
            if (res) return res;
            if (brother) res = brother->Find(value);
            if (res) return res;
            return res;
        }
    }
    
    void MultiTree::Print()
    {
        cout<<data<<" ";
        if (brother) brother->Print();
        if (child) child->Print();
    }
    
    MultiTree* CreateMultiTree()
    {
        MultiTree *root = NULL;
    
        string str;
        stringstream ss;
        int temp;
        if (getline(cin,str))//根节点
        {
            ss.clear();
            ss.str(str);
    
            if (ss>>temp)//第一个节点----根节点
            {
                root = new MultiTree(temp);
    
                if (ss>>temp)//第二个节点
                {
                    MultiTree *subnode = new MultiTree(temp);
                    root->child = subnode;
                    MultiTree *pre = subnode;
                    while (ss>>temp)//第三个节点及其以后
                    {
                        MultiTree *bronode = new MultiTree(temp);
                        pre->brother = bronode;
                        pre = bronode;
                    }
                }
            }
    
            while (getline(cin,str))//后续结点
            {
                ss.clear();
                ss.str(str);
    
                if (ss>>temp)//第一个节点
                {
                    MultiTree* node = root->Find(temp);
                    if (!node) return root;
    
                    if (ss>>temp)//第二个节点
                    {
                        MultiTree *subnode = new MultiTree(temp);
                        node->child = subnode;
                        MultiTree *pre = subnode;
                        while (ss>>temp)//第三个节点及其以后
                        {
                            MultiTree *bronode = new MultiTree(temp);
                            pre->brother = bronode;
                            pre = bronode;
                        }
                    }
                }
            }
        }
        return root;
    }
    
    int main()
    {
        MultiTree* root = CreateMultiTree();
        if (root) root->Print();
        delete root;
        return 0;
    }
    展开全文
  • 题目:给定一个二叉搜索(BST),找到中第 K 小的节点。 * 考察点 基础数据结构的理解和编码能力 递归使用 * 示例 5 / \ 3 6 / \ 2 4 / 1 说明:保证输入的 K 满足 1<=K<=(节点数目) ...

    题目:给定一个二叉搜索树(BST),找到树中第 K 小的节点。

    * 考察点

    1. 基础数据结构的理解和编码能力
    2. 递归使用

    * 示例

           5
          / \
         3   6
        / \
       2   4
      /
     1
     
    

    说明:保证输入的 K 满足 1<=K<=(节点数目)

    树相关的题目,第一眼就想到递归求解,左右子树分别遍历。联想到二叉搜索树的性质,root 大于左子树,小于右子树,如果左子树的节点数目等于 K-1,那么 root 就是结果,否则如果左子树节点数目小于 K-1,那么结果必然在右子树,否则就在左子树。因此在搜索的时候同时返回节点数目,跟 K 做对比,就能得出结果了。

    /**
     * Definition for a binary tree node.
     **/
    
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) { val = x; }
    }
    
    class Solution {
        private class ResultType {
        
            boolean found;  // 是否找到
            
            int val;  // 节点数目
            ResultType(boolean found, int val) {
                this.found = found;
                this.val = val;
            }
        }
    
        public int kthSmallest(TreeNode root, int k) {
            return kthSmallestHelper(root, k).val;
        }
    
        private ResultType kthSmallestHelper(TreeNode root, int k) {
            if (root == null) {
                return new ResultType(false, 0);
            }
    
            ResultType left = kthSmallestHelper(root.left, k);
    
            // 左子树找到,直接返回
            if (left.found) {
                return new ResultType(true, left.val);
            }
    
            // 左子树的节点数目 = K-1,结果为 root 的值
            if (k - left.val == 1) {
                return new ResultType(true, root.val);
            }
    
            // 右子树寻找
            ResultType right = kthSmallestHelper(root.right, k - left.val - 1);
            if (right.found) {
                return new ResultType(true, right.val);
            }
    
            // 没找到,返回节点总数
            return new ResultType(false, left.val + 1 + right.val);
        }
    }
    

    给定一个二叉搜索树,编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。

    说明:
    你可以假设 k 总是有效的,1 ≤ k ≤ 二叉搜索树元素个数。

    示例 1:

    输入: root = [3,1,4,null,2], k = 1

       3
      / \
     1   4
      \
       2


    输出: 1


    示例 2:

    输入: root = [5,3,6,2,4,null,null,1], k = 3

           5
          / \
         3   6
        / \
       2   4
      /
     1


    输出: 3
    进阶:
    如果二叉搜索树经常被修改(插入/删除操作)并且你需要频繁地查找第 k 小的值,你将如何优化 kthSmallest 函数?

    使用中序遍历

    class Solution {
        List<Integer> list = new ArrayList();
        public void dfs(TreeNode root){
            if(root == null)
                return ;
            dfs(root.left);
            list.add(root.val);
            dfs(root.right);
        }
        public int kthSmallest(TreeNode root, int k) {
            dfs(root);
            for(int i=0;i<list.size();i++){
                if(i == k-1)
                    return list.get(i);
            }
            return -1;
        }
    }


    使用递归(计算节点数量):

    class Solution {    
        public int count(TreeNode root){
            if(root == null)
                return 0;
            return 1 + count(root.left) + count(root.right);
        }
        public int kthSmallest(TreeNode root, int k) {
            int num = count(root.left);
            if(num == k-1)
                return root.val;
            if(num > k-1)
                return kthSmallest(root.left,k);
            return kthSmallest(root.right,k - num-1);
        }
    }


    参考链接:

    https://blog.csdn.net/xuchonghao/article/details/80770490

    https://github.com/debitCrossBlockchain/interview__reference/blob/master/01.%E9%98%BF%E9%87%8C%E7%AF%87/1.1.3%20%E7%BB%99%E5%AE%9A%E4%B8%80%E4%B8%AA%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91(BST)%EF%BC%8C%E6%89%BE%E5%88%B0%E6%A0%91%E4%B8%AD%E7%AC%AC%20K%20%E5%B0%8F%E7%9A%84%E8%8A%82%E7%82%B9.md

     

    展开全文
  • 离散数学-为给定创建prufer代码 1. INPUT.txt 文件输入。 第一行:n-顶点数。 接下来的n行:每行包含2个整数(2个顶点):ab-表示一条边。 2. prufercodeV1,V2,V3,V3gentest 创建一棵用作测试。 3. ...
  • 题目描述现在有一棵合法的二叉树,的节点都是用数字表示,现在给定这棵上所有的父子关系,求这棵的高度输入描述:输入的第一行表示节点的个数n(1 ≤ n ≤ 1000,节点的编号为0到n-1)组成,下面是n-1行,每行...
  • 题目描述现在有一棵合法的二叉树,的节点都是用数字表示,现在给定这棵上所有的父子关系,求这棵的高度输入描述:输入的第一行表示节点的个数n(1 ≤ n ≤ 1000,节点的编号为0到n-1)组成, 下面是n-1行,每行...
  • 判别给定二叉树是否为二叉排序
  • 判断给定二叉树是否二叉搜索 题设要求 (1)函数接口说明: bool IsBST ( BinTree T ); 其中BinTree结构定义如下: typedef struct TNode *Position; typedef Position BinTree; struct TNode{ ElementType Data; ...
  • 判断给定的二叉树是否为二叉排序

    万次阅读 多人点赞 2018-11-12 21:19:49
    判断给定的二叉树是否为二叉排序
  • 判定给定二叉树是否为二叉排序

    千次阅读 2019-06-20 21:53:25
    描述试写一个判定给定二叉树是否为二叉排序的程序,设此二叉树以二叉链表做存储结构,且结点的关键字均不同 输入 输入一个二叉树的先序序列,若某个节点没有左孩子(右孩子),则左孩子(右孩子)用0表示 ...
  • 结构练习——判断给定森林中有多少棵 Time Limit: 1000MS Memory limit: 65536K 题目描述  众人皆知,在编程领域中,C++是一门非常重要的语言,不仅仅因为其强大的功能,还因为它是很多其他面向...
  • 给定的一段文本抽取一个多个基于知识的标签。 Project Structure textmulclassify/ ▾ data_structures/ __init__.py model.py tree.py ▾ engines/ __base__.py __init__.py association_rule_...
  • 判断给定的二叉树是否是二叉排序 根据二叉排序的定义,左子树结点值 < 根结点值 < 右子结点值,所以对二叉排序进行中序遍历(LNR),可以得到一个递增的有序序列。因此,对给定的二叉树进行中序遍历,...
  • 1.哈夫曼概念一棵中,从任意一个结点到达另一个结点的通路叫做路径,该路径包含的边的...给定N个结点和它们的权值,以这N个结点为叶子节点构造的带权路径长度和最小的二叉树,就是哈夫曼。2.C语言实现给定结点...
  • 罗斯林·夸特(RoslynQuoter) 用于给定C#程序的Roslyn工具显示了语法工厂API调用以构造其语法。 可以通过以下网址进行实时试用: : 。
  • 而我们知道对于一棵二叉树搜索来说,其每一棵子树也都是二叉搜索,且其最小值为最左边的结点,最大值为最右边的结点。 所以反过来讲,就是如果一棵普通二叉树的任意一棵左子树中的最大值(左子树的最右边结点)...
  • 令φ(T,λ)=nΣk=0(-1)kCk(T)λn-k是一个n点T的...应用图的变换,确定给定直径和悬挂点数的中所有拉普拉斯系数Ck(T)最小的。特别是确定了一些具有极端维纳指标、修改超维纳指标和Laplacian-like能量的
  • import java.io.File; public class ReadDirectory { // 文件所在的层数 private int fileLevel;... * @param name 输出的文件名目录名 * @param level 输出的文件名或者目录名所在的层次 * @return
  • buildUPGMA.py是执行UPGMA算法并为给定序列输出指导的程序。 安装 buildUPGMA.py使用Python 3标准库。 如果您以前安装过Python 3,则不需要其他软件包。 否则,您可以从“ ”安装Python 3。 确保为操作系统选择了...
  • #include <stdio.h><br />#define ENDKEY 0 typedef struct node {  int key;  struct node *lchild,*rchild; }BSTNode,*BSTree; void InsertBST(BSTree *bst,int key) ...
  • (2) 在森林中选出两个根结点的权值最小的合并,作为一棵新的左、右子,且新的根结点权值为其左、右子根结点权值之和; (3)从森林中删除选取的两棵,并将新加入森林; (4)重复(2)、(3)步,直到森林中只...
  • import catalog.sourcedir.models.SourceDir; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class NodeUtil { ... List returnList = new ArrayList();...
  • 问题描述 给出一棵二叉树的中序后序排列。求出它的先序排列。(约定结点用不同的大写字母表示,长度&lt;=8)。输入格式 两行,每行一个字符串,分别表示中序和后序排列输出格式 一个字符串,表示所求先序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 267,545
精华内容 107,018
关键字:

给定与或树