精华内容
下载资源
问答
  • C#数据结构

    2013-12-10 11:49:54
    释数据结构及其有关概念,接着讨论算法相关知识,最后简单介绍本书所要用 到相关数学知识和C#知识。 1.1 数据结构 1.1.1 学习数据结构的必要性 我们知道,虽然每个人都懂得英语语法与基本类型,但是对于同样...
  • 数据结构概括

    2014-09-13 20:00:52
    一、基本概念 1、数据结构:指相互之间存在一定关系数据元素集合。...根据数据元素之间逻辑关系不同,数据结构分为以下四类。 (1)集合:数据元素之间就是属于同一个集合,除此之外,没有任何关系。

    一、基本概念

    1、数据结构:指相互之间存在一定关系的数据元素的集合。

    2、数据:信息的载体,在计算机科学中是指所有能输入到计算机中并能被计算机程序识别和处理的符号集合。

    3、数据元素:数据的基本单位。

    4、数据项:构成元素的不可分割的最小单位。

    、分类

    根据数据元素之间逻辑关系的不同,数据结构分为以下四类。

    (1)集合:数据元素之间就是属于同一个集合,除此之外,没有任何关系。

    (2)线性结构:数据元素之存在一对一的线性关系。

    (3)树结构:数据元素之间存在一对多的层次关系。

    (4)图结构:数据元素之间存在多对多的关系。

    三、抽象数据类型

    1、数据类型

    数据类型是一组值的集合以及定义与这个值集上的一组操作总称。

    2、抽象

    抽象就是抽出问题本质的特征而忽略非本质的细节,是对具体事务的一个概括。

    3、抽象数据类型

    抽象数据类型是一个数据结构以及定义在该结构上的一组操作的总称。

    四、算法及算法分析

    1、算法:是指解决问题的方法。

    2、算法必须满足的五个重要特性。

    (1)输入:一个算法有零个或多个输入,这些输入通常取自于某个特定的对象集合。

    (2)输出:一个算法有一个或多个输出,通常输出与输入之间有着特定的关系。

    (3)有穷性:一个算法必须总是在执行有穷步骤后结束,且每一步都在有穷时间内完成。

    (4)确定性:算法中每一条指令必须有确切的含义。

    (5)可行性:算法描述的操作可以通过已经实现的基本操作执行有限次来实现。

    3、算法的描述方法

    (1)自然语言

    优点:容易理解。缺点:容易出现二义性。

    (2)流程图

    优点:直观易懂。缺点:严密性差。

    (3)程序设计语言

    (4)伪代码:被称为算法语言或第一语言。

    4、算法分析

    (1)度量算法效率的方法

    事前分析估算的方法——渐进发杂度

    (2)算法的时间复杂度

    若存在两个正常数c和n。,对于任意数n>=n。,都有T<=c*f(n),则称T(n)=O(f(n))(或称算法在O(f(n)中)。

    (3)算法的空间复杂度

    算法临时开辟的存储空间。通常记做S(n)=O(f(n)),n为问题规模,分析方法与算法的时间复杂度类似。

     

    展开全文
  • 数据结构-并查集

    2021-01-12 14:56:42
    简介 并查集(Disjoint-Set)是一种可以动态维护若干个重叠的集合,并支持合并与查询两种操作的一种数据结构。 就是维护多个集合之间的关系,集合的合并和查询定位...我们可以用数组来表示数据结构(并查集表示的是

    简介

    并查集(Disjoint-Set)是一种可以动态维护若干个不重叠的集合,并支持合并与查询两种操作的一种数据结构。
    就是维护多个集合之间的关系,集合的合并和查询定位(哪个元素属于哪些集合等查询操作),所以并查集主要包括两种操作:

    合并(Union):合并两个集合;
    查询(Find):查询元素属于哪些集合。

    由上面的概念,我们可以知道并查集主要解决以下几个个问题:

    合并两个或多个集合;
    判断某一个元素或者多个元素是否属于某个集合

    分析

    慢union,快find

    我们可以用数组来表示数据结构(并查集表示的是多个集合之间的关系,使用map不能直观的描述多个集合的关系),数组的下标代表元素,存储的内容代表所在的集合,如下:

    在这里插入图片描述
    此时假如我们需要将元素2合并到元素1所在集合,则直接使arr[2]=arr[1]就行了

    在这里插入图片描述
    假如我们要将1集合加入到3集合,也就是元素1和元素2加入到3的集合中,则需要将元素1和元素2所在的集合做更改,arr[1]=3,arr[2]=3,合并的时间复杂度为O(n)

    在这里插入图片描述

    这时判断元素1和元素2是否在同一个集合只需要判断数组内值是否相等即可arr[1]==arr[2],相等则说明属于同一个集合,时间复杂度为O(1)
    示例代码如下(慢union,快):

    package com.example.demo;
    
    public class Test {
    
        private static int[] arr = new int[]{0,1,2,3,4,5,6,7};
    
        public static void main(String[] args) throws Exception {
            System.out.println("元素所在集合初始:" );
            arrToString(arr);
            System.out.println("将元素2合并到元素1所在集合");
            union(2,1);
            arrToString(arr);
            System.out.println("将元素1、2合并到3所在集合");
            union(1,3);
            arrToString(arr);
        }
    
        /**
         * 查看元素属于哪个集合
         * 时间复杂度为 O(1)
         * @param index
         * @return
         */
        public static int find(int index){
            return arr[index];
        }
    
        /**
         * 判断两个元素是否属于同一个集合
         * @param first
         * @param second
         * @return
         */
        public static boolean isTogether(int first, int second){
            return find(first) == find(second);
        }
    
        /**
         * 时间复杂度为 O(n)
         * 将first元素所在集合合并到second元素所在集合
         * @param first
         * @param second
         */
        public static void union(int first, int second){
            int m1 = find(first);
            int m2 = find(second);
    
            for(int i = 0; i < arr.length;i++){
                if(arr[i] == m1 ){
                    arr[i] = m2;
                }
            }
    
        }
    
        public static void arrToString(int[] arr){
            if(null == arr || arr.length <= 0){
                return;
            }
            System.out.print("数组元素:");
            for(int i = 0 ; i < arr.length ; i ++){
                System.out.print(i + " " );
            }
            System.out.println("");
            System.out.print("所在集合:");
            for(int c : arr){
                System.out.print(c + " ");
            }
            System.out.println("");
        }
    
    }
    

    输出:
    元素所在集合初始:
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 1 2 3 4 5 6 7
    将元素2合并到元素1所在集合
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 1 1 3 4 5 6 7
    将元素1、2合并到3所在集合
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 3 3 3 4 5 6 7

    上面的方法union时间复杂度是O(n),每次合并都需要把需要合并的集合遍历一遍,当集合内数据很大时肯定是不行的,我们需要对union进行优化

    快union,慢find

    我们将上面的关系转化为树形结构,改成树形结构时我们需要对数组进行小调整,数组下标依然表示元素,数组内容需要变为父集合。

    上面我们将2加入1,则元素2的父集合就是1所在的集合,1加入3则元素1的父集合就是3所在的集合,稍做调整后的数组结为arr[2]=arr[1],arr[1]=arr[3],如图:

    在这里插入图片描述
    树形结构如下图:

    在这里插入图片描述
    这个时候假如我们将3集合合并到4集合,其实只需要把领头的元素3加入到4集合,元素1,2,3的关系保持不变就可以了,只需要操作一步就完成了合并操作。这个时候数据结构就从数组转变成了树形结构,成功的将union时间复杂度变为了O(1)

    在这里插入图片描述
    再来看find(1),需要找到顶部元素所在集合(也就是元素4所在集合)即可,时间复杂度取决于树的深度
    示例代码:

    package com.example.demo;
    
    public class Test2 {
    
        private static int[] arr = new int[]{0,3,1,3,4,5,6,7};
    
        public static void main(String[] args) throws Exception {
            System.out.println("元素所在集合初始:");
            arrToString(arr);
            System.out.println("将元素3所在集合合并到元素4所在集合");
            union(3, 4);
            arrToString(arr);
        }
    
        /**
         * 查看元素属于哪个集合
         * 时间复杂度为 O(1)
         * @param index
         * @return
         */
        public static int find(int index){
            // 判断自己是不是顶部节点 没有父集合就是顶部元素
            while(index != arr[index]){
                //如果不是顶部元素  则往上查找  知道找到顶部元素为止
                //顶部元素所在的集合就是该元素所在的集合
                index = arr[index];
            }
            return index;
        }
    
        /**
         * 判断两个元素是否属于同一个集合
         * @param first
         * @param second
         * @return
         */
        public static boolean isTogether(int first, int second){
            return find(first) == find(second);
        }
    
        /**
         * 时间复杂度为 O(n)
         * 将first元素所在集合合并到second元素所在集合
         * @param first
         * @param second
         */
        public static void union(int first, int second){
            int firstRoot = find(first);
            int secondRoot = find(second);
            // 如果所属集合相等则不操作
            if(firstRoot == secondRoot){
                return ;
            }
            // 否则将first元素所在集合的顶部元素所在的父集合指向元素second顶部元素所在的集合,则完成了合并
            arr[firstRoot] = secondRoot;
        }
    
        public static void arrToString(int[] arr){
            if(null == arr || arr.length <= 0){
                return;
            }
            System.out.print("数组元素:");
            for(int i = 0 ; i < arr.length ; i ++){
                System.out.print(i + " " );
            }
            System.out.println("");
            System.out.print("所在集合:");
            for(int c : arr){
                System.out.print(c + " ");
            }
            System.out.println("");
        }
    
    }
    

    输出:
    元素所在集合初始:
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 3 1 3 4 5 6 7
    将元素3所在集合合并到元素4所在集合
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 3 1 4 4 5 6 7

    快速union,快速find,基于重量

    上面的例子中我们要找到2所在的集合需要把整个集合都遍历一遍,这是因为每次合并时都是往父一级追加,形成了线性链表,上面的优化导致了find方法时间复杂度为集合深度。为了再次优化find方法,我们需要优化树结构的生成规则。既然两个元素合并到一个元素,以上面的例子举例,元素3合并到元素4和元素4合并到元素3其实是一个效果,但是显然元素4合并到元素3更为合理。也就是谁元素多谁为主,元素少的集合合并到元素多的集合中,这样就能降低树的深度提高find效率了

    在这里插入图片描述

    示例代码:

    package com.example.demo;
    
    public class Test3 {
    
        private static int[] arr    = new int[]{0,3,1,3,4,5,6,7};
        private static int[] weight = new int[]{1,1,0,2,1,1,1,1};
    
        public static void main(String[] args) throws Exception {
            System.out.println("元素所在集合初始:");
            arrToString(arr);
            System.out.println("将元素3所在集合和元素4所在集合合并");
            union(3, 4);
            arrToString(arr);
        }
    
        /**
         * 查看元素属于哪个集合
         * 时间复杂度为 O(1)
         * @param index
         * @return
         */
        public static int find(int index){
            // 判断自己是不是顶部节点 没有父集合就是顶部元素
            while(index != arr[index]){
                //如果不是顶部元素  则往上查找  知道找到顶部元素为止
                //顶部元素所在的集合就是该元素所在的集合
                index = arr[index];
            }
            return index;
        }
    
        /**
         * 判断两个元素是否属于同一个集合
         * @param first
         * @param second
         * @return
         */
        public static boolean isTogether(int first, int second){
            return find(first) == find(second);
        }
    
        /**
         * 时间复杂度为 O(n)
         * 将first元素所在集合合并到second元素所在集合
         * @param first
         * @param second
         */
        public static void union(int first, int second){
            int firstRoot = find(first);
            int secondRoot = find(second);
            // 如果所属集合相等则不操作
            if(firstRoot == secondRoot){
                return ;
            }
            // 取出所在集合元素个数
            int fweight = weight[firstRoot];
            int sweight = weight[secondRoot];
            if(fweight < sweight){
                //若second所在集合元素个数大于first所在集合元素个数
                // 则将first元素加入second元素所在集合
                arr[firstRoot] = secondRoot;
                weight[secondRoot] = sweight + fweight ;
            }else{
                // 于上面相反
                arr[secondRoot] = firstRoot;
                weight[firstRoot] = fweight + sweight;
    
            }
    
        }
    
        public static void arrToString(int[] arr){
            if(null == arr || arr.length <= 0){
                return;
            }
            System.out.print("数组元素:");
            for(int i = 0 ; i < arr.length ; i ++){
                System.out.print(i + " " );
            }
            System.out.println("");
            System.out.print("所在集合:");
            for(int c : arr){
                System.out.print(c + " ");
            }
            System.out.println("");
            System.out.print("集合重量:");
            for(int c : weight){
                System.out.print(c + " ");
            }
            System.out.println("");
        }
    
    }
    

    元素所在集合初始:
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 3 1 3 4 5 6 7
    集合高度:1 1 0 2 1 1 1 1
    将元素3所在集合合并到元素4所在集合
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 3 1 3 3 5 6 7
    集合重量:1 1 0 3 1 1 1 1

    观察上面输出可以看到元素4加入了集合3

    快速union,快速find,基于高度(基于秩)

    对于上述改进方法,只是单纯的判断集合内元素的个数大小来决定如何合并集合,如果数据结构是如下图时:

    在这里插入图片描述
    假如按照元素个数谁大合并到谁那则会出现下面的情况

    在这里插入图片描述

    集合5加入了集合3,树的高度变为了4,极端情况下find的时间复杂度会无限接近o(n)(无限接近线性链表的结构)。假如我们按照树的高度来判断合并到哪个集合,上述情况合并会得到:

    在这里插入图片描述
    示例代码:

    package com.example.demo;
    
    public class Test4 {
    
        private static int[] arr    = new int[]{0,3,3,3,3,5,5,6};
        private static int[] height = new int[]{1,1,1,2,1,3,2,1};
    
        public static void main(String[] args) throws Exception {
            System.out.println("元素所在集合初始:");
            arrToString(arr);
            System.out.println("将元素3所在集合和元素5所在集合合并");
            union(3, 5);
            arrToString(arr);
        }
    
        /**
         * 查看元素属于哪个集合
         * 时间复杂度为 O(1)
         * @param index
         * @return
         */
        public static int find(int index){
            // 判断自己是不是顶部节点 没有父集合就是顶部元素
            while(index != arr[index]){
                //如果不是顶部元素  则往上查找  知道找到顶部元素为止
                //顶部元素所在的集合就是该元素所在的集合
                index = arr[index];
            }
            return index;
        }
    
        /**
         * 判断两个元素是否属于同一个集合
         * @param first
         * @param second
         * @return
         */
        public static boolean isTogether(int first, int second){
            return find(first) == find(second);
        }
    
        /**
         * 时间复杂度为 O(n)
         * 将first元素所在集合合并到second元素所在集合
         * @param first
         * @param second
         */
        public static void union(int first, int second){
            int firstRoot = find(first);
            int secondRoot = find(second);
            // 如果所属集合相等则不操作
            if(firstRoot == secondRoot){
                return ;
            }
            // 取出所在集合元素个数
            int fheight = height[firstRoot];
            int sheight = height[secondRoot];
            if(fheight < sheight){
                //若second所在集合高度大于first所在集合高度
                // 则将first元素加入second元素所在集合
                // 高度取决于最高的集合 所以最大高度并不会改变
                arr[firstRoot] = secondRoot;
            }else if(fheight == sheight){
                //若second所在集合高度和first所在集合高度  相等
                // 则将first元素加入second元素所在集合
                // 高度+1
                arr[firstRoot] = secondRoot;
                height[secondRoot] = sheight + 1;
            }else{
                //若second所在集合高度小于first所在集合高度
                // 则将second元素加入first元素所在集合
                // 高度不变
                arr[secondRoot] = firstRoot;
            }
    
        }
    
        public static void arrToString(int[] arr){
            if(null == arr || arr.length <= 0){
                return;
            }
            System.out.print("数组元素:");
            for(int i = 0 ; i < arr.length ; i ++){
                System.out.print(i + " " );
            }
            System.out.println("");
            System.out.print("所在集合:");
            for(int c : arr){
                System.out.print(c + " ");
            }
            System.out.println("");
            System.out.print("集合高度:");
            for(int c : height){
                System.out.print(c + " ");
            }
            System.out.println("");
        }
    
    }
    

    输出:
    元素所在集合初始:
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 3 3 3 3 5 5 6
    集合高度:1 1 1 2 1 3 2 1
    将元素3所在集合和元素5所在集合合并
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 3 3 5 3 5 5 6
    集合高度:1 1 1 2 1 3 2 1

    最大高度还是3没有变化

    路径压缩

    针对基于重量的优化,我们可以将叶子节点直接指向父元素的父元素所在集合,这样也能压缩树的高度,提高find性能。这种方法实际上没有改变树的结构,只是直接越级查找了
    示例代码:

    package com.example.demo;
    
    public class Test32 {
    
        private static int[] arr    = new int[]{0,3,1,3,4,5,6,7};
        private static int[] weight = new int[]{1,1,0,2,1,1,1,1};
    
        public static void main(String[] args) throws Exception {
            System.out.println("元素所在集合初始:");
            arrToString(arr);
            System.out.println("将元素3所在集合和元素4所在集合合并");
            union(3, 4);
            arrToString(arr);
        }
    
        /**
         * 查看元素属于哪个集合
         * 时间复杂度为 O(1)
         * @param index
         * @return
         */
        public static int find(int index){
            // 判断自己是不是顶部节点 没有父集合就是顶部元素
            while(index != arr[index]){
                //如果不是顶部元素  则往上查找  知道找到顶部元素为止
                // 这里查找采用路径压缩法,越过一级往上查找
                index = arr[arr[index]];
            }
            return index;
        }
    
        /**
         * 判断两个元素是否属于同一个集合
         * @param first
         * @param second
         * @return
         */
        public static boolean isTogether(int first, int second){
            return find(first) == find(second);
        }
    
        /**
         * 时间复杂度为 O(n)
         * 将first元素所在集合合并到second元素所在集合
         * @param first
         * @param second
         */
        public static void union(int first, int second){
            int firstRoot = find(first);
            int secondRoot = find(second);
            // 如果所属集合相等则不操作
            if(firstRoot == secondRoot){
                return ;
            }
            // 取出所在集合元素个数
            int fweight = weight[firstRoot];
            int sweight = weight[secondRoot];
            if(fweight < sweight){
                //若second所在集合元素个数大于first所在集合元素个数
                // 则将first元素加入second元素所在集合
                arr[firstRoot] = secondRoot;
                weight[secondRoot] = sweight + fweight;
            }else{
                // 于上面相反
                arr[secondRoot] = firstRoot;
                weight[firstRoot] = fweight + sweight;
    
            }
    
        }
    
        public static void arrToString(int[] arr){
            if(null == arr || arr.length <= 0){
                return;
            }
            System.out.print("数组元素:");
            for(int i = 0 ; i < arr.length ; i ++){
                System.out.print(i + " " );
            }
            System.out.println("");
            System.out.print("所在集合:");
            for(int c : arr){
                System.out.print(c + " ");
            }
            System.out.println("");
            System.out.print("集合重量:");
            for(int c : weight){
                System.out.print(c + " ");
            }
            System.out.println("");
        }
    
    }
    

    输出:
    元素所在集合初始:
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 3 1 3 4 5 6 7
    集合重量:1 1 0 2 1 1 1 1
    将元素3所在集合和元素4所在集合合并
    数组元素:0 1 2 3 4 5 6 7
    所在集合:0 3 1 3 3 5 6 7
    集合重量:1 1 0 3 1 1 1 1

    应用场景:

    并查集在很多场景都可以使用,比如地图寻址,im的群查找合并,数据统计等

    原文:https://gper.club/articles/7e7e7f7ff4g59gc7g69

    展开全文
  • 慕课西安交通大学.WEB编程技术.第七章.ASP.NET.数据绑定概念及语法0 目录7 ASP.NET7.10 数据绑定概念及语法7.10.1 课堂重点7.10.2 ...以下不属于数据绑定层次结构的是( )。 A.数据绑定控件 B.数据源控件 C.ADO....

    慕课西安交通大学.WEB编程技术.第七章.ASP.NET.数据绑定概念及语法

    0 目录

    7 ASP.NET

    7.10 数据绑定概念及语法

    7.10.1 课堂重点

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    7.10.2 测试与作业

    以下不属于数据绑定层次结构的是( )。
    A.数据绑定控件
    B.数据源控件
    C.ADO.NET
    D.数据表
    正确答案:D

    8 下一章

    博客地址:

    展开全文
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    17.以下属于逻辑结构的是(C )。【西安电子科技大学应用 2001一、1】 A.顺序表 B. 哈希表 C.有序表 D. 单链表 二、判断题 1. 数据元素是数据的最小单位。( ) 【北京邮电大学 1998 一、1(2分)】【青岛大学 ...
  • 部件透明性

    千次阅读 2015-12-04 23:56:12
    所谓透明实际上指那些不属于自己管部分,在计算机系统中,下层机器级的概念结构功能特性,对上层机器语言程序员是透明。汇编程序员在编程时,不需要考虑指令缓冲器,移位器乘法器和先行进位链等部件。指令...

    对于汇编语言程序员来说,以下部件不透明的是:

    1、指令缓冲器

    2、移位器

    3、通用寄存器

    4、中断字寄存器

    5、乘法器

    6、先行进位链


    所谓透明实际上指那些不属于自己管的部分,在计算机系统中,下层机器级的概念性结构功能特性,对上层机器语言的程序员是透明的。汇编程序员在编程的时,不需要考虑指令缓冲器,移位器乘法器和先行进位链等部件。指令缓冲器,移位器乘法器和先行进位链属于运算器的设计。

    常见的有透明性的计算机器件有:移位器,指令缓冲器,时标发生器,条件寄存器,乘法器、主存地址寄存器等。




    展开全文
  • 《数据结构》第六章 图 教学设计

    千次阅读 2014-11-30 17:38:00
    本章节主要是概念多,图结构复杂。本设计也属于迟到了。抱歉。 本章学习总时问分为2周,共四次课来来学习。两次上课(13周和14周),一次实验(14周,实验给课内时间,请大家自己找时间完成,我只检查大家实验...
  • 在学习了列表和元组之后,我们再来学习一种容器型数据类型,它名字叫集合(set)。说到集合这个词大家一定不会陌生,在数学... 确定性:给定一个集合,任给一个元素,该元素或者属于或者不属于该集合,二者必居其一
  •  本书是一本关于oracle database 9i、10g 和11g 数据库体系结构的权威图书,涵盖了所有重要oracle 体系结构特性,包括文件、内存结构和进程,锁和闩,事务、并发和多版本,表和索引,数据类型,分区和并行,以及...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    2、要求的图如下,也可以自己构造图,但是需要注意的是,图能是退化的单链表: 实验报告要求: 1、 按要求记录下图的类的完整实验代码; 2、 纪录你所使用的图; 3、 按要求记录下要求的输出...
  • CruiseYoung提供的带有详细书签的电子书籍目录 ... Oracle 9i & 10g编程艺术:深入数据库体系结构(09年度畅销榜TOP50)(08年度畅销榜TOP50) 基本信息 ...第10章介绍了各种类型的表,其中最重要的是堆组织表...
  • 面向对象建模,把系统看作是相互协作对象,这些对象是结构和行为封装,都属于某个类,那些类具有某种层次化的结构。系统所有功能通过对象之间相互发送消息来获得。面向对象建模可以视为一个包含以下元素...
  • 什么是NoSQL数据库?

    2014-07-21 23:24:20
    面向文档数据库具有以下特征:即使定义表结构,也可以像定义了表结构一样使用。关系型数据库在变更表结构时比较费事,而且为了保持一致性还需修改程序。然而NoSQL数据库则可省去这些麻烦(通常程序都是正确)...
  • 1、 以下数据结构不属于线性数据结构的是()。 A、队列 B、线性表 C、二叉树 D、栈 我的答案:C 2、 在结构化方法中,用数据流程图(DFD)作为描述工具的软件开发阶段是()。 A、 可行性分析 B、需求分析 ...
  • (2) 以下数据结构不属于线性数据结构的是(C) A. 队列 B. 线性表 C. 二叉树 D. 栈 (3) 在一棵二叉树上第5层的结点数最多是(B) 注:由公式2k-1得 A. 8 B. 16 C. 32 D. 15 (4) 下面描述中,符合结构化程序设计风格...
  •  尽管SAN和NAS有很多共同特征,但二者还是有很大的差异的,其最大的差异是存储局域网是一个网络的概念,而附网存储实际上是指一种可以与网络直接相连的存储设备,它更多的是强调“设备”的概念。存储局域网考虑的是...
  • ASP.NET网页代码模型及生命周期

    热门讨论 2009-07-28 14:22:11
    在创建了ASP.NET应用程序后,系统同样会默认创建一个Default.aspx页面,不同的是,多出了一个Default.aspx.designer.cs,用来初始化页面控件,一般需要修改。 4.1.5 ASP.NET网站和ASP.NET应用程序的区别 在ASP.NET...
  • (2) 以下数据结构不属于线性数据结构的是______。(C) A. 队列 B. 线性表 C. 二*树 D. 栈 (3) 在一棵二*树上第5层的结点数最多是______。(B) A. 8 B. 16 C. 32 D. 15 (4) 下面描述中,符合结构化程序设计风格的是__...
  • 需求对象 答案 B 150 数据库物理设计完成后进入数据库实施阶段下列各项中不属于实施阶段工作是 D. 系统调试A. 建立库结构 B. 扩充功能 C. D. 系统调试 答案 B 150 通常用以下的顺序来完成数据库设计工作 A. 概念...
  • 适配器模式是指将一个类接口转换成用户期望另一个接口,使原本接口兼容类可以一起工作,属于结构型设计模式。 1.2 适用场景 适配器模式适用于以下场景: 已经存在方法和需求匹配; 不是软件...
  • ,所以我们可以把系统分为以下几个模块:数据处理电路、显示电路、待测信 号产生电路、待测信号整形放大电路,电源电路。 2.2 主要开发工具和平台 2.2.1 原理图和印刷电路板图设计开发工具:PROTEL DXP Protel DXP...
  • (2)线性表顺序存储结构具有以下两个基本特点: ① 线性表中所有元素所占存储空间是连续; ② 线性表中各数据元素在存储空间中是按逻辑顺序依次存放。 元素ai存储地址为:ADR(ai)=ADR(a1)+(i-1)k,ADR(a1...
  • 设计模式之装饰模式

    2019-08-14 13:40:14
    这种类型设计模式属于结构型模式(结构型模式设计,它关注类和对象组合。继承这一概念被用来组合接口和定义组合对象获得新功能方式。它包括以下几种具体设计模式:适配器模式、桥接模式、过滤器模式、组合...
  • mysql 索引(二)

    2020-07-07 11:02:10
    索引就是一种数据结构,就是发挥这种数据结构来加快查询效率 例如:InnoDB存储引擎中使用的是就是B+tree这种数据结构来组织索引。 mysql中索引的种类也不是很多,不同索引有不同的作用 mysql索引主要分为以下几类: ...
  • 以下不属于现阶段知识图谱技术类别的是(C) A.构建技术 B.推理技术 C.展示技术 D.应用技术 3单选 以下关于知识图谱的说法错误的是(B) A.知识图谱以结构化的形式,描述客观世界中存在的概念、实体和实体间的关系 ...
  • Oracle试卷及答案

    2011-06-22 10:43:12
    2、 ORACLE数据库物理结构包括以下三种文件,以下不属于的是(A) (A) 系统文件 (B)日志文件 (C)数据文件 (D)控制文件 3、 在一台物理服务器上可以安装多个服务软件,构成逻辑上的多个服务器。为区分这些...
  • 以下不属于领导力的特征的是? A. 灵活 B. 积极进取 C. 权力欲望 D. 正直 正确答案:A 6单选(2分) 创业过程包括以下哪些环节? A. 产生创业动机和书别创业机会 B. 整合有效资源和创建创业企业 C. ...
  • 简单工厂模式(学习笔记)

    千次阅读 2021-01-09 18:01:06
    1. 概念 设计模式主要分为三大类型:(1) 创建型模式;(2)结构型模式;(3)行为型模式。其中,简单工厂模式属于创建型模式。...接口调用方,需要知道接口具体实现细节,只需要调用简单工厂类就可以创建一个接
  • 下列属于面向对象开发方法的是(A B C D)。 A) Booch B) UML C) Coad D) OMT 6. 软件危机的主要表现是(B D)。 A) 软件成本太高 B) 软件产品的质量低劣 C) 软件开发人员明显不足 D) 软件生产率低下 7...

空空如也

空空如也

1 2 3 4
收藏数 78
精华内容 31
关键字:

以下不属于结构概念的是