写的数据结构1对多再对多的形式结构

最新推荐文章于 2022-11-24 19:37:46 发布
最新推荐文章于 2022-11-24 19:37:46 发布
阅读量2.9k 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uestc_lxp/article/details/50611982
版权 


    public List<AllInfoInPackage> queryClassAndMethodInfoByPackage3(String appName,String packageName1) {
        AlpacaCodeRelationExample example = new AlpacaCodeRelationExample();
        example.createCriteria().andAppNameEqualTo(appName).andPackageNameEqualTo(packageName1).andIsDeletedEqualTo("n").andIsHiddenEqualTo("n");
        List<AlpacaCodeRelation> acrList = alpacaCodeRelationDAO.selectByExample(example);
        if(ListUtils.isBlank(acrList)) {
            return null;
        }
        List<AllInfoInPackage> topClassList = new ArrayList<AllInfoInPackage>();
        for(AlpacaCodeRelation acr : acrList) {
            String className = acr.getClassName();
            String methodName = acr.getMethodName();
            Long classDetailId = acr.getClassDetailsId();
            Long methodDetailId = acr.getMethodDetailsId();
            Long dataId = acr.getId();
            if(topClassList.size()==0) {
                if(classDetailId==null||classDetailId<=0) {
                    classDetailId = insertInitClassOrMethodDetail();//首先在detail表中插入一条class数据，返回插入的id号
                }
                if(methodDetailId==null||methodDetailId<=0) {
                    methodDetailId = insertInitClassOrMethodDetail();
                }
                acr.setClassDetailsId(classDetailId);
                acr.setMethodDetailsId(methodDetailId);
                if(acr.getClassDetailsId()==null||acr.getMethodDetailsId()==null)
                    updateClassOrMethodId(dataId,classDetailId,methodDetailId);
                addNewMethodData(acr, topClassList);//最终返回数据插入初值
            } else {
                boolean isClassNameExist = false;
                for(AllInfoInPackage allInfoInPackage:topClassList) {
                    List<MethodInfoDto> methodLists;
                    MethodInfoDto newMethodInfoDto = new MethodInfoDto();
                    if(className.equals(allInfoInPackage.getClassName())) {
                        Long publicClassId = allInfoInPackage.getClassDetailId();
                        methodLists = allInfoInPackage.getMethodInfos();
                        newMethodInfoDto.setMethodName(methodName);
                        if(methodDetailId==null||methodDetailId<=0) {
                            methodDetailId = insertInitClassOrMethodDetail();
                            updateClassOrMethodId(dataId,publicClassId,methodDetailId);
                        }
                        newMethodInfoDto.setMethodDetailId(methodDetailId);
                        newMethodInfoDto.setMethodAttr(this.queryMethodOrClassDescriptionById(methodDetailId).getAttribute());//设置属性
                        methodLists.add(newMethodInfoDto);
                        isClassNameExist = true;
                        break;
                    }
                }
                if(!isClassNameExist) {
                    if(classDetailId==null||classDetailId<=0) {
                        classDetailId = insertInitClassOrMethodDetail();//首先在detail表中插入一条class数据，返回插入的id号
                    }
                    if(methodDetailId==null||methodDetailId<=0) {
                        methodDetailId = insertInitClassOrMethodDetail();
                    }
                    acr.setClassDetailsId(classDetailId);
                    acr.setMethodDetailsId(methodDetailId);
                    if(acr.getClassDetailsId()==null||acr.getMethodDetailsId()==null)
                        updateClassOrMethodId(dataId,classDetailId,methodDetailId);
                    addNewMethodData(acr, topClassList);//最终返回数据插入初值
                }
            }

        }
        return topClassList;
    }
private void addNewMethodData(AlpacaCodeRelation acr, List<AllInfoInPackage> topClassList) {
        String className = acr.getClassName();
        String methodName = acr.getMethodName();
        Long classDetailId = acr.getClassDetailsId();
        Long methodDetailId = acr.getMethodDetailsId();
        AllInfoInPackage allInfoInPackage = new AllInfoInPackage();
        allInfoInPackage.setClassName(className);
        allInfoInPackage.setClassDetailId(classDetailId);
        allInfoInPackage.setClassDesc(this.queryMethodOrClassDescriptionById(classDetailId).getDescription());//加入类描述信息
        MethodInfoDto methodInfoDto = new MethodInfoDto();
        methodInfoDto.setMethodName(methodName);
        methodInfoDto.setMethodDetailId(methodDetailId);
        methodInfoDto.setMethodAttr(this.queryMethodOrClassDescriptionById(methodDetailId).getAttribute());
        List<MethodInfoDto> methodInfos = new ArrayList<MethodInfoDto>();
        methodInfos.add(methodInfoDto);
        allInfoInPackage.setMethodInfos(methodInfos);
        topClassList.add(allInfoInPackage);
    }

    private Long insertInitClassOrMethodDetail() {
        AlpacaCodeRelationDetails acrd = new AlpacaCodeRelationDetails();
        acrd.setGmtCreate(new Date());
        acrd.setGmtModified(new Date());
        acrd.setIsDeleted("n");
        Long detailId = alpacaCodeRelationDetailsDAO.insert(acrd);
        return detailId;
    }

    //通过id来更新相应表中的classDetailId或者methodDetailId字段
    private int updateClassOrMethodId(Long id,Long classDetailId,Long methodDetailId) {
        AlpacaCodeRelation record = new AlpacaCodeRelation();
        record.setId(id);
        record.setGmtModified(new Date());
        record.setClassDetailsId(classDetailId);
        record.setMethodDetailsId(methodDetailId);
        int row = alpacaCodeRelationDAO.updateByPrimaryKeySelective(record);
        return row;
    }






测试代码部分：

（1）

package test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

public class ListTest {
	public static void main(String[] args) {
		List<List<String>> maa = new ArrayList<List<String>>();
		List<AlpacaCodeRelation> acrList = new ArrayList<AlpacaCodeRelation>();
		for(int i=0;i<6;i++) {
			AlpacaCodeRelation acr = new AlpacaCodeRelation();
			
			if(i==1||i==4) {
				acr.setClassName("lxp0");
			} else 
				acr.setClassName("lxp"+i);
			
			acr.setMethodName("lxpm"+i);
			acr.setPackageName("lxpp"+i);
			acrList.add(acr);
		}
		
		List<AllInfoInPackage> topClassList = new ArrayList<AllInfoInPackage>();
        for(AlpacaCodeRelation acr : acrList) {
            String packageName = acr.getPackageName();
            String className = acr.getClassName();
            String methodName = acr.getMethodName();
            if(topClassList==null||topClassList.size()==0) {
 /*           	AllInfoInPackage allInfoInPackage = new AllInfoInPackage();
            	allInfoInPackage.setClassName(className);
            	MethodInfoDto methodInfoDto = new MethodInfoDto();
            	methodInfoDto.setMethodName(methodName);
                List<MethodInfoDto> methodInfos = new ArrayList<MethodInfoDto>();
                methodInfos.add(methodInfoDto);
                allInfoInPackage.setMethodInfos(methodInfos);
                topClassList.add(allInfoInPackage);
                System.out.println("haha:"+topClassList.toString());*/
            	addNewMethodData(acr, topClassList);
            } else {
                boolean isClassNameExist = false;              
                for(AllInfoInPackage allInfoInPackage:topClassList) {
                	List<MethodInfoDto> methodLists = new ArrayList<MethodInfoDto>();
                	MethodInfoDto newMethodInfoDto = new MethodInfoDto();
                    if(className.equals(allInfoInPackage.getClassName())) {
                        methodLists = allInfoInPackage.getMethodInfos();
                        newMethodInfoDto.setMethodName(methodName);
                        methodLists.add(newMethodInfoDto);
//                        System.out.println("topClassList:"+topClassList.toString());
                        isClassNameExist = true;
                        break;
                    } 
                }
                if(!isClassNameExist) {
/*                	List<MethodInfoDto> methodLists = new ArrayList<MethodInfoDto>();
                	AllInfoInPackage allInfoInPackage = new AllInfoInPackage();
                	allInfoInPackage.setClassName(className);
                	MethodInfoDto methodInfoDto = new MethodInfoDto();
                	methodInfoDto.setMethodName(methodName);
                    methodLists.add(methodInfoDto);
                    allInfoInPackage.setMethodInfos(methodLists);
                    topClassList.add(allInfoInPackage);*/
                	addNewMethodData(acr,topClassList);
                    System.out.println("topClassList2:"+topClassList.toString());
                }
            }
            
        }
	}
	private void testtest() {
		String sql = "{'topic':'haha','priority':'p1','url':'http://sss'}";
		JSON json = JSONObject.parseObject(sql);
	}
	
	private static void addNewMethodData(AlpacaCodeRelation acr,List<AllInfoInPackage> topClassList) {
		String className = acr.getClassName();
		String methodName = acr.getMethodName();
		AllInfoInPackage allInfoInPackage = new AllInfoInPackage();
    	allInfoInPackage.setClassName(className);
    	MethodInfoDto methodInfoDto = new MethodInfoDto();
    	methodInfoDto.setMethodName(methodName);
        List<MethodInfoDto> methodInfos = new ArrayList<MethodInfoDto>();
        methodInfos.add(methodInfoDto);
        allInfoInPackage.setMethodInfos(methodInfos);
        topClassList.add(allInfoInPackage);
	}
}
（2） 

package test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSONObject;

public class CopyOfListTest {
	public static void main(String[] args) {
		CopyOfListTest ll = new CopyOfListTest();
		/**
		 * 测试数据
		 * 1、全部都不同，也就是6个包名，6个class名，6个method名
		 * 2、有2个包名相同，但是类名和方法名不同的：p1==p2=1,
		 * 3、有2个包名相同，类名也相同，但是2个方法不同
		 * 4、有2个包名相同，类名相同，方法相同
		 */
		ll.test(3);
	}
	
	private void test(int k) {
		List<List<String>> maa = new ArrayList<List<String>>();
		List<AlpacaCodeRelation> acrList = new ArrayList<AlpacaCodeRelation>();
		
		if(k==1) {
			for(int i=0;i<6;i++) {
				AlpacaCodeRelation acr = new AlpacaCodeRelation();			
				acr.setPackageName("p"+i);
				acr.setClassName("c"+i);		
				acr.setMethodName("m"+i);
				acrList.add(acr);
			}
		} else if(k==2) {
			for(int i=0;i<6;i++) {
				AlpacaCodeRelation acr = new AlpacaCodeRelation();
				if(i==1||i==3) {
					acr.setPackageName("p1");
					acr.setClassName("c"+i);		
					acr.setMethodName("m"+i);
				} 
				else {
					acr.setPackageName("p"+i);
					acr.setClassName("c"+i);		
					acr.setMethodName("m"+i);
				}			
				acrList.add(acr);
			}
		} else if(k==3) {

			for(int i=0;i<6;i++) {
				AlpacaCodeRelation acr = new AlpacaCodeRelation();
				if(i==1||i==3) {
					acr.setPackageName("p1");
					acr.setClassName("c"+i);		
					acr.setMethodName("m"+i);
				} else if (i==2||i==4) {
					acr.setPackageName("p2");
					acr.setClassName("c2");		
					acr.setMethodName("m"+i);
				}
				else {
					acr.setPackageName("p"+i);
					acr.setClassName("c"+i);		
					acr.setMethodName("m"+i);
				}			
				acrList.add(acr);
			}
		} else {
			for(int i=0;i<6;i++) {
				AlpacaCodeRelation acr = new AlpacaCodeRelation();
				if(i==1||i==3) {
					acr.setPackageName("p1");
					acr.setClassName("c"+i);		
					acr.setMethodName("m"+i);
				} else if (i==2||i==4) {
					acr.setPackageName("p2");
					acr.setClassName("c2");		
					acr.setMethodName("m2");
				} 
				else {
					acr.setPackageName("p"+i);
					acr.setClassName("c"+i);		
					acr.setMethodName("m"+i);
				}			
				acrList.add(acr);
			}
		}
		
		List<ReturnClassInfoDto> topClassList = new ArrayList<ReturnClassInfoDto>();
		
		for(AlpacaCodeRelation acr : acrList) {
            String packageName = acr.getPackageName();
            String className = acr.getClassName();
            String methodName = acr.getMethodName();
            if(topClassList==null||topClassList.size()==0) {
                ReturnClassInfoDto returnClassInfoDto = new ReturnClassInfoDto();
                returnClassInfoDto.setClassName(className);
                returnClassInfoDto.setPackageName(packageName);
                List<String> methodLists = new ArrayList<String>();
                methodLists.add(methodName);
                returnClassInfoDto.setMethodNames(methodLists);
                topClassList.add(returnClassInfoDto);
                System.out.println("haha:"+topClassList.toString());
            } else {
                boolean isClassNameExist = false;              
                for(ReturnClassInfoDto returnClassInfoDto:topClassList) {
                	List<String> methodLists = new ArrayList<String>();
                    if(className.equals(returnClassInfoDto.getClassName())&&packageName.equals(returnClassInfoDto.getPackageName())) {
                        methodLists = returnClassInfoDto.getMethodNames();
                        methodLists.add(methodName);
                        returnClassInfoDto.setMethodNames(methodLists);                       
                        System.out.println(returnClassInfoDto.toString());
                        System.out.println("topClassList:"+topClassList.toString());
                        isClassNameExist = true;
                        break;
                    } 
                }
                if(!isClassNameExist) {
                	List<String> methodLists = new ArrayList<String>();
                	ReturnClassInfoDto returnClassInfoDto = new ReturnClassInfoDto();
                    returnClassInfoDto.setClassName(className);
                    returnClassInfoDto.setPackageName(packageName);
                    methodLists.add(methodName);
                    returnClassInfoDto.setMethodNames(methodLists);
                    topClassList.add(returnClassInfoDto);
                    System.out.println("topClassList2:"+topClassList.toString());
                }
            }
		}
		List<ReturnPackageInfoDto> haha = changeToPackageListInfo(topClassList);
		String json = JSONObject.toJSONString(haha);
		System.out.println("haha"+k+":"+json);
	}
	
	private List<ReturnPackageInfoDto> changeToPackageListInfo(List<ReturnClassInfoDto> returnClassInfoList) {
		List<ReturnPackageInfoDto> topPackageList = new ArrayList<ReturnPackageInfoDto>();
		for(ReturnClassInfoDto returnClassInfoDto:returnClassInfoList) {
			String packageName = returnClassInfoDto.getPackageName();
			if(topPackageList==null||topPackageList.size()==0) {
				List<ReturnClassInfoDto> dataStore = new ArrayList<ReturnClassInfoDto>();
				ReturnPackageInfoDto infoDto = new ReturnPackageInfoDto();
				dataStore.add(returnClassInfoDto);
				infoDto.setPackageName(packageName);
				infoDto.setClassInfos(dataStore);
				topPackageList.add(infoDto);
			} else {
				boolean isPackageNameExist = false;    
				for(ReturnPackageInfoDto returnPackageInfoDto:topPackageList) {
					List<ReturnClassInfoDto> middleProcess = new ArrayList<ReturnClassInfoDto>();
					if(packageName.equals(returnPackageInfoDto.getPackageName())) {
						middleProcess = returnPackageInfoDto.getClassInfos();
						middleProcess.add(returnClassInfoDto);
						isPackageNameExist = true;
						break;
					}
				}
				
				if(!isPackageNameExist) {
					List<ReturnClassInfoDto> middleProcess = new ArrayList<ReturnClassInfoDto>();
					ReturnPackageInfoDto returnPackageInfoDto = new ReturnPackageInfoDto();
					middleProcess.add(returnClassInfoDto);
					returnPackageInfoDto.setPackageName(packageName);
					returnPackageInfoDto.setClassInfos(middleProcess);
					topPackageList.add(returnPackageInfoDto);
                }
				
			}
		}
		return topPackageList;
	}
}
（3） 
package test;

import java.util.Date;

public class AlpacaCodeRelation {
    private Long id;

    private Date gmtCreate;

    private Date gmtModified;

    private Integer crid;

    private String moduleName;

    private String job;

    private String methodName;

    private String methodDesc;

    private String className;

    private String packageName;

    private Integer env;

    private String appName;

    private Long methodDetailsId;

    private Long classDetailsId;

    private String isHidden;

    private String isDeleted;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Date getGmtCreate() {
        return gmtCreate;
    }

    public void setGmtCreate(Date gmtCreate) {
        this.gmtCreate = gmtCreate;
    }

    public Date getGmtModified() {
        return gmtModified;
    }

    public void setGmtModified(Date gmtModified) {
        this.gmtModified = gmtModified;
    }

    public Integer getCrid() {
        return crid;
    }

    public void setCrid(Integer crid) {
        this.crid = crid;
    }

    public String getModuleName() {
        return moduleName;
    }

    public void setModuleName(String moduleName) {
        this.moduleName = moduleName == null ? null : moduleName.trim();
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job == null ? null : job.trim();
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName == null ? null : methodName.trim();
    }

    public String getMethodDesc() {
        return methodDesc;
    }

    public void setMethodDesc(String methodDesc) {
        this.methodDesc = methodDesc == null ? null : methodDesc.trim();
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className == null ? null : className.trim();
    }

    public String getPackageName() {
        return packageName;
    }

    public void setPackageName(String packageName) {
        this.packageName = packageName == null ? null : packageName.trim();
    }

    public Integer getEnv() {
        return env;
    }

    public void setEnv(Integer env) {
        this.env = env;
    }

    public String getAppName() {
        return appName;
    }

    public void setAppName(String appName) {
        this.appName = appName == null ? null : appName.trim();
    }

    public Long getMethodDetailsId() {
        return methodDetailsId;
    }

    public void setMethodDetailsId(Long methodDetailsId) {
        this.methodDetailsId = methodDetailsId;
    }

    public Long getClassDetailsId() {
        return classDetailsId;
    }

    public void setClassDetailsId(Long classDetailsId) {
        this.classDetailsId = classDetailsId;
    }

    public String getIsHidden() {
        return isHidden;
    }

    public void setIsHidden(String isHidden) {
        this.isHidden = isHidden == null ? null : isHidden.trim();
    }

    public String getIsDeleted() {
        return isDeleted;
    }

    public void setIsDeleted(String isDeleted) {
        this.isDeleted = isDeleted == null ? null : isDeleted.trim();
    }
}

（4） 

package test;

import java.util.List;

/**
 * Created by zouping.lxp on 2016/1/20.
 */
public class AllInfoInPackage {
	private Long classDetailId;
	private String className;
    private String classDesc;
    private String classAttr;
    private List<MethodInfoDto> methodInfos;
	public Long getClassDetailId() {
		return classDetailId;
	}
	public void setClassDetailId(Long classDetailId) {
		this.classDetailId = classDetailId;
	}
	public String getClassName() {
		return className;
	}
	public void setClassName(String className) {
		this.className = className;
	}
	public String getClassDesc() {
		return classDesc;
	}
	public void setClassDesc(String classDesc) {
		this.classDesc = classDesc;
	}
	public String getClassAttr() {
		return classAttr;
	}
	public void setClassAttr(String classAttr) {
		this.classAttr = classAttr;
	}
	public List<MethodInfoDto> getMethodInfos() {
		return methodInfos;
	}
	public void setMethodInfos(List<MethodInfoDto> methodInfos) {
		this.methodInfos = methodInfos;
	}
	@Override
	public String toString() {
		return "{classDetailId=" + classDetailId
				+ ", className=" + className + ", classDesc=" + classDesc
				+ ", classAttr=" + classAttr + ", methodInfos=" + methodInfos
				+ "}";
	}
}

数据结构示意图





uestc_lxp
关注
专栏目录
Unity 面试篇|（六）数据结构和算法篇 【全面总结 | 持续更新】
游戏开发小Y的博客
01-20 5万+
先拿10000个数建堆，然后一次添加剩余元素，如果大于堆顶的数（10000中最小的），将这个数替换堆顶，并调整结构使之仍然是一个最小堆，这样遍历完后，堆中的10000个数就是所需的最大的10000个。桶排序是计数排序的升级版。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。这样处理就可以分别在每个文件的10^6个数据中找出最大的10000个数，合并到一起在再找出1000*10000中的最终的结果。
数据结构与算法必知基础知识
热门推荐
bigsai
01-06 1万+
原创公众号：bigsai 文章已收录在 全网都在关注的数据结构与算法学习仓库 欢迎star 前言 数据结构与算法是程序员内功体现的重要标准之一，且数据结构也应用在各个方面，业界更有程序=数据结构+算法这个等式存在。各个中间件开发者，架构师他们都在努力的优化中间件、项目结构以及算法提高运行效率和降低内存占用，在这里数据结构起到相当重要的作用。此外数据结构也蕴含一些面向对象的思想，故学好掌握数据结构对逻辑思维处理抽象能力有很大提升。 为什么学习数据结构与算法？如果你还是学生，那么这门课程是必修的，考研基本也.
数据结构之树（二叉树、堆）（一对多结构）
Glanic的博客
10-21 682
二叉树 二叉树是一种常用的数据结构，处理起来比较简单方便，而且普通树可以很方便地转换成二叉树使用 二叉树的定义：节点的度最多为2的树 二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。 二叉树的性质： 性质1：二叉树的第i层上至多有2^(i-1)（i≥1）个节点。 满二叉树： 1、每层的节点数都是2^(i-1) 2、可以理解为二叉树中每一层都是满的
java中的数据结构_java 中几种常用数据结构
weixin_33443972的博客
02-12 300
JAVA中常用的数据结构(java.util. 中)java中有几种常用的数据结构，主要分为Collection和map两个主要接口(接口只提供方法，并不提供实现)，而程序中最终使用的数据结构是继承自这些接口的数据结构类。其主要的关系(继承关系)有： (----详细参见java api文档！)Collection---->Collections ...
图——一种多对多的数据结构
最新发布
chujieli的博客
11-24 796
图是一种描述多对多数据关系的数据结构，线性表和树都可以看作是图的一种特殊情况。图中包含以下元素：1.一组定点：通常用V(Vertex)表示顶点的集合。2.一组边：通常用E(Edge)表示边的集合，便是顶点对（v,w）∈E，其中v，w∈V。有向边表示从v指向w的边（单行线）。不考虑重边和自回路。数据名称：图（Graph）数据对象集：G(V,E)由一个非空的有限定点集合V,和一个有限边集合E组成。操作集：·Graph Create():初始化并返回一个空图。
数据结构之图
我的编程世界
10-08 296
图结构反映的多对多的关系，即任意两个结点之间都可能相关。
将既存的1对多改造为多对多的数据结构方法
04-16 507
原主从表为1对多关系A为主表，B为从表，查询语句如下： SELECT * FROM B b LEFT JOIN A a ON b.parent_id = a.id 由于业务调整，A与B转化为多对多关系 1. 建立A与B的关联关系表 CREATE TABLE a_b_relation( a_id VARCHAR(40), b_id VARCHAR(40) ...
什么是数据结构？对数据结构的理解
weixin_42952472的博客
03-28 1万+
数据结构 大学已逐渐进入尾声，想回顾一下自己专业所学的内容，看到数据结构这些概念，也总是记不住，理解也不是很深刻。想借助写下这些来加深一些印象吧。以下一些相关的内容，来自王道的数据结构讲解。 基本概念 数据结构是相互之间存在一种或多种特定关系的数据元素的集合。这个概念对于我来说太过于深奥，也不能记住，于是我思考。举个例子，在食堂里吃麻辣香锅，我们需要排队，并且食堂阿姨会给你号码牌，我们吃麻辣香锅的...
【数据结构功法】第1话 · 数据结构入门竟如此简单？
kikokingの比特宇宙
03-23 1万+
从今天开始，我将正式开启一个新的打卡专题——【数据结构·水滴计划】，没错！这是今年上半年的一整个系列计划！本专题目的是通过百天刷题计划，通过题目和知识点串联的方式，刷够1000道题！完成对数据结构相关知识的全方位复习和巩固；同时还配有专门的笔记总结和文档教程哦！想要搞定，搞透数据结构的同学，欢迎订阅本专栏！.........
java数据结构
m0_67698950的博客
05-22 4480
一、java集合 　　研究表明，人类大脑右脑的记忆能力是左脑的10万的倍，右脑对图形图像处理比较敏感，因而借助于图形图像能快速提高记忆效率，废话不多说，直接上图： 　　 　　　　　　　　　　　　　　　　　　　Collection集合体系继承关系 　　 　　　　　　　　　　　　　　　 Map集合体系继承关系 1、线性表的性能分析 各种线性表的性能分析概览： 1.1、数组 　　以一块连续内存区来保存所有的数组元素，所以数组在随机访问时性能最好。所有的内部以数组作为底层实现的集合在随
数据结构之一对多，树（完结）
Juinjonn的博客
03-03 1172
树，**定义:**一个树至多有一个根节点,每一个路径的终端都叫终端节点,也叫叶子结点。既不是根也不是叶子节点叫中间节点,节点与节点连接的线叫边。从底下往上看叫***高度***,从上往低看叫***深度***。 PS:树整体高度和深度取最大值。 度:看当前节点有n个子节点就叫n度。
一对多的美——数据结构之树和二叉树
diviner_s的博客
04-14 858
数和二叉树 树的定义 树：是n（n≥0）个结点的有限集。 若 n = 0，称为空树：； 若 n > 0,则它满足如下两个条件； （1）有且仅有一个特定的称为根（Root）的结点； （2）其余结点可分为m（m≥0）个互不相交的有限集T1，T2，T3，···，Tm，其中每一个集合本身又是一棵树，并称为根的子树（SubTree）。 树是n个结点的有限集 树还有其他的表示方式：嵌套集合、广义表、凹入...
java多对多_Java多对多关系示例
weixin_30075405的博客
02-12 656
使用集合不仅可以表示一对一的关系，也可以表示多对多的关系。例如，一个学生可以选多门课程，一门课程可以有多个学生参加，那么这就是一个典型的多对多关系。要完成上面要求，首先应该定义两个类，分别是学生信息(Student)类、课程信息(Course)类。在学生类中存在一个集合，保存全部的课程。同样，在课程类中也要存在一个集合，保存全部的学生。1)定义学生类public class Student {pr...
简单了解C#之数据结构与算法（一）数据结构介绍
Root915的博客
07-17 358
一、数据结构分类 1.集合：元素之间的关系是“只属于一个集合” 2.线性结构：元素之间的关系是一对一关系 3.树形结构：一对多关系 4.图状结构：多对多关系 二、算法 算法的评价标准 运行时间 占用空间 正确性 可读性 健壮性 ...
Mybatis之Mapper接口及Example实例函数使用详解
Calvin的博客
10-29 1189
  声明：本文章部分内容源自于CSDN博主biandous的博客文章，在其基础上进行了部分修正和代码修改。 一、Mapper接口方法 方法 功能说明 int countByExample(UserExample example) throws SQLException 按条件计数 int deleteByPrimaryKey(Integer id) throws SQLE...
数据结构-图
feizai1208917009的博客
03-15 698
一、图的引入 图的用处：存储多对多的关系 图的存储结构：顺序表结构（二维数组）、链式表结构（链表） 图的路径规划：最短路径问题/算法 二、 图的定义 图（graph）是一种存储多对多关系的一种网状数据结构。图是由费控顶点集合和一个描述定点之间关系的集合组成。 （1）无向图、有向图 （2）加权图 ...
【考研--数据结构】 多对多数据结构——图
高斯的博客
08-27 2402
G(V,E)，点V，边E的集合为G，称之为 图（Graph）n表示点数量，m表示边数量。
C#数据结构与算法之二：线性表
爱吃猫的小鱼干
10-25 2110
目录 第二章 线性表 2.1 CLR中的线性表 2.2线性表的接口定义 2.3线性表的实现方式 2.3.1顺序表 2.3.2单链表 2.3.3双向链表 2.3.4循环链表 2.4栈和队列 2.4.1栈 2.4.2队列 2.4.3栈和队列应用实例 2.5串和数组 2.5.1串 2.5.2数组 首先感谢siki老师对C#数据结构与算法的讲解。原视频内容戳这里http:/...
Java常用数据结构总结
HelloWorld搬运工
02-16 1万+
数据元素相互之间的关系称为结构。有四类基本结构：集合、线性结构、树形结构、图状结构; 集合结构:除了同属于一种类型外，别无其它关系 线性结构:元素之间存在一对一关系常见类型有: 数组,链表,队列,栈,它们之间在操作上有所区别.例如:链表可在任意位置插入或删除元素,而队列在队尾插入元素,队头删除元素,栈只能在栈顶进行插入,删除操作. 树形结构:元素之间存在一对多关系,常见类型有:树(有许多特例:二...
数据结构基础：影响磁盘读写时间的因素
在教学方面，根据描述，该课程的教材来自《数据结构（C++描述）》，期末考试采取开卷形式，占总成绩70%，平时作业和实验占30%。考试侧重考察概念、方法、技巧、思想、创新和程序设计风格。此外，还推荐了几本参考书...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值