精华内容
下载资源
问答
  • 数据结构上级作业的实验报告,里头有各分函数的代码
  • 完整的C查找数据结构代码; 能在vc6.0和vs2010下运行; 上机实验已验证;
  • 一元多项式可以表示成数据由两个数据项组成的一个线性表,如果只存储系数让指数隐含在系数序号中,则会浪费存储空间。只对多项式的值无需修改系数和指数值的情况下,采用顺序表结构较好。
  • 数据结构上机.rar

    2021-01-20 16:05:26
    数据结构上级报告及课程实践,适用于大二学生
  • 数据结构邻接表

    2015-10-15 22:27:22
    数据结构上级试验,邻接表,c语言,vc系统使用
  • 数据结构ppt 数据结构教程 源程序 数据结构上级指导 源程序
  • 数据结构链表代码

    2014-01-04 03:19:44
    链表的插入,删除,修改,数据结构上级实验的一些代码,C语言实现的
  • 老师给的数据结构上级实习算法源代码大全免得手敲
  • 数据结构上级经典题目,练手用最好,有点难度,希望好好利用
  • 易懂,简明数据结构上级算法答案。经编译通过,绝对无错
  • js 树形结构叶子节点数据上级聚合 分三个步骤: 平铺 取父集 取交集 确保数据存在层级关系,遍历平铺数据取出当前父集,取叶子节点数据取交集,然后层层向上聚合 const arr = [ { id: 1, pid: null, list: ...

    js 树形结构叶子节点数据取交集向上级聚合

    分三个步骤:

    • 平铺
    • 取父集
    • 取交集

    确保数据存在层级关系,遍历平铺数据取出当前父集,取叶子节点数据取交集,然后层层向上聚合

    const arr = [
        {
            id: 1,
            pid: null,
            list: [],
            child: [
                {
                    id: 11,
                    pid: 1,
                    list: [],
                    child: [
                        {
                            id: 111,
                            pid: 11,
                            list: [
                                {
                                    val: 'a4'
                                },
                                {
                                    val: 'a5'
                                }
                            ]
                        },
                        {
                            id: 112,
                            pid: 11,
                            list: [
                                {
                                    val: 'a6'
                                },
                                {
                                    val: 'a4'
                                }
                            ]
                        }
                    ]
                },
                {
                    id: 12,
                    pid: 1,
                    list: [
                        {
                            val: 'a6'
                        }
                    ]
                }
            ]
        },
        {
            id: 2,
            pid: null,
            list: [],
            child: [
                {
                    id: 21,
                    pid: 2,
                    list: [
                        {
                            val: 'a1'
                        },
                        {
                            val: 'a3'
                        }
                    ]
                },
                {
                    id: 22,
                    pid: 2,
                    list: [
                        {
                            val: 'a2'
                        },
                        {
                            val: 'a1'
                        }
                    ]
                }
            ]
        },
        {
            id: 3,
            pid: null,
            list: [],
            child: [
                {
                    id: 31,
                    pid: 3,
                    list: [
                        {
                            val: 'a2'
                        },
                        {
                            val: 'a3'
                        }
                    ]
                }
            ],
            
        }
    ]
    
    // 平铺数据
    const dist = []
    const fee = (data) => {
        data.forEach(el=> {
            dist.push(el)
            if (el.child && el.child.length) {
                el.list = []
                fee(el.child)
            }
        })
    }
    fee(arr)
    
    // 取交集
    const intersect = (pre, cur, key) => {
        const preValArr = (pre || []).map(el => el[key])
        const curArr = (cur || []).filter(el => new Set(preValArr).has(el[key]))
        return curArr
    }
    
    dist.forEach(el => {
        if (el.pid) {
            // 取父集
            const father = dist.find(ll => ll.id === el.pid)
            const mgList = father.child.reduce((p, c) => {
                p.push(c.list)
                return p
            },[])
            father.list = mgList.reduce((p, c)=>{ 
                return intersect(p, c, 'val')
            })
        }
    })
    
    console.log(JSON.stringify(arr))
    ====[{"id":1,"pid":null,"list":[],"child":[{"id":11,"pid":1,"list":[{"val":"a4"}],"child":[{"id":111,"pid":11,"list":[{"val":"a4"},{"val":"a5"}]},{"id":112,"pid":11,"list":[{"val":"a6"},{"val":"a4"}]}]},{"id":12,"pid":1,"list":[{"val":"a6"}]}]},{"id":2,"pid":null,"list":[{"val":"a1"}],"child":[{"id":21,"pid":2,"list":[{"val":"a1"},{"val":"a3"}]},{"id":22,"pid":2,"list":[{"val":"a2"},{"val":"a1"}]}]},{"id":3,"pid":null,"list":[{"val":"a2"},{"val":"a3"}],"child":[{"id":31,"pid":3,"list":[{"val":"a2"},{"val":"a3"}]}]}]
    
    展开全文
  • 数据结构

    2020-12-15 15:48:40
    数据结构基础 什么是链表? ​ 地下党是一些什么样的人物呢? ​ 在影视作品中,我们可能都见到过地下工作者的经典话语: ​ 上级的姓名、住址,我知道,下级的姓名、住址,我也知道。但是这些都是我们党的秘密,不能...

    数据结构基础

    什么是链表?

    ​ 地下党是一些什么样的人物呢?

    ​ 在影视作品中,我们可能都见到过地下工作者的经典话语:

    ​ 上级的姓名、住址,我知道,下级的姓名、住址,我也知道。但是这些都是我们党的秘密,不能告诉你们!

    ​ 地下党借助这种单线联络的方式,灵活隐秘地传递着各种重要信息。

    ​ 在计算机科学领域里,有一种数据结构也恰恰具备这样地特征,这种数据结构就是链表

    链表是一种在物理上非连续、非顺序的数据结构,由若干节点所组成。

    单项链表的每一个节点又包含两个部分,最后1个节点被称为尾节点,尾节点的next指针指向空。

    public   class Node {
       String data;
        Node next;
    
        public Node(String data) {
            this.data = data;
        }
    }
    
    

    双向链表

    双向链表比单项链表稍微复杂一些,它的每一个节点除了拥有data和next指针,还拥有指向向前节点的prev指针。

    数组在内存中的存储方式是顺序存储,那么链表在内存中的存储方式是随机存储。

    什么是随机存储?

    我们知道数据的内存分配方式,数组在内存中占用了连续完整的存储空间。而链表则采用了见缝插针的方式,链表的每一个节点分布在内存的不同位置,依靠next指针关联起来。这样可以灵活有效地利用零散地碎片化空间。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rmLgnD1C-1608018484831)(C:\Users\ZhangGuojun\AppData\Roaming\Typora\typora-user-images\image-20201215144244252.png)]

    ​ 数组的内存分配方式

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YvjLH01w-1608018484833)(C:\Users\ZhangGuojun\AppData\Roaming\Typora\typora-user-images\image-20201215144506984.png)]

    ​ 链表的内存分配方式

    链表的基本操作

    1. 查找节点

    ​ 在查找元素时,链表不像数组那样可以通过下标快速进行定位,只能从头节点开始向后一个一个节点逐一查找。所以,最坏的时间复杂度时O(n)。

    2.更新节点

    ​ 如果不考虑查找节点的过程,链表的更新过程会像数组那样简单,直接把旧数据替换成新数据即可。

    3.插入节点

    与数组类似,链表插入节点时,同样分为3种情况

    • 尾部插入
    • 头部插入
    • 中间插入
    尾部插入

    尾部插入时最简单的情况,把最后一个节点的next指针指向新插入的节点即可。

             //插入尾部
                last.next=insertNode;
                last=insertNode;
    
    头部插入分为两个步骤
    1. 第一步,把新节点的next指针指向原先的头节点。
    2. 第二步,把新节点变为链表的头节点。
     //插入头部
                insertNode.next=head;
                head=insertNode;
    
    中间插入,同样分为两个步骤。
    1. 第一步,新节点的next指针,指向插入位置的节点。
    2. 第二步,插入位置前置节点的next指针,指向新节点。
        /**
         * 链表查找元素
         * @Param index 查找的位置
        * */
        public Node get(int index){
            if (index<0 || index>=size){
                throw new IndexOutOfBoundsException("超出链表节点范围");
            }
            Node temp=head;
            for (int i=0;i<index;i++){
                temp=temp.next;
            }
            return temp;
        }
    
    
            //中间插入
                 Node prevNode=get(index-1);
                 insertNode.next=prevNode.next;
                 prevNode.next=insertNode;
    

    只要内存空间永许,能够插入链表的元素是无穷无尽的,不需要像数组那样考虑扩容的问题。

    4.删除元素

    链表的删除操作同样分为3种情况

    • 尾部删除
    • 头部删除
    • 中间删除
    尾部删除

    尾部删除,是最简单的情况,把倒数第2个节点的next指针指向空即可。

      //删除尾节点
                Node prevNode=get(index-1);
                removNode=prevNode.next;
                prevNode.next=null;
                last=prevNode;
    
    头部删除

    头部删除,也很简单,把链表的头节点设为原先头节点的next指针即可

       //删除头节点
                removNode=head;
                head=head.next;
    
    中间删除

    把要删除节点的前置节点的next指针,指向要删除元素的下一个节点

            //删除中间节点
                Node prevNode=get(index-1);
                Node nextNode=prevNode.next.next;
                removNode=prevNode.next;
                prevNode.next=nextNode;
    
    查找 更新 插入 删除
    数组 O(1) O(1) O(n) O(n)
    链表 O(n) O(1) O(1) O(1)

    实现代码

    package com.stx.linkedlist;
    
    /**
     * @Author :张国军
     * @Date :Created in 11:38 2020/12/15
     * @Description : algorithm
     **/
    public class LinkedList {
        /**
         * 头节点指针
         * */
        private Node head;
        /**
         * 尾节点指针
         * */
        private Node last;
        /**
         * 链表实际长度
        * */
        private int size;
    
        /**
        * 链表插入元素
         * @Param data 插入元素
         * @Param index 插入位置
        * */
        public void insert(String data ,int index){
            if (index<0 || index>size){
                throw new IndexOutOfBoundsException("超出链表实际长度");
            }
            Node insertNode=new Node(data);
            if (size==0){
                //空链表
                head=insertNode;
                last=insertNode;
    
            }else if (index==0){
                //插入头部
                insertNode.next=head;
                head=insertNode;
            }else if (size==index){
                //插入尾部
                last.next=insertNode;
                last=insertNode;
            }else {
                //中间插入
                 Node prevNode=get(index-1);
                 insertNode.next=prevNode.next;
                 prevNode.next=insertNode;
            }
            size++;
        }
    
        /**
         * 链表删除元素
         *
         * */
        public Node remove(int index){
            if (index<0||index>=size){
                throw new IndexOutOfBoundsException("超出链表节点范围");
            }
            Node removNode=null;
            if (index==0){
                //删除头节点
                removNode=head;
                head=head.next;
            }else if (index==size-1){
                //删除尾节点
                Node prevNode=get(index-1);
                removNode=prevNode.next;
                prevNode.next=null;
                last=prevNode;
            }else {
                //删除中间节点
                Node prevNode=get(index-1);
                Node nextNode=prevNode.next.next;
                removNode=prevNode.next;
                prevNode.next=nextNode;
            }
            size--;
            return removNode;
        }
    
        /**
         * 链表查找元素
         * @Param index 查找的位置
        * */
        public Node get(int index){
            if (index<0 || index>=size){
                throw new IndexOutOfBoundsException("超出链表节点范围");
            }
            Node temp=head;
            for (int i=0;i<index;i++){
                temp=temp.next;
            }
            return temp;
        }
    
        /**
         * 输出链表
         * */
        public void output(){
            Node temp=head;
            while (temp!=null){
                System.out.println(temp.data);
                temp=temp.next;
    
            }
        }
    
    }
    
    
    
    
    展开全文
  • 数据结构,可以作为大作业,详细的注释以及严谨的编码风格,为大二编写的还是很学生化得,而且有说明文档
  • 数据结构迷宫算法

    2012-10-22 20:16:32
    数据结构初学上级必备,简单而又实际学习,对数据结构初学来说帮助还是帮助很大的,我是刚上机学习感觉用处很大与大家分享
  • 新编数据结构-.doc

    2020-07-10 22:15:12
    PAGE PAGE 253 第5章 树 到目前为止我们已经学习了线性结构和表结构这些数据结构一般不适合于描述具有分支结构的数据在这种数据之间可能有祖先后代上级下属整体部分等分支的关系本章引入的树形结构则是以分支关系...
  • 下面是我们要处理的数据,简写: let arr = [ { title: '你好吗?', children: [ { title: '很好啊', children: null }, { title: '是吗', children: null } ] ...

    下面是我们要处理的数据,简写:

    let arr = [
    		{
    			title: '你好吗?',
    			children: [
    				{
    					title: '很好啊',
    					children: null
    				},
    				{
    					title: '是吗',
    					children: null
    				}
    			]
    		},
    		{
    			title: '卡卡卡',
    			children: [
    				{
    					title: '非常好芬',
    					children: null
    				}
    			]
    		},
    		{
    			title: '第三方的',
    			children: null
    		}
    	];

    再搜索框输入 好 字时,希望树形结构中带有 好 字的项显示,即使父节点没有 好 字,但子节点含有,父节点仍要返回;代码实现如下:

    const rebuildData=(value, arr) => {
      	let newarr = [];
      	arr.forEach(element => {
        if (element.children && element.children.length) {
          const ab = rebuildData(value,element.children);
          const obj = {
            ...element,
            children: ab
          };
          if (ab && ab.length) {
            newarr.push(obj);
          }
        } else {
          if (element.title.indexOf(value) > -1) {
            newarr.push(element);
          }
        }
      });
      return newarr;
    };
    	console.log(rebuildData( '好', arr));

    输出如下图:

    深度解析

    这是个很明显的多叉树的树形结构,一般情况下,对于这种树形结构一般采用深度优先遍历和广度优先遍历。

    深度优先遍历

    深度优先遍历的原则是:
    1. 从顶点开始;
    2. 如果当前节点有子节点,则遍历当前节点的所有子节点;

    // 递归实现
    function deepSearch(tree){
        for(var i = 0; i<tree.length; i++) {
            console.log(tree[i]);
            if(tree[i].children && tree[i].children.length>0) {
                deepSearch(tree[i].children);
            }
        }
    }
    
    // 非递归
    function deepSearch(tree) {
        var stark = [];
    
        stark = stark.concat(tree);
    
        while(stark.length) {
            var temp = stark.shift();
            if(temp.children) {
                // 当前节点有子节点时,将子节点放到当前的栈的前面
                stark = temp.children.concat(stark);
            }
            console.log(temp);
        }
    }
    

    广度优先遍历

    广度优先遍历的原则是:
    1. 从根节点开始;
    2. 遍历所有子节点;
    3. 从第一个子节点开始再执行广度优先遍历。
    代码如下:

    function breadthSearch(tree) {
        var stark = [];
    
        stark = stark.concat(tree);
    
        while(stark.length) {
            var temp = stark.shift();
            if(temp.children) {
                stark = stark.concat(temp.children);
            }
            console.log(temp);
        }
    }

    我这里使用的是深度优先

    方案二:搜索前把tree数据摊平,变成一个普通list,不再需要深度递归,就一层,搜索完之后再重新生成tree结构数据

    展开全文
  • } // 获取树结构数据 public List getList() { try { // 从数据库里获取 List 数据,如果有条件,则根据相应条件获取,总之这里是一个树结构的 list List tests = testRepository.findAll(); // ??? 为什么不是 ...

    一 TreeLeader方法:
    1.1首先把传过来的list 集合遍历
    1.2 根据遍历创建一个leader对象 用来接收各级leader对象的name 值
    1.3 把这个对象添加到之前new 的ArrayList集合中
    1.4 再获取到当前对象的children的值 再调用本身
    1.5 当前leader 对象没有子成员时 不满足当前方法参数所需要的条件 递归就会停止
    public class Leader {
    private Integer id;
    private String name;
    private Integer parentId;
    private Integer level;
    public Leader(Integer id, String name, Integer parentId, Integer level) {
    super();
    this.id = id;
    this.name = name;
    this.parentId = parentId;
    this.level = level;
    }
    public Integer getId() {
    return id;
    }
    public void setId(Integer id) {
    this.id = id;
    }
    public String getName() {
    return name;
    }
    public void setName(String name) {
    this.name = name;
    }
    public Integer getParentId() {
    return parentId;
    }
    public void setParentId(Integer parentId) {
    this.parentId = parentId;
    }
    public Integer getLevel() {
    return level;
    }
    public void setLevel(Integer level) {
    this.level = level;
    }

    }
    public class Test {
    static List data=new ArrayList();
    static {
    Leader l1=new Leader(1,“军长”,0,1);
    Leader l2=new Leader(2,“师长”,1,2);
    Leader l3=new Leader(3,“旅长”,2,3);
    Leader l4=new Leader(4,“团长”,3,4);
    data.add(l1);
    data.add(l2);
    data.add(l3);
    data.add(l4);
    }

    public static void main(String[] args) {
    List list = new ArrayList<>();
    System.out.println(“查询前集合大小”+data.size());
    for(Leader l:data) {
    if(l.getParentId()==0) {
    list.add(l);
    if(ifChilds(data,l.getId())) {
    List childs = new ArrayList<>();
    childs=getChildList(data,l.getId(),childs);
    list.addAll(childs);
    }
    }
    }
    System.out.println(“查询后集合大小”+list.size());

    for(Leader leader:list) {
    	String s="";
    	for(int i=1;i<leader.getLevel();i++) {
    		s=s+"\t";
    	}
    	System.out.println(s+"  "+leader);
    }
    

    }

    private static List getChildList(List data2, Integer id, List childs) {
    // TODO Auto-generated method stub
    for(Leader leader:childs) {
    if(ifChilds(childs,leader.getId()));

    }
    return childs;
    

    }

    private static boolean ifChilds(List list, Integer Pid ) {
    // TODO Auto-generated method stub
    boolean flag=false;
    for(Leader leader:list) {
    flag=true;
    break;
    }
    return flag;
    }
    }

    树形结构在数据库的设计过程中是一种比较常见的模型,指的是各元素之间存在‘一对多’的结构模型。在树形结构中,树根结点没有前驱结点,其余每个结点有且只有一个前驱结点。叶子结点没有后续结点,其余每个结点的后续节点数可以是一个也可以是多个。
    在这里插入图片描述
    在数据库中建好对应的表’t_classes’后,可以使用Java实现对该表的CRUD操作,下面介绍递归的方法实现对表中元素遍历查询,并将其有层次地显示出来。

    对应的Java语句如下所示:

    package com.njupt.exam.manager;

    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;

    import com.njupt.exam.util.DbUtil;

    /**

    • 班级管理类
    • @author hzy

    */

    public class ClassesManager {

    public void dispalyClassesList() {
        Connection conn = null;
        try {
            conn = DbUtil.getConnection();
            displayClassesList(conn,0,0);
        } catch(Exception e) {
            e.printStackTrace();
    

    //此处conn遵循一个原则:在哪里打开就在哪里关闭

        } finally {
            DbUtil.close(conn);
        }
    }
    

    //构成方法重载

    public void displayClassList(Connection conn,int pid,int level) {
    

    //level表示空格的个数,随节点层数的增加而增加,使显示结果具有层次感

    //此处s用于使显示结果更具有层次感

        String s = "";
        PreparedStatement psta = null;
        ResultSet rs = null;
        String sql = "use 成绩管理系统 select * from t_class where pid = ?";
        for(int i=0;i<level;i++)
            s += "  ";
        try {
            psta = conn.prepareStatement(sql);
            psta.setInt(1,pid);
            rs = psta.executeQuery();
            while(rs.next()) {
    

    //打印输出当前节点的信息,当前节点的父节点为参数pid

                System.out.println(s + rs.getInt("class_id") + "  " + rs.getString("class_name"));
    

    //判断当前节点是否为叶子节点

    /如果不是叶子节点,说明当前节点下还有子节点,需要再次调用自身对子节点进行显示,此时displayClassesList函数中应当传入的参数为conn,由于要对子节点进行显示,故pid应为当前节点的id,level随着节点层数的变化变为level+1/

                if(rs.getInt("leaf") == 0) {                                                                          displayClassesList(conn,rs.getInt("class_id"),level+1)
                }  
            }
        } catch(SQLException e1) {
            e1.printStackTrace();
        } finally {
            DbUtil.close(rs);
            DbUtil.close(psta);
        }                               
    }
    

    //主函数实现对显示函数的调用

    public static void main(String args[]) {
        new ClassesManager.displayClassesList();
    }
    

    }

    由于之前在写树结构遍历的时候都是 copy 的别人的代码,想着把功能完成就行,并没有真正理解如何实现的遍历的,又怎么递归。前几天尝试着自己写一个遍历树结构 List,其实很简单,所以能自己动手,决不要 copy。先记录一个查询,增、删、改后续补上。

    正文
    实现思路

    1. 先从数据库根据相应条件获取出树结构 List
    2. 遍历获取到的数据将根节点取出
    3. 遍历刚取出的列表,调用递归方法将子节点数据存放到根节点里
    4. 就是这么 easy,直接贴上代码,细品
      1
      2
      3
      4
      5
      /** 从一个简单的DTO文件开始 */
      public class TestDTO {
      // 自身 ID
      private Long id;
      // 名称
      private String name;
      // 父节点 ID
      private Long parentId;
      // 子节点集合
      private List children;
      // 其他属性

      // setter and getter 方法

      }

    /** 实现类 */
    @Service
    public class TestServiceImpl implements TestService {

    // Repository 当然是获取数据啦...
    private final TestRepository testRepository;
    
    // 这个是构造方法
    public TestServiceImpl(TestRepository testRepository) {
        this.testRepository = testRepository;
    }
    
    // 获取树结构数据
    public List<TestDTO> getList() {
        try {
            // 从数据库里获取 List 数据,如果有条件,则根据相应条件获取,总之这里是一个树结构的 list
            List<Test> tests = testRepository.findAll();
            // ??? 为什么不是 TestDTO 类型?这里 Test 是 Entity,从数据库获取的数据当前是用 Entity 类型接收啦!
            // 没关系的,可以转DTO
            // 定义一个空数组,用来存放最终的树结构数据
            List<TestDTO> result = new ArrayList<>();
            // 第一步遍历获取到的数据,将根节点数据存放 result 里
            for (Test test: tests) {
                // 判断是否是根节点,就是 parentId,这里是从 0 开始,如果 parentId 为 0 ,则表示根节点
                if (test.getParentId() == 0) {
                    // 这里可以将 entity 转为 DTO 存放
                    // 如果字段不多可以直接使用 set get 方法来存取,就像这样
                    TestDTO testDTO = new TestDTO();
                    testDTO.setId(test.getId);
                    testDTO.setName(test.getName);
                    testDTO.setParentId(test.getParentId);
                    // 如果字段太多,超过5个以上,还是建议使用 mapper 方法来转哦,具体如何使用 mapper 将 Entity 转为 DTO 请移步下方链接
                    result.add(testDTO);
                }
            }
            // 根节点添加完就需要添加每个节点的子节点了,这里需要调用 递归方法 getChildren();
            // 遍历根节点数据,为其设置子节点集合
            for (TestDTO test: result) {
                // 获取子节点数据,传入 当前节点 id 和 所有 list
                List<TestDTO> childList = getChildren(test.getId(), tests);
                // 将获取到的子节点集合添加到根节点里
                test.setChildren(childList);
            }
            // 将一层一层的树结构数据返回吧!
            return result;
        } catch(Exception e) {
            // 这里可以抛个异常
        }
    }
    
    /**
     * 获取子节点数据
     * @param id 父节点 ID
     * @param List<Test> tests 所有节点集合
     * @return 返回子节点列表
     */
    private List<TestDTO> getChildren(Long id, List<Test> tests) {
        // 存在子节点数据
        List<TestDTO> childList = new ArrayList<>();
        // 遍历所有节点数据
        for (Test item : tests) {
            // 如果当前节点 ID 与父节点 ID 一致,表示当前数据是该节点的子节点
            if (item.getParentId().equals(String.valueOf(id))) {
                TestDTO testDTO = new TestDTO();
                testDTO.setId(test.getId);
                testDTO.setName(test.getName);
                testDTO.setParentId(test.getParentId);
                // 如果字段太多,超过5个以上,还是建议使用 mapper 方法来转哦,具体如何使用 mapper 将 Entity 转为 DTO 请移步下方链接
                childList.add(testDTO);
            }
        }
        // 重点来了,递归调用
        for (TestDTO item : childList) {
            // 调用自身方法,依次添加子节点数据
            item.setChildren(getChildren(item.getId(), tests));
        }
        // 如果当前节点无子节点数据添加空数据,递归退出
        if (childList.size() == 0) {
            return new ArrayList<>();
        }
        // 返回最终的子节点数据
        return childList;
    }
    

    }

    展开全文
  • 树是由结点和边组成的,不存在环的一种数据结构。 树满足递归定义的特性。也就是说,如果一个数据结构是树结构,那么剔除掉根结点后,得到的若干个子结构也是树,通常称作子树。 1)A 结点是 B 结点和 C 结点的上级...
  • 数据结构实验指导书

    2014-07-20 10:57:27
    数据结构 (C语言版)--严蔚敏 上级指导书,其中有完整的操作流程,还有完整的代码例子
  • 第一种方法我采用了链接里的简单的数据结构,就采用pre[i]数组记录i的上级,当i=pre[i]是,i即为根节点。 #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;cstdio&amp;amp;gt;...
  • 每个门派的根节点是掌门,任意节点的父节点是自己的直属上级。两个大侠碰到了,需要找到他们的掌门是否是同一个人 江湖上门派太多,总是打架。希望把这些小门派都合并,就不会打架了。 路径压缩:江湖上有门派...
  • 数据结构

    2013-03-24 22:28:17
    这学期终于开了传说中的数据结构。记得在大一时就听说过这门课,当时觉得好深奥,现在呢,还是那么深奥啊 真是坑啊 第一节课还可以,听得懂。 后来上级,我去,各种不会啊。C语言功底太差了,没办法了,只好自己补...
  • 数据结构刨析之哈希表

    千次阅读 2020-12-22 07:52:40
    散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组...
  • 数据结构的概念(逻辑结构与物理结构) 逻辑结构 彼此间的关系,应选择合适的结构。 1 集合结构 数据元素属于同一集合,彼此之间没有关系。 2 线性结构 数据元素彼此一一对应,呈现线的形状结构。 3 树形结构 数据...
  • 二叉树数据结构

    2014-07-19 22:07:11
    一个节点可以有多个下级节点,但只有一个上级节点     二叉树: 一个节点可以有不多于两个的下级节点,但只有一个上级节点   完全二叉树 满二叉树 B树 B+树 B-树     二叉树的遍历方式: 先序...
  • 严蔚敏的数据结构教材,含有所有数据结构中需要上级的实验,并有仔细的实验报告。绝对值得一看。
  • 数据结构 数据结构的分类 数据结构有逻辑结构和物理结构,物理结构就是在计算机中如何表示的,这里我们只关注逻辑结构。 树结构只能从父节点指向孩子结点,如果将孩子结点指向上级的结点就构成了图结构,图结构是...
  • 数据结构课程设计(2010),内容包括五道上级设计题目,可以供新手练习。
  • 数据结构 严蔚敏版ptf+随书资料 (随书资料包括严蔚敏老师上课的一些讲稿和ppt,还有一些上级实验,最重要的是原书课后的源代码)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 583
精华内容 233
关键字:

数据结构上级

数据结构 订阅