数据库笔记1

元始天尊

这2天开始攻数据库，现在看的是东南大学数据库视频，核心原理摘抄如下：

数据库产生原因：
    涉及的数据量大
    数据不随程序结束而消失
    数据为多个应用程序所共享

数据库发展阶段：
    人工管理
    文件系统管理

文件管理系统缺点：
    编写应用程序不方便：必须对文件的逻辑及物理结构了解，使用文件打开关闭读写等功能而不能直接向文件查询
    文件的设计难于满足多种应用程序的要求，数据冗余度大
    文件结构的修改导致应用程序的修改：文件系统数据和程序的独立性不好
    文件系统不支持对文件的并发访问
    数据缺少统一管理，在格式、编码、表示命名、安全保密难于规范化
   
数据库系统构成：
    数据库DB：以一定组织形式汇集到磁盘介质上的数据
    数据库管理系统DBMS：管理数据库软件
    数据库管理员DBA：进行数据库规划，设计协调、维护管理人员
    数据库系统：应用程序、数据库管理系统、数据库和数据库管理员的总称

数据库系统功能：
    提供高级用户接口
    查询处理和优化
    数据目录管理
    并发控制
    恢复功能
    完整性约束检查
    访问控制

层次数据结构：
    树形结构只有一个双亲
    实体之间的联系单一
    树形结构在计算机中表示方便

    非层次的多元关系带来数据冗余
    数据库语言和数据的独立性比较差
    信息模型的转换有一定的难度

计算机世界三大模型：
    网状模型
    层次模型
    关系模型

传统数据模型优缺点：
    在记录基础上定义各自基本结构，约束和操作
    向用户提供了一种统一的数据模型和语言
   
    以记录为基础，不能很好地面向用户
        现实世界事务的概念为实体不是记录
        记录的划分从系统实现考虑
        使用缺乏简单方便性
    不能以自然的方式描述实体之间的联系
        描述的联系是在数据库中的实现
    语义贫乏
        记录中各个属性联系作用不明确
        对实体间联系不自然
    数据类型少
        只有简单的数据类型
        不允许用户定义新数据类型

描述应用的限制：
    非事务处理
    过早与DBMS相联系
    提高抽象级别和表达能力

元始天尊

多项式合并：

1. 
   
2. // test.cpp : Defines the entry point for the console application.
   
3. //
   
4. 
   
5. #include "stdafx.h"
   
6. 
   
7. #include <stdio.h>
   
8. #include <malloc.h>
   
9. 
   
10. struct ElemType
    
11. {
    
12.         ElemType* next;
    
13.         float coef;//系数
    
14.         int expn;//指数
    
15. };
    
16. 
    
17. ElemType* head1=NULL;
    
18. ElemType* head2=NULL;
    
19. 
    
20. ElemType* CreatePolyn()
    
21. {//初始化多项式
    
22.         ElemType* head=(ElemType*)malloc(sizeof(ElemType));
    
23.         head->next=NULL;
    
24.         return head;
    
25. }
    
26. 
    
27. void AddPolyn(ElemType* head,float coef,int expn)
    
28. {//增加多项式节点
    
29.         if(coef == 0.0)
    
30.                 return;
    
31.         for(ElemType* cur=head;cur->next != NULL && cur->next->expn < expn;cur=cur->next);
    
32.         ElemType* newnode=(ElemType*)malloc(sizeof(ElemType));
    
33.         newnode->next=cur->next;
    
34.         newnode->coef=coef;
    
35.         newnode->expn=expn;
    
36.         cur->next=newnode;
    
37. }
    
38. 
    
39. void PrintPolyn(ElemType* head)
    
40. {//打印多项式
    
41.         for(ElemType* cur=head->next;cur != NULL;cur=cur->next)
    
42.         {
    
43.                 printf("coef:%f,expn=%d\n",cur->coef,cur->expn);
    
44.         }
    
45. }
    
46. 
    
47. void MergePolyn(ElemType* head1,ElemType* head2)
    
48. {//合并多项式head1+head2->head1
    
49.         ElemType* cur1=head1;
    
50. 
    
51.         while(cur1->next && head2->next)
    
52.         {
    
53.                 ElemType* cur2=head2->next;
    
54. 
    
55.                 if(cur2->expn < cur1->next->expn)//插入cur1之前
    
56.                 {
    
57.                         head2->next=cur2->next;
    
58.                         cur2->next=cur1->next;
    
59.                         cur1->next=cur2;
    
60.                 }
    
61.                 else if(cur2->expn == cur1->next->expn)
    
62.                 {
    
63.                         cur1->next->coef += cur2->coef;
    
64.                        
    
65.                         if(cur1->next->coef == 0)
    
66.                         {
    
67.                                 ElemType* p=cur1->next;
    
68.                                 cur1->next=p->next;
    
69.                                 delete p;
    
70.                         }
    
71.                         else
    
72.                         {
    
73.                                 cur1=cur1->next;
    
74.                         }
    
75.                         head2->next=cur2->next;
    
76.                         delete cur2;
    
77.                 }
    
78.                 else
    
79.                 {
    
80.                         cur1=cur1->next;
    
81.                 }
    
82. 
    
83.         }
    
84.        
    
85.         if(head2->next)
    
86.                 cur1->next=head2->next;
    
87.         head2->next=NULL;
    
88. }
    
89. 
    
90. void DestroyPolyn(ElemType* head)
    
91. {//销毁多项式
    
92.         ElemType* cur=head;
    
93.         while(cur->next)
    
94.         {
    
95.                 ElemType* p=cur->next;
    
96.                 delete cur;
    
97.                 cur=p;
    
98.         }
    
99. }
    
100. 
     
101. int main(int argc, char* argv[])
     
102. {
     
103.         head1=CreatePolyn();
     
104.         head2=CreatePolyn();
     
105.         //7+3x+9x^8+5x^17
     
106.         AddPolyn(head1,7,0);
     
107.         AddPolyn(head1,3,1);
     
108.         AddPolyn(head1,9,8);
     
109.         AddPolyn(head1,5,17);
     
110.         printf("head1:\n");
     
111.         PrintPolyn(head1);
     
112. 
     
113.         //8x+22x^7-9x^8
     
114.         AddPolyn(head2,8,1);
     
115.         AddPolyn(head2,22,7);
     
116.         AddPolyn(head2,-9,8);
     
117.         printf("head2:\n");
     
118.         PrintPolyn(head2);
     
119. 
     
120.         MergePolyn(head1,head2);
     
121.         printf("head1:\n");
     
122.         PrintPolyn(head1);
     
123.         printf("head2:\n");
     
124.         PrintPolyn(head2);
     
125.         DestroyPolyn(head1);
     
126.         DestroyPolyn(head2);
     
127. 
     
128.         getchar();
     
129.         return 0;
     
130. }
     
131. 
     

复制代码

1. 
   
2. 单链表头结点移动到链表最后：
   
3.     Status A(LinList L)
   
4.     {
   
5.         if(L && L->next)   
   
6.         {
   
7.             Q=L;
   
8.             L=L->next;
   
9.             P=L;
   
10.             while(P->next) P=P->next;
    
11.             P->next=Q;
    
12.             Q->next=NULL;
    
13.         }
    
14.         return OK;
    
15.     }
    
16. 
    
17. 双链表拆分成2个双链表
    
18.     void BB(LNode* s,LNode* q)
    
19.     {
    
20.         p=s;
    
21.         while(p->next != q)
    
22.             p=p->next;
    
23.         p->next=s;
    
24.     }
    
25. 
    
26.     void AA(LNode* pa,LNode* pb)
    
27.     {
    
28.         BB(pa,pb);
    
29.         BB(pb,pa);
    
30.     }
    
31. 
    
32. 10进制转换为8进制
    
33.     void conversion()
    
34.     {
    
35.         InitStack(S);
    
36.         scanf("%d",N);
    
37.         while(N)
    
38.         {
    
39.             Push(S,N%8);
    
40.             N=N/8;
    
41.         }
    
42.         while(!StackEmpty(s))
    
43.         {
    
44.             Pop(S,e);
    
45.             printf("%d",e);
    
46.         }
    
47.     }
    

复制代码

0xAA55

加油。

元始天尊

数据库笔记2

数据库管理系统：
    交互式接口
    词法分析器，语法树
    存取路径，查询优化
    DBMS存取原语，打开、存取记录、建立索引
    解决共享、冲突以及故障恢复机制
    分配内存、磁盘IO、读取物理块

事务：transaction,DBMS的执行单位，由有限的操作序列组成
    执行的原子性：(atomic)要么都做要么全部做
    功能一致性：(consistency)从一个状态到另一个状态满足一致性
    彼此数据的隔离性：(isolation)多个事务可以并发执行，同一事务相互隔离
    作用的持久性：(durability)事务对数据库的影响是持久的，发生故障可以恢复

    只有在COMMIT后，数据库的变化才产生
    COMMIT与事务避免不一致的情形
    COMMIT应该执行时间很短

进程：拥有自己的内存，文件句柄和系统资源
线程：单个进程包含的执行路径：进程的代码和数据空间提供给所有的线程

网络数据库：
用户->客户应用系统->服务器API->连接性软件->网络协议->.......->网络协议->连接性软件->服务器软件->服务器OS->数据库
                                    客  户  机                                             网络                                        服  务  器

数据库管理系统内存区结构：
    系统全局区SGA    有所有服务器和客户机进程共享，用户进程需要查看的信息必须首先放到SGA中
        数据高速缓冲区
        字典高速缓冲区
        重做日志缓冲区为事务高速缓冲区
        共享SQL池为程序高速缓冲区
    程序全局区PGA    不能再进程中共享，存放数据和进程控制信息

数据目录：catalog
    是一组关于数据的数据：元数据，数据目录也是表格，可以使用查询语言
数据目录对DBMS服务：
    包括基表、视图定义
    存取路径(索引和散列)
    访问权限和查询优化条件
数据目录为系统定义并为系统所有：
    由系统自动维护
    被频繁访问的数据
    允许用户进行有控制的查询

0xAA55

终于不需要我帮忙排版了哈