精华内容
下载资源
问答
  • 在数据库开发方面,通过单表所表现实现,有时候需要组合查询来找到我们需要记录集,这时候我们...它是通过(INNER JOIN或者JOIN)关键字把多表进行连接。我们通过建立两个表来说明问题: StudentID StudentNa...
    在数据库开发方面,通过单表所表现的实现,有时候需要组合查询来找到我们需要的记录集,这时候我们就会用到连接查询。 
    
      连接查询主要包括以下几个方面:
      内连接
      内连接一般是我们最常使用的,也叫自然连接,是用比较运算符比较要联接列的值的联接。它是通过(INNER JOIN或者JOIN)关键字把多表进行连接。我们通过建立两个表来说明问题:

    StudentID StudentName StudentAge
    ----------- -------------------------------------------------- -----------
    1 张三 25
    2 李四 26
    3 王五 27
    4 赵六 28
    5 无名氏 27
      以上是表Student,存放学生基本信息。

    BorrowBookID BorrowBookName StudentID BorrowBookPublish
    ----------------------------------------------------------------------------------------------------------------------
    1 主义政治经济学 1 电子工业出版社
    2 思想概论 2 高等教育出版社
    3 理论 3 人民邮电出版社
    4 大学生思想道德修养 4 中国铁道出版社
    5 C语言程序设计 NULL 高等教育出版社
      以上是表BorrowBook,存放学生所借的书。

     以上两张表是通过StudentID进行关联,在这里先执行内联连语句:

    Select Student.StudentName,Student.StudentAge,BorrowBook.BorrowBookName,BorrowBook.BorrowBookPublish
    From Student
    Inner Join BorrowBook
    On Student.StudentID = BorrowBook.StudentID
      上面这个语句也可以写成

    Select Student.StudentName,Student.StudentAge,BorrowBook.BorrowBookName,BorrowBook.BorrowBookPublish
    FROM Student,BorrowBook
    WHERE Student.StudentID = BorrowBook.StudentID
      其中,Inner Join是SQL Server的缺省连接,可简写为Join。在Join后面指定具体的表作连接。On后面指定了连接的条件。
      运行的结果如下:

    tudentName StudentAge BorrowBookName BorrowBookPublish
    --------------------------------------------------------------------------------
    张三 25 主义政治经济学 电子工业出版社
    李四 26 思想概论 高等教育出版社
    王五 27 理论 人民邮电出版社
    赵六 28 大学生思想道德修养 中国铁道出版社
      (所影响的行数为 4 行)
      根据查询的结果来进行分析:
      如果多个表要做连接,那么这些表之间必然存在着主键和外键的关系。所以需要将这些键的关系列出,就可以得出表连接的结果。在上例中,StudentID是Student表的主键,StudentID又是BorrowBook表的外键,这两个表的连接条件就是Student.StudentID = BorrowBook.StudentID,对比查询结果可以得知,内连接查询只查询出主键StudentID在另张表中存在的记录,像Student表中的第五条记录,因为在BorrowBook表中StudentID不存在,像BorrowBook表中的第五条记录StudentID为Null,对应的Student表中没有记录,所以就不会显示。所以内连接就是将参与的数据表中的每列与其它数据表的列相匹配,形成临时数据表,并将满足数据项相等的记录从临时数据表中选择出来。

      内连接查询操作列出与连接条件匹配的数据行,它使用比较运算符比较被连接列的列值。内连接分三种:
      1) 等值连接:在连接条件中使用等于号(=)运算符比较被连接列的列值,其查询结果中列出被连接表中的所有列,包括其中的重复列。
      2) 不等连接: 在连接条件使用除等于运算符以外的其它比较运算符比较被连接的列的列值。这些运算符包括> 、> =、 <=、 <、!> 、! <和 <> 。
      3) 自然连接:在连接条件中使用等于(=)运算符比较被连接列的列值,但它使用选择列表指出查询结果集合中所包括的列,并删除连接表中的重复列。
      例如对于用不等值连接语句:

    Select Student.StudentName,Student.StudentAge,BorrowBook.BorrowBookName,BorrowBook.BorrowBookPublish
    From Student
    Inner Join BorrowBook
    On Student.StudentID <> BorrowBook.StudentID

    StudentName StudentAge BorrowBookName BorrowBookPublish
    ----------------------------------------------------------------------------------
    李四 26 主义政治经济学 电子工业出版社
    王五 27 主义政治经济学 电子工业出版社
    赵六 28 主义政治经济学 电子工业出版社
    无名氏 27 主义政治经济学 电子工业出版社
    张三 25 思想概论 高等教育出版社
    王五 27 思想概论 高等教育出版社
    赵六 28 思想概论 高等教育出版社
    无名氏 27 思想概论 高等教育出版社
    张三 25 理论 人民邮电出版社
    李四 26 理论 人民邮电出版社
    赵六 28 理论 人民邮电出版社
    无名氏 27 理论 人民邮电出版社
    张三 25 大学生思想道德修养 中国铁道出版社
    李四 26 大学生思想道德修养 中国铁道出版社
    王五 27 大学生思想道德修养 中国铁道出版社
    无名氏 27 大学生思想道德修养 中国铁道出版社
      它就会把两表所对应不相等的记录给查询出来了。

     外连接

      外连接主要包括左连接、右连接和完整外部连接。
      1)左连接:Left Join 或 Left Outer Join
      左连接的结果集包括LEFT OUTER子句中指定的左表的所有行,而不仅仅是联接列所匹配的行。如果左表的某行在右表中没有匹配行,则在相关联的结果集行中右表的所有选择列表列均为空值(Null)。
      我们看对应的SQL语句:

    Select Student.StudentName,Student.StudentAge,BorrowBook.BorrowBookName,BorrowBook.BorrowBookPublish
    From Student
    LeftJOIN BorrowBook
    On Student.StudentID = BorrowBook.StudentID
      运行的结果如下:

    StudentName StudentAge BorrowBookName BorrowBookPublish
    ---------------------------------------------------------------------------------
    张三 25 主义政治经济学 电子工业出版社
    李四 26 思想概论 高等教育出版社
    王五 27 理论 人民邮电出版社
    赵六 28 大学生思想道德修养 中国铁道出版社
    无名氏 27 NULL NULL
      (所影响的行数为 5 行)
      可以看到的是,它查询的结果是以左表Student为主,Student对应的StudentID在右表BorrowBook如果不存在的话,就会用NULL值来代替。

      2) 右连接:Right Join 或 Right Outer Join
      右连接和左连接相反,它将返回右表的所有行。如果右表的某行在左表中没有匹配行,则将为左表返回空值(Null)。
      我们看对应的SQL语句

    Select Student.StudentName,Student.StudentAge,BorrowBook.BorrowBookName,BorrowBook.BorrowBookPublish
    From Student
    RightJOIN BorrowBook
    On Student.StudentID = BorrowBook.StudentID
      运行的结果如下:

    StudentName StudentAge BorrowBookName BorrowBookPublish
    ----------------------------------------------------------------------------------------------------------------------
    张三 25 主义政治经济学 电子工业出版社
    李四 26 思想概论 高等教育出版社
    王五 27 理论 人民邮电出版社
    赵六 28 大学生思想道德修养 中国铁道出版社
    NULL NULL C语言程序设计 高等教育出版社
      (所影响的行数为 5 行)
      可以看到的是,它查询的结果是以右表BorrowBook为主,BorrowBook对应的StudentID在左表Student如果不存在的话,就会用NULL值来代替。

      3) 完整外部联接:Full Join 或 Full Outer Join
      完整外部联接返回左表和右表中的所有行。当某行在另一个表中没有匹配行时,则另一个表的选择列表列包含空值。如果表之间有匹配行,则整个结果集行包含基表的数据值。
      我们看对应的SQL语句

    Select Student.StudentName,Student.StudentAge,BorrowBook.BorrowBookName,BorrowBook.BorrowBookPublish
    From Student
    FULL OUTER JOIN BorrowBook
    On Student.StudentID = BorrowBook.StudentID
      运行的结果如下:

    StudentName StudentAge BorrowBookName BorrowBookPublish ----------------------------------------------------------------------------------------------------------------------
    NULL NULL C语言程序设计 高等教育出版社
    张三 25 主义政治经济学 电子工业出版社
    李四 26 思想概论 高等教育出版社
    王五 27 理论 人民邮电出版社
    赵六 28 大学生思想道德修养 中国铁道出版社
    无名氏 27 NULL NULL
      (所影响的行数为 6 行)
      可以看到的是,它查询的结果除了把相对应完全匹配的记录查出来以后,还会把左连接及右连接两种情形都包括,对应的值用NULL值来代替。

     交叉连接

      交叉连接(CROSS JOIN),就是指不带W H E R E子句的查询。在数学上,就是表的笛卡尔积。也就是它查询出来的记录数行为两个表的乘积,对应记录也就是为表A*表B。
      我们看对应的SQL语句

    Select Student.StudentName,Student.StudentAge,BorrowBook.BorrowBookName,BorrowBook.BorrowBookPublish
    From Student Cross Join BorrowBook
      运行的结果如下:

    StudentName StudentAge BorrowBookName BorrowBookPublish
    ---------------------------------------------------------------------------------
    张三 25 主义政治经济学 电子工业出版社
    李四 26 主义政治经济学 电子工业出版社
    王五 27 主义政治经济学 电子工业出版社
    赵六 28 主义政治经济学 电子工业出版社
    无名氏 27 主义政治经济学 电子工业出版社
    张三 25 思想概论 高等教育出版社
    李四 26 思想概论 高等教育出版社
    王五 27 思想概论 高等教育出版社
    赵六 28 思想概论 高等教育出版社
    无名氏 27 思想概论 高等教育出版社
    张三 25 理论 人民邮电出版社
    李四 26 理论 人民邮电出版社
    王五 27 理论 人民邮电出版社
    赵六 28 理论 人民邮电出版社
    无名氏 27 理论 人民邮电出版社
    张三 25 大学生思想道德修养 中国铁道出版社
    李四 26 大学生思想道德修养 中国铁道出版社
    王五 27 大学生思想道德修养 中国铁道出版社
    赵六 28 大学生思想道德修养 中国铁道出版社
    无名氏 27 大学生思想道德修养 中国铁道出版社
    张三 25 C语言程序设计 高等教育出版社
    李四 26 C语言程序设计 高等教育出版社
    王五 27 C语言程序设计 高等教育出版社
    赵六 28 C语言程序设计 高等教育出版社
    无名氏 27 C语言程序设计 高等教育出版社
      (所影响的行数为 25 行)
      可以看到的是,它把表Student中的每一行和BorrowBook中的每一条记录都进行关联,返回的记录数为5*5=25行,即笛卡尔积,它执行的语句也就等效于

    Select Student.StudentName,Student.StudentAge,BorrowBook.BorrowBookName,BorrowBook.BorrowBookPublish
    From Student,BorrowBook
    展开全文
  • 连接基本结构

    2020-11-18 19:28:57
    连接基本结构件包括:1、接触件;2、绝缘体;3、外壳体;4、附件。 ... 1.接触件(contacts)是连接器完成电连接功能核心零件。一般由阳性接触件和阴性接触...插孔结构种类,有圆筒型(劈槽、缩口)
  • 线性表之链表

    2018-02-26 16:30:46
    我们学习数据结构时,除了顺序,接触更多的另一种线性表就是“链表”。链表是一种物理存储单元上非连续、非顺序链式存储结构,数据元素逻辑顺序是通过链表中指针的连接次序实现。链表由一系列结点(链表中...
           我们学习数据结构时,除了顺序表,接触更多的另一种线性表就是“链表”。链表是一种物理存储单元上非连续、非顺序的链式存储结构,数据元素的逻辑顺序是通过链表中的指针的连接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储其他结点地址的指针域。相比线性表的顺序结构,操作更复杂。
           链表的种类由节点类型大体可以分为单链表、循环链表、双向链表、双向循环链表,根据有无头结点又可以分成带头节点链表、不带头结点链表。还有一种“静态链表”。。
    链表的基本操作有初始化、插入、删除、查找、求长、判空、判满、清除、销毁、逆置。。。
    我们主要学习其中常用的带头结点的链表、静态链表和不带头结点的单链表。。其实这些链表的操作实现大同小异,均是在单链表实现的基础上加以变换。所以我们先实现单链表,然后对比说明其他链表~
     C++ Code list.h
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    //带头节点的单链表
    typedef struct Node
    {
        
    int data;
        
    struct Node*next;
    }Node,*List;
    //List == Node*

    //初始化
    void InitList(List plist);
    //头插,违背生活规律,尽量少用
    bool Insert_head(List plist,int val);
    //尾插
    bool Insert_tail(List plist,int val);
    //查找
    Node* Search(List plist,int key);
    //删除
    bool Delete(List plist,int key);
    //求长
    int GetLength(List plist);
    //判空
    bool IsEmpty(List plist);
    //清空数据
    void Clear(List plist);
    //销毁单链表
    void Destroy(List plist);
    //打印链表
    void Show(List plist);
    //链表逆置
    void Reverse(List plist);
    C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    #include 
    #include 
    #include 
    #include "list.h"

    //初始化
    void InitList(List plist)
    {
        assert(plist != 
    NULL);
        
    if(plist==NULL)
        {
            
    return ;
        }

        plist->next = 
    NULL;
    }
    //头插
    bool Insert_head(List plist,int val)
    {
        Node *p = (Node *)malloc(
    sizeof(Node));
        p->data = val;
        p->next = plist->next;
        plist->next = p;
        
        
    return true;
    }
    //尾插
    bool Insert_tail(List plist,int val)
    {
        Node *q;
        
    for(q=plist;q->next!=NULL;q=q->next);
        
    //尾节点q标记为q->next==NULL
        Node *p = (Node *)malloc(sizeof(Node));
        p->data = val;
        
    //将p插在q的后面
        p->next = q->next;//p->next = NULL;
        q->next = p;

        
    return true;
    }
    //查找
    Node* Search(List plist,int key)
    {
        
    for(Node *p=plist->next;p!=NULL;p=p->next)
        {
            
    if(p->data == key)
            {
                
    return p;
            }
        }

        
    return NULL;
    }
    //查找前驱
    static Node *SearchPri(List plist,int key)
    {
        
    for(Node *p=plist;p->next!=NULL;p=p->next)
        {
            
    if(p->next->data == key)
            {
                
    return p;
            }
        }
        
    return NULL;
    }
    //删除
    bool Delete(List plist,int key)
    {
        Node *p = SearchPri(plist,key);
        
    if(p == NULL)
        {
            
    return false;
        }

        Node *q = p->next;
        p->next = q->next;
        free(q);

      
        
    return true;
    }
    //求长
    int GetLength(List plist)
    {
        
    int count = 0;
        
    for(Node *p=plist->next;p!=NULL;p=p->next)
        {
            count++;
        }

        
    return count;
    }
    //判空
    bool IsEmpty(List plist)
    {
        
    return plist->next == NULL;
    }
    //清空数据
    void Clear(List plist)
    {
        Destroy(plist);
    }
    //销毁单链表
    void Destroy(List plist)
    {
        Node *p;
        
    while(plist->next != NULL)//类似排队买饭,每次free第一个节点元素。
        {
            p = plist->next;
            plist->next = p->next;
            free(p);
        }
    }
    //打印
    void Show(List plist)
    {
        
    for(Node *p=plist->next;p!=NULL;p=p->next)
        {
            printf(
    "%d ",p->data);
        }
        printf(
    "\n");
    }
    //逆置
    void Reverse(List plist)
    {
        
    if(plist==NULL || plist->next==NULL || 
           plist->next->next==
    NULL)
        {
            
    return ;
        }

        Node *p = plist->next;
        Node *q;
        plist->next = 
    NULL;

        
    while(p != NULL)
        {
            q = p->next;
            p->next = plist->next;
            plist->next = p;
            p = q;
        }
    }



    循环链表是另一种形式的链式存贮结构。它的特点是将单链表中最后一个结点的指针域指向头结点,整个链表形成一个环。不同于单链表,主要在其在判空操作时条件为头指针(指向头结点的指针)的next(指针域)等于头指针,即cplist->next == cplist。遍历节点结束的条件为节点的指针不等于头指针,即for(p=cplist->next; p != cplist; p=p->next)
    双向链表指在单链表的基础上,增加每个节点的一个指向前驱节点的指针域,但头结点无前驱。不同于单链表的操作,在删除任意节点时更方便,不需要查找前驱节点进行删除,而是借助被删除节点的prio节点进行删除,时间复杂度为o(1).
    双向循环链表是一个尾指针指向头结点的双向链表,也形成一个环。
    不带头结点单链表实现如下:

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    #pragma once
    //不带头结点的单链表

    typedef struct Node
    {
        
    int data;
        
    struct Node *next;
    }Node,*NList;

    //初始化

    void InitList(NList *pplist);

    //头插,违背生活规律,尽量少用
    bool Insert_head(NList *pplist,int val);

    //尾插
    bool Insert_tail(NList *pplist,int val);

    //查找
    Node* Search(NList plist,int key);

    bool Delete(NList *pplist,int key);

    int GetLength(NList plist);

    bool IsEmpty(NList *plist);

    //清空数据
    void Clear(NList *pplist);

    //销毁顺序表
    void Destroy(NList *pplist);

    void Show(NList plist);

     
    void Reverse(NList *pplist);

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    #include 
    #include 
    #include 
    #include "nlist.h"
    //初始化
    void InitList(NList *pplist)
    {
        assert(pplist != 
    NULL);
        *pplist = 
    NULL;
    }
    //头插,违背生活规律,尽量少用
    bool Insert_head(NList *pplist,int val)//pplist是存储首元节点地址的地址(传指针,解引用,改变首元节点的地址。。)
    {
        Node *p = (Node *)malloc(
    sizeof(Node));
        p->data = val;

        p->next = (*pplist);
    //*pplist代表首元节点的地址
        *pplist = p;

        
    return true;
    }
    //尾插
    bool Insert_tail(NList *pplist,int val)
    {
        Node *p;
        
    for(p = *pplist; p != NULL; p = p->next);

        Node *q = (Node *)malloc(
    sizeof(Node));
        q->data = val;
        q->next = p;
        p = q;

        
    return true;
    }
    //查找
    Node* Search(NList plist,int key)
    {
        Node *p = plist;
        
    for(; p != NULL; p = p->next)
        {
            
    if(p->data == key)
            {
                
    return p;
            }
        }
        
    return NULL;
    }
    //删除
    bool Delete(NList *pplist,int key)
    {
        Node *p = Search(*pplist, key);
        
    if(p != NULL)
        {
            Node *q = p->next;
            
    int tmp = p->data;
            p->data = q->data;
            q->data = tmp;  

            p->next = q->next;
            free(q);
            
    return true;
        }
        
    return false;
    }
    //求长
    int GetLength(NList plist)
    {
        
    int count = 0;
        
    for(Node *p = plist; p != NULL; p = p->next)
        {
            ++count;
        }
        
    return count;
    }
    //判空
    bool IsEmpty(NList plist)
    {
        
    return plist == NULL;
    }
    //清空数据
    void Clear(NList *pplist)
    {
        Destroy(pplist);
    }
    //销毁顺序表
    void Destroy(NList *pplist)
    {
        
    while(*pplist != NULL)
        {
            Node *p = *pplist;
            *pplist = p->next;
            free(p);
        }
    }
    //打印
    void Show(NList plist)
    {
        Node *p = plist;
        
    for(; p != NULL; p = p->next)
        {
            printf(
    "%d  ", p->data);    
        }
        printf(
    "\n");
    }
    //逆置
    void Reverse(NList *pplist)
    {
        
    if(pplist==NULL || *pplist==NULL || (*pplist)->next==NULL)
        {
            
    return ;
        }
        Node *p = *pplist;
        *pplist = 
    NULL;

        
    while(p != NULL)
        {
            Node *q = p->next;
            p->next = *pplist;
            *pplist = p;
            p = q;
        }
    }
    上面介绍的各种链表都是使用指针类型实现的,链表中的节点空间的分配和回收(释放)均由系统提供的标准函数malloc和free动态实现,故称之为动态链表。
    静态链表:由于一些编程语言中没有指针类型,所以我们采用了顺序表的数组模拟实现带头结点的循环链表。用下一节点的下标代表“指针”,自己编写从数组中“分配节点”和“回收节点”的过程。从0下标作为有效链的表头,1下标作为空闲链的表头。
     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    //静态链表
    //利用顺序表模拟带头节点的循环链表
    //0下标作为有效链的表头,1下标作为空闲链的表头

    #define SIZE 10 

    typedef struct SNode
    {
        
    int data;//数据
        int next; //指针,下一个节点的下标
    }SNode,*PSList,SList[SIZE];//SList是SNode数组数据类型

    void InitSList(PSList ps);

    //头插
    bool Insert_head(PSList ps,int val); 

    bool Delete(PSList ps,int key);

    bool IsEmpty(PSList ps);

    int Search(PSList ps,int key);

    void Show(PSList ps);

    void Clear(PSList ps);
    C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    #include 
    #include 
    #include "slist.h"

    void InitSList(PSList ps)
    {
        assert(ps != 
    NULL);

        
    for(int i=0;i
        {
            ps[i].next = i+
    1;
        }

        ps[
    0].next = 0;
        ps[SIZE-
    1].next = 1;
    }

    static bool IsFull(PSList ps)
    {
        
    return ps[1].next == 1;
    }
    //头插
    bool Insert_head(PSList ps,int val)
    {
        
    if(IsFull(ps))
        {
            
    return false;
        }

        
    int p = ps[1].next;//找到一个空闲节点

        ps[
    1].next = ps[p].next;//将p从空闲链删除

        ps[p].data = val;
    //将数据放到p节点中 

        ps[p].next = ps[
    0].next; //将p头插进有效链
        ps[0].next = p;

        
    return true;
    }
    bool IsEmpty(PSList ps)
    {
        
    return ps[0].next == 0;
    }
    static int SearhcPri(PSList ps,int key)
    {
        
    for(int p=0;ps[p].next!=0;p=ps[p].next)
        {
            
    //if(p->next->data == key)
            if(ps[ps[p].next].data == key)
            {
                
    return p;
            }
        }
        
    return -1;
    }
    int Search(PSList ps,int key)
    {
        
    for(int p=ps[0].next;p!=0;p=ps[p].next)
        {
            
    if(ps[p].data == key)
            {
                
    return p;
            }
        }
        
    return -1;
    }
    bool Delete(PSList ps,int key)//todo
    {
        
    int p = Search(ps, key);
        
    int q;
        
    for(int q = p; q != 0; q = ps[q].next)
        {
            ps[q] = ps[q+
    1];
        }
        ps[q].next = 
    0;
    }
    void Show(PSList ps)
    {
        
    for(int p=ps[0].next;p!=0;p=ps[p].next)
        {
            printf(
    "%d ",ps[p].data);
        }
        printf(
    "\n");
    }

    void Clear(PSList ps)
    {
        ps[
    0].next = 0;
    }
    展开全文
  • 1给出了可穿戴设备的种类和典型用例。  1:可穿戴设备的分类(* 身体:包括手臂、躯干和腿 )  大部分可穿戴设备都配有一个或个传感器、处理器、存储器、连接器(无线电控制器)、显示器和电池。图2给出...
  • 1给出了可穿戴设备的种类和典型用例。  1:可穿戴设备的分类(* 身体:包括手臂、躯干和腿 )  大部分可穿戴设备都配有一个或个传感器、处理器、存储器、连接器(无线电控制器)、显示器和电池。图2给出...
  • 鉴于市场上用户手机型号、种类、屏幕分辨率等参差不齐,传统方式根据主流系统分别开发相应系统耗时又耗力,为了高效开发并节约开发项目成本,本文采用Android+HTML5相结合方式进行移动端Web系统设计研发工作...
  • 诸多网站开展网上会展业务,群雄并起,竞争激烈,出现行业、种类的专业化趋势,加速并推动电子商务发展。 第三阶段:网上会展与传统展览并存竞争阶段。网上会展逐渐被人们所接受,形成既相互融合,又相互竞争竟...
  • ML - 深度前馈网络

    2020-10-19 18:27:59
    如果把个感知器连接起来,就可以表达种类繁多非线性曲面。 神经网络 神经网络基于感知器模型做了三点扩展: (1)加入隐藏层,隐藏层可以有多层,增强模型表达能力 (2)个输出层神经元,灵活应用于分类回归...

    参考

    华为云学院

    概述

    单个感知器的表达能力有限,它只能表达线性决策面(超平面)。如果把多个感知器连接起来,就可以表达种类繁多的非线性曲面。

    神经网络

    神经网络基于感知器模型做了三点扩展:
    (1)加入隐藏层,隐藏层可以有多层,增强模型的表达能力
    (2)多个输出层神经元,灵活应用于分类回归,分类,语义分割等。
    (3)扩展激活函数,包括Sigmoid函数,Softmax和ReLU等。

    什么是深度学习

    隐藏层比较多(大于2)的神经网络叫做深度神经网络(DNN)。也叫作前馈神经网络(FeedForward Neural Network)或者多层感知器(Multilayer Perception,MLP),是典型的深度学习模型。

    深度前馈网络推导

    在这里插入图片描述
    对于第二层的三个神经元的输出
    在这里插入图片描述
    转换成矩阵表达式
    在这里插入图片描述
    进一步推广可得
    在这里插入图片描述

    展开全文
  • 本文从系统开发、运行环境选择、系统可行性分析、系统功能需求分析、功能模块划分、数据库及数据表的设计与开发到系统功能模块具体开发实现都进行了详细分析和介绍。本系统采用ASP.NET 2.0作为构建平台...
  • 说明:21是某个连接的sid数 然后用 kill 命令杀此进程号。 五、SQL*PLUS使用 a、近入SQL*Plus $sqlplus 用户名/密码 退出SQL*Plus SQL>exit b、在sqlplus下得到帮助信息 列出全部SQL命令和SQL*Plus命令 SQL>...
  • MATLAB可以进行矩阵运算、绘制函数和数据、实现算法、创建用户界面、连接其他编程语言程序等,主要应用于工程计算、控制设计、信号处理与通讯、图像处理、信号检测、金融建模设计与分析等领域。 当前面向矩阵运算...
  • 5.2 多表连接查询 实例123 使用UNION运算符使学生档案归档 实例124 内连接查询指定课程教师信息 实例125 左外连接查询员工信息 实例126 右外连接查询员工信息 实例127 多表外连接查询 实例128 完全连接查询 5.3 ...
  • 数字电路制造工业进步,使得系统设计人员能在更小空间内实现更多的功 能,从而提高系统可靠性和速度。 集成电路类型很,从大方面可以分为模拟电路和数字集成电路2 大 类。数字集成电路广泛用于计算机、...
  •  9.6 在多表连接中除去连接记录(侯选行)  9.7 在大小不同表间进行双表连接  9.8 三表连接(基于成本)  9.9 位图连接索引  9.10 第三方性能调整工具  9.11 调整分布式查询  9.12 一切就绪  9.13 各种调整...
  • Java编程那些事儿23—逻辑运算符

    千次阅读 2008-12-27 20:13:00
    逻辑运算主要包括与(and)、或(or)和非(not)三种,在程序中主要用来连接多个条件,从而形成更加复杂的条件。 逻辑运算符的运算结果是boolean类型。 参与逻辑运算的数据也必须是boolean类型。 关于逻辑运算符的种类...
    4.3 逻辑运算符
             逻辑运算符是指进行逻辑运算的符号。逻辑运算主要包括与(and)、或(or)和非(not)三种,在程序中主要用来连接多个条件,从而形成更加复杂的条件。
             逻辑运算符的运算结果是boolean类型。
             参与逻辑运算的数据也必须是boolean类型。
             关于逻辑运算符的种类和说明参看表4-3。
    表4-3 逻辑运算符
    符号
    名称
    功能说明
    &&
    逻辑与
    两个条件同时为true才为true,否则为false
    ||
    逻辑或
    两个条件有一个为true则为true,否则为false
    !
    逻辑非
    只操作一个数据,对数据取反
             逻辑运算符使用示例代码:
                       boolean b1 = true;
                       boolean b2 = false;
                       boolean b3 = b1 && b2; //则b3的值是false
                       b3 = b1 || b2;        //则b3的值是true
                       b3 = !b1;           //则b3的值是false
             在实际程序中,可以根据逻辑的需要使用对应的逻辑运算符号。实际使用示例:
    表示变量n是否属于[0,10)区间
    int n = 4;
                                boolean b = (n >=0) && (n < 10);
    对于变量n来说,只要n同时满足大于等于零,且小于10,则位于[0,10)区间,由于程序中无法书写0<=n<10这样的条件,则必须通过逻辑运算符进行连接。
    表示变量n不属于[0,10)区间
    一种写法是:
             int n = 4;
             boolean b = !((n >= 0) && (n < 10));
    这里,对于属于该区间的条件取反,则可以获得不属于该区间的条件。
    另一种写法是:
             int n = 4;
             boolean b = (n < 0) || (n >= 10);
    这里做了一个简单的变通,如果变量n不属于该区间,则在数学上只需要满足n小于0或者n大于等于10的任何一个条件即可,这样的或者关系在程序中实现时使用逻辑或实现。
             在程序设计中,根据逻辑需要,使用对应的逻辑运算符,可以实现相对比较复杂的组合条件,从而实现对应程序的功能。
             最后说一下&&和&的区别,其实在进行逻辑与运算时,既可以使 用&&也可以使用&,在功能上本身没有区别。两者区别的位置在,对于&来说,如果左侧条件为false,也会计算右侧条 件的值,而对于&&来说,如果左侧的条件为false,则不计算右侧的条件,这种现象被称作短路现象。
             示例代码:
                       int n = -1;
                       boolean b1 = (n >= 0) && (n < 10);
                       boolean b2 = (n >= 0) & (n < 10);
             则对于第二行代码来说,两个条件都将被计算,而对于第三行代码来说,因为n >= 0这个条件不成立,则n < 10根本不会被执行。当然,两者得到的最终结果是一样的。
             对于现在的代码来说,区别不大,但是如果后续的条件是一个方法(方法的概念后续将介绍到),则将影响程序逻辑。
             验证&和&&功能的示例代码如下:
                       public class Test{
                                public static void main(String[] args){
                                          int n = 10;
                                          boolean b = (n < 8) && ((n = 1) != 0);
                                          int m = 20;
                                          boolean b1 = (m < 8) & ((m = 1) != 0);
     
                                          System.out.println(n);
                                          System.out.println(m);
                                }
    }
                                                                       
                                                                                                 最后编辑:2008-5-26 修正&和&&的错误
    展开全文
  • 算法基本运算和操作包括:算术运算、逻辑运算、关系运算、数据传输。 (3)算法3种基本控制结构 算法3种基本控制结构是:顺序结构、选择结构、循环结构。 (4)算法基本设计方法 算法基本设计方法:列举法、...
  • 5.6.3 配置服务器连接尝试最大次数 211 5.6.4 控制数据库版本信息显示 211 5.6.5 设置未授权访问标题和审计 212 第6章 备份和恢复 213 6.1 增强块介质恢复 213 6.1.1 使用recover...block命令先决条件...
  • oracle数据库经典题目

    2011-02-17 15:05:20
    5. 说明数据库空间的种类,以及不同类型空间的作用。 答案: 数据库空间分为系统空间和非系统空间两类,其中非系统空间包括撤销空间、临时空间和用户空间等。 SYSTEM空间主要用于存储数据库的...
  • 软件工程知识点

    2012-12-02 21:34:25
    在确定项目可以进行以后,接着需要针对项目开展,从人员、组织、进度、资金、设备等个方面进行合理规划,并以“项目开发计划书”形式提交书面报告。 4.软件需求分析 软件需求分析是软件规格描述具体化与...
  • 本书以开发人员在项目开发中经常遇到问题和必须掌握技术为中心,介绍了应用Java进行桌面程序开发各个方面知识和技巧,主要包括Java语法与面向对象技术、Java高级应用、窗体与控件应用、文件操作典型应用和...
  • 本书以开发人员在项目开发中经常遇到问题和必须掌握技术为中心,介绍了应用Java进行桌面程序开发各个方面知识和技巧,主要包括Java语法与面向对象技术、Java高级应用、窗体与控件应用、文件操作典型应用和...
  • 5.3 问题的种类 117 5.4 关于问题的问题 119 5.5 关于数据的问题 121 5.6 建立逻辑表达式 126 5.7 小结 136 第6章 SQL执行计划 137 6.1 解释计划 137 6.1.1 使用解释计划 137 6.1.2 理解解释计划可能达不到...
  • 5.3 问题的种类 117 5.4 关于问题的问题 119 5.5 关于数据的问题 121 5.6 建立逻辑表达式 126 5.7 小结 136 第6章 SQL执行计划 137 6.1 解释计划 137 6.1.1 使用解释计划 137 6.1.2 理解解释计划可能达不到...
  • 入门学习Linux常用必会60个命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    这是因为Linux和许多版本Unix一样,提供了虚拟控制台访问方式,允许用户在同一时间从控制台(系统控制台是与系统直接相连监视器和键盘)进行次登录。每个虚拟控制台可以看作是一个独立工作站,工作台...
  • 千里马酒店前台管理系统V7使用手册

    热门讨论 2011-06-16 14:09:38
    千里马V7.2主界面是MDI文档窗口方式,可同时打开个工作视图、客单、帐户,支持并发操作,用户不必关闭或退一个功能才可进入另一功能。按酒店前台业务部门分组,千里马V7.2功能划分为可自定义一个个动态...
  • 除6楼外在1-12楼分别设一楼层配线间,楼分别放置主设备间光纤采用光纤19寸机柜式配线架安装方式,并应配备台12口光纤配线架,以适应机房集中管理,以及未来扩容需要,光纤连接器采用高性能,小体积LC光纤器,...
  • Visual C++ 2008入门经典--详细书签版

    热门讨论 2013-02-02 16:07:15
    Horton拥有丰富教学经验(教学内容包括C、C++、Fortran、PL/1、APL等),同时还是机械、加工和电子CAD系统、机械CAM系统和DNC/CNC系统方面专家。IvorHorton还著有关于C、C++和Java的多部入门级好书,如《C语言入门...
  •  因为处理器的种类和型号不同,合理温度也各不相同。但是总的来说,温度应该低于110度。如果你发现处理器的测试高于这处温度,检查一下机箱内的风扇是否正常运转。  3、USB和扫描仪造成的影响  由于Windows启动...
  • iPhone开发秘籍(第2版)--源代码

    热门讨论 2012-12-11 13:51:22
     《iphone开发秘籍(第2版)》提供了关于iphone sdk以及iphone开发全面信息,对iphone sdk中各种组件做了深入浅出介绍,包括iphone 3.0 sdk所有新增特性,同时对iphone开发基本流程、基本原理和基本原则...

空空如也

空空如也

1 2 3 4 5
收藏数 85
精华内容 34
关键字:

多表连接的种类包括