关系代数运算基本实现

最新推荐文章于 2024-02-24 23:21:20 发布
最新推荐文章于 2024-02-24 23:21:20 发布
阅读量180 收藏
点赞数

传统的集合运算：

（1）：并（Union）

 1 //并
 2  relate union_relate(relate u_R, relate u_S)
 3 {
 4     relate P;
 5     int i = 0, j = 0, k = 0;
 6     for (i = 0; i < 25; i++) 
 7     {
 8         P.num_tuple = u_S.num_tuple;
 9         P.num_row = u_S.num_row;
10         P.i_A[i] = 0;
11         P.i_B[i] = 0;
12         P.i_C[i] = 0;
13         P.i_D[i] = 0;
14         P.i_E[i] = 0;
15         P.i_F[i] = 0;
16     }
17 
18     if (u_R.num_row != u_S.num_row)
19     {
20         cout << "R、S不是同目关系" << endl;
21         return P;
22     }
23 
24     for (i = 0; i < u_R.num_tuple; i++)
25     {
26         P.i_A[i] = u_S.i_A[i];
27         P.i_B[i] = u_S.i_B[i];
28         P.i_C[i] = u_S.i_C[i];
29     }
30 
31     for (i = 0, k = u_R.num_tuple; i < u_R.num_tuple; i++)
32     {
33         for (j = 0; j < u_S.num_tuple; j ++)
34         {
35             if (u_R.i_A[i] == u_S.i_A[j]
36                 && u_R.i_B[i] == u_S.i_B[j]
37              && u_R.i_C[i] == u_S.i_C[j])
38             {    
39                 break;
40             }
41             else
42             {
43                 if (j == u_S.num_tuple -1)
44                 {
45                     P.i_A[k] = u_R.i_A[i];
46                     P.i_B[k] = u_R.i_B[i];
47                     P.i_C[k] = u_R.i_C[i];
48                     (P.num_tuple)++;
49                     k++;
50                 }
51             }
52         }
53     }
54 
55     return P;
56 }





（2）差（Difference）：






//差
relate except_relate(relate e_R, relate e_S)     //except
{
    relate P;
int i = 0, j = 0, k = 0;
for (i = 0; i < 25; i++) 
    {
        P.num_tuple = 0;
        P.num_row = e_R.num_row;
        P.i_A[i] = 0;
        P.i_B[i] = 0;
        P.i_C[i] = 0;
        P.i_D[i] = 0;
        P.i_E[i] = 0;
        P.i_F[i] = 0;
    }

if (e_R.num_row != e_S.num_row)
    {
        cout << "R、S不是同目关系" << endl;
return P;
    }

for (i = 0, k = 0; i < e_R.num_tuple; i++)
    {
for (j = 0; j < e_S.num_tuple; j ++)
        {
if (e_R.i_A[i] == e_S.i_A[j]
&& e_R.i_B[i] == e_S.i_B[j]
&& e_R.i_C[i] == e_S.i_C[j])
            {    
break;
            }
else
            {
if (j == e_S.num_tuple -1)
                {
                    P.i_A[k] = e_R.i_A[i];
                    P.i_B[k] = e_R.i_B[i];
                    P.i_C[k] = e_R.i_C[i];
                    (P.num_tuple)++;
                    k++;
                }
            }
        }
    }
return P;
}





（3）交（Interstation）：






/****************************************************************

方法一：

*****************************************************************/
//交
relate intersect_relate(relate i_R, relate i_S)  //intersection
{
    relate P;
int i = 0, j = 0, k = 0;
for (i = 0; i < 25; i++) 
    {
        P.num_tuple = 0;
        P.num_row = i_R.num_row;
        P.i_A[i] = 0;
        P.i_B[i] = 0;
        P.i_C[i] = 0;
        P.i_D[i] = 0;
        P.i_E[i] = 0;
        P.i_F[i] = 0;
    }

if ( i_R.num_row != i_S.num_row)
    {
        cout << "R、S不是同目关系" << endl;
return P;
    }

for (i = 0, k =0; i < i_R.num_tuple; i++)
    {
for (j = 0; j < i_S.num_tuple; j++)
       {
if (i_R.i_A[i] == i_S.i_A[j]
&& i_R.i_B[i] == i_S.i_B[j]
&& i_R.i_C[i] == i_S.i_C[j])
           {
               P.i_A[k] = i_R.i_A[i];
               P.i_B[k] = i_R.i_B[i];
               P.i_C[k] = i_R.i_C[i];
               (P.num_tuple)++;
               k++;
           }
       }
    }
return P;
}





对于交还有另一种算法：R n S = R - (R - S)


代码如下：






//***************************************************************
//
//方法二：
//
//***************************************************************
relate intersect_relate(relate i_R, relate i_S)  //intersection
{
    relate P;
int i = 0;
for (i = 0; i < 25; i++) 
    {
        P.num_tuple = 0;
        P.num_row = i_R.num_row;
        P.i_A[i] = 0;
        P.i_B[i] = 0;
        P.i_C[i] = 0;
        P.i_D[i] = 0;
        P.i_E[i] = 0;
        P.i_F[i] = 0;
    }

if (i_R.num_row != i_S.num_row)
    {
        cout << "R、S不是同目关系" << endl;
return P;
    }

    P = except_relate(i_R,except_relate(i_R,i_S));
return P;
}





（4）笛卡尔积（Cartesian Product）：






//笛卡尔积
relate car_pro_relate(relate c_R, relate c_S)    //cartesian product
{
    relate P;
int i = 0, j = 0, k = 0, n = 0;
for (i = 0; i < 25; i++) 
    {
        P.num_tuple = c_R.num_tuple * c_S.num_tuple;
        P.num_row = c_R.num_row + c_S.num_row;
        P.i_A[i] = 0;
        P.i_B[i] = 0;
        P.i_C[i] = 0;
        P.i_D[i] = 0;
        P.i_E[i] = 0;
        P.i_F[i] = 0;
    }

for (i = 0; i < c_R.num_tuple * c_S.num_tuple; i++)
    {
if (i < (j+1)*c_S.num_tuple)
        {
            P.i_A[i] = c_R.i_A[j];
            P.i_B[i] = c_R.i_B[j];
            P.i_C[i] = c_R.i_C[j];
            P.i_D[i] = c_S.i_D[j];
            P.i_E[i] = c_S.i_E[j];
            P.i_F[i] = c_S.i_F[j];
        }
if ((i+1) % c_S.num_tuple == 0)
        {
            j++;
        }
    }

for (i = 0; i < c_R.num_tuple * c_S.num_tuple; i++)
    {      
for (j = 0; j < c_S.num_tuple; j++)
        {
if (i % c_S.num_tuple == j)
            {
if (c_R.num_row == 1)
                {
                    P.i_B[i] = c_S.i_A[j];
                    P.i_C[i] = c_S.i_B[j];            
                    P.i_D[i] = c_S.i_C[j];
                }
if (c_R.num_row == 2)
                {
                    P.i_C[i] = c_S.i_A[j];            
                    P.i_D[i] = c_S.i_B[j];
                    P.i_E[i] = c_S.i_C[j];
                }
if (c_R.num_row == 3)
                {        
                    P.i_D[i] = c_S.i_A[j];
                    P.i_E[i] = c_S.i_B[j];
                    P.i_F[i] = c_S.i_C[j];
                }
            }
        }
            }
return P;
}





专门的关系运算：


（1）投影（Projection）：






//投影,只提供实现在单个属性列上的投影
//R在S上的投影
//        R              
//   A    B    C         C
//-------------------------------
//   1    3    2         2
//   5    7    2         2
//   1    3    4         4
//--------------------------------
//    PAI    (R)
//       (S)
relate project_relate(relate p_R, char ch)     //projection
{
    relate P;
int i = 0, j = 0, k = 0, n = 0;
for (i = 0; i < 25; i++) 
    {
        P.num_tuple = p_R.num_tuple;
        P.num_row = 1;
        P.i_A[i] = 0;
        P.i_B[i] = 0;
        P.i_C[i] = 0;
        P.i_D[i] = 0;
        P.i_E[i] = 0;
        P.i_F[i] = 0;
    }
if (ch == 'A')
    {
for (i = 0; i < p_R.num_tuple; i++)
        {
            P.i_A[i] = p_R.i_A[i];
        }        
    }
if (ch == 'B')
    {
for (i = 0; i < p_R.num_tuple; i++)
        {
            P.i_A[i] = p_R.i_B[i];
        }        
    }
if (ch == 'C')
    {
for (i = 0; i < p_R.num_tuple; i++)
        {
            P.i_A[i] = p_R.i_C[i];
        }        
    }
//去除相同元素
    for (i = 0; i < p_R.num_tuple; i++)
    {
for (j = i+1; j < p_R.num_tuple; j++)
        {
if (P.i_A[i] == P.i_A[j])
            {
                P.i_A[j] = 0;
            }
        }
    }

for (i = 0, k= 0; i < P.num_tuple; i++)
    {
if (P.i_A[i] != 0)
        {
            P.i_A[k] = P.i_A[i];
            k++;
        }
    }
    P.num_tuple = k;
return P;
}





（2）自然连接（Natural join）：






//自然连接
relate join_relate(relate j_R, relate j_S)       //join
{
    relate P, Q;
int i = 0, j = 0, k = 0, n = 0;
for (i = 0; i < 25; i++) 
    {
        P.num_tuple = 0;
        P.num_row = 4;    //R(A,B,C)和S(B,C,D)相同属性名是B、C,自然连接后剩下四个属性组
//R(A,B)和S(B,C,D)相同属性名是B，自然连接后4个属性组
        P.i_A[i] = 0;
        P.i_B[i] = 0;
        P.i_C[i] = 0;
        P.i_D[i] = 0;
        P.i_E[i] = 0;
        P.i_F[i] = 0;
        Q.num_tuple = 0;
        Q.num_row = 0;
        Q.i_A[i] = 0;
        Q.i_B[i] = 0;
        Q.i_C[i] = 0;
        Q.i_D[i] = 0;
        Q.i_E[i] = 0;
        Q.i_F[i] = 0;
    }
for (i = 0; i < j_S.num_tuple; i++)//为了能使用笛卡尔积函数，将S(B,C,D,)转为S(A,B,C)
    {
        j_S.i_A[i] = j_S.i_B[i];
        j_S.i_B[i] = j_S.i_C[i];
        j_S.i_C[i] = j_S.i_D[i];
        j_S.i_D[i] = j_S.i_E[i];
        j_S.i_E[i] = j_S.i_F[i];
    }
    Q = car_pro_relate(j_R, j_S);

//R有三个属性组，且B,C为相同属性名
    if (j_R.num_row == 3)
    {
//相同属性名是B、C
//         R             S
//     A   B   C      B  C  D
//->   A   B   C      A  B  C
//---------------------------
//Q:   A   B   C      D  E  F
//P:   A   B   C      D

for (i = 0,j = 0; i < Q.num_tuple; i++)
        {
if (Q.i_B[i] == Q.i_D[i] && Q.i_C[i] == Q.i_E[i])
            {
                P.i_A[j] = Q.i_A[i];
                P.i_B[j] = Q.i_B[i];
                P.i_C[j] = Q.i_C[i];
                P.i_D[j] = Q.i_D[i];
                P.i_E[j] = Q.i_E[i];
                P.i_F[j] = Q.i_F[i];
                j++;
            }
        }
        P.num_tuple = j;
for (i = 0; i < P.num_tuple; i++)
        {
            P.i_D[i] = P.i_F[i];
            P.i_E[i] = 0;
            P.i_F[i] = 0;
        }
    }

//相同属性名是B且R只有两个属性组
    if (j_R.num_row == 2) 
    {
//相同属性名是B
//      R         S
//--------------------------
//    A   B  |  B    C    D
//->  A   B  |  A    B    C
//Q:  A   B     C    D    E
//         \   / \  / \  /
//          \ /   \/   \/
//P:  A      B    C    D
        for (i = 0,j = 0; i < Q.num_tuple; i++)
        {
if (Q.i_B[i] == Q.i_C[i])
            {
                P.i_A[j] = Q.i_A[i];
                P.i_B[j] = Q.i_B[i];
                P.i_C[j] = Q.i_C[i];
                P.i_D[j] = Q.i_D[i];
                P.i_E[j] = Q.i_E[i];
                P.i_F[j] = Q.i_F[i];
                j++;
            }
        }
        P.num_tuple = j;
for (i = 0; i < P.num_tuple; i++)
        {
            P.i_B[i] = P.i_C[i];
            P.i_C[i] = P.i_D[i];
            P.i_D[i] = P.i_E[i];
            P.i_E[i] = 0;
        }
    }
return P;
}






(3)除法（Division）：






// R / S的必要条件是：
//(1) R.num_tuple>S.num_tuple
//(2) S非空
//(3) R中存在S.num_tuple个属性与S的S.num_tuple个属性定义在相同的域中
relate div_relate(relate d_R ,relate d_S)        //division
{
    relate P;
int i = 0, j = 0, k = 0, n = 0;
for (i = 0; i < 25; i++) 
    {
        P.num_tuple = 0;
        P.num_row = d_R.num_row - d_S.num_row;    
        P.i_A[i] = 0;
        P.i_B[i] = 0;
        P.i_C[i] = 0;
        P.i_D[i] = 0;
        P.i_E[i] = 0;
        P.i_F[i] = 0;
    }
//R(A,B,C)    S(A,B)
//X的属性组：C
//Y的属性组：A,B

    P = project_relate(d_R, 'C');
    P = car_pro_relate(d_S,P);
    P = except_relate(P, d_R);
    P = project_relate(P,'C');
    P = except_relate(project_relate(d_R,'C'),P);    
return P;
}






好了，写个主函数测试下：






//main.cpp

#include "common.h"

#include <iostream>

using namespace std;

//并、交、差
void UIE(void)
{
	relate R, S, U, I, E;
	int i = 0;
	for (i = 0; i < 25; i++) 
    {
		R.num_tuple = 3;    //记录元组个数
		R.num_row = 3;      //记录列数
		S.num_tuple = 3;    //记录元组个数
		S.num_row = 3;      //记录列数
        R.i_A[i] = 0;
        R.i_B[i] = 0;
        R.i_C[i] = 0;
        R.i_D[i] = 0;
        R.i_E[i] = 0;
        R.i_F[i] = 0;
		S.i_A[i] = 0;
        S.i_B[i] = 0;
        S.i_C[i] = 0;
        S.i_D[i] = 0;
        S.i_E[i] = 0;
        S.i_F[i] = 0;
    }
    //          R        |        S
    //----------------------------------------
    //    A  |  B  |  C  |   A  |  B  |  C
    //    1  |  1  |  2  |   1  |  2  |  1
    //    1  |  2  |  1  |   1  |  1  |  1
    //    2  |  2  |  3  |   2  |  2  |  3
    //----------------------------------------
    //
	
    R.i_A[0] = 1;
    R.i_A[1] = 1;
    R.i_A[2] = 2;
    R.i_B[0] = 1;
    R.i_B[1] = 2;
    R.i_B[2] = 2;
    R.i_C[0] = 2;
    R.i_C[1] = 1;
    R.i_C[2] = 3;
    S.i_A[0] = 1;
    S.i_A[1] = 1;
    S.i_A[2] = 2;
    S.i_B[0] = 2;
    S.i_B[1] = 1;
    S.i_B[2] = 2;
    S.i_C[0] = 1;
    S.i_C[1] = 1;
    S.i_C[2] = 3;
	
	cout << "R:" << endl;
	for (i = 0; i < R.num_tuple; i++)
	{
        cout << R.i_A[i] << "\t" << R.i_B[i] << "\t" << R.i_C[i] <<endl;
		cout << "--------------------" << endl;
	}
	cout << "S:" << endl;
	for (i = 0; i < S.num_tuple; i++)
	{
        cout << S.i_A[i] << "\t" << S.i_B[i] << "\t" << S.i_C[i] <<endl;
		cout << "--------------------" << endl;
	}
    U = union_relate(R, S);
    cout << "\n" << "并：" << endl;
	for (i = 0; i < U.num_tuple; i++)
    {
        cout << U.i_A[i] << "\t" << U.i_B[i] << "\t" << U.i_C[i] <<endl;
		cout << "--------------------" << endl;
    }
	I = intersect_relate(R,S);
	cout << "交：" << endl;
    for (i = 0; i < I.num_tuple; i++)
    {
        cout << I.i_A[i] << "\t" << I.i_B[i] << "\t" << I.i_C[i] <<endl;
		cout << "--------------------" << endl;
    }
	E =except_relate(R,S);
	cout << "差：" << endl;
	for (i = 0; i < E.num_tuple; i++)
    {
        cout << E.i_A[i] << "\t" << E.i_B[i] << "\t" << E.i_C[i] <<endl;
		cout << "--------------------" << endl;
    }

	return;
}

//笛卡尔积
void Car_pro(void)
{
	relate R, S, C;
	int i = 0;
	for (i = 0; i < 25; i++) 
    {
		R.num_tuple = 2;    //记录元组个数
		R.num_row = 3;      //记录列数
		S.num_tuple = 3;    //记录元组个数
		S.num_row = 3;      //记录列数
        R.i_A[i] = 0;
        R.i_B[i] = 0;
        R.i_C[i] = 0;
        R.i_D[i] = 0;
        R.i_E[i] = 0;
        R.i_F[i] = 0;
		S.i_A[i] = 0;
        S.i_B[i] = 0;
        S.i_C[i] = 0;
        S.i_D[i] = 0;
        S.i_E[i] = 0;
        S.i_F[i] = 0;
    }
	//          R        |        S
    //----------------------------------------
    //    A  |  B  |  C  |   A  |  B  |  C
    //    1  |  1  |  2  |   1  |  2  |  1
    //    1  |  2  |  1  |   1  |  1  |  1
    //    2  |  2  |  3  |   2  |  2  |  3
    //----------------------------------------
    //
	
    R.i_A[0] = 1;
    R.i_A[1] = 1;
   // R.i_A[2] = 2;
    R.i_B[0] = 1;
    R.i_B[1] = 2;
   // R.i_B[2] = 2;
    R.i_C[0] = 2;
    R.i_C[1] = 1;
    //R.i_C[2] = 3;
    S.i_A[0] = 1;
    S.i_A[1] = 1;
    S.i_A[2] = 2;
    S.i_B[0] = 2;
    S.i_B[1] = 1;
    S.i_B[2] = 2;
    S.i_C[0] = 1;
    S.i_C[1] = 1;
    S.i_C[2] = 3;
	cout << "\n" <<"R:" << endl;
	for (i = 0; i < R.num_tuple; i++)
	{
        cout << R.i_A[i] << "\t" << R.i_B[i] << "\t" << R.i_C[i] <<endl;
		cout << "--------------------" << endl;
	}
	cout << "S:" << endl;
	for (i = 0; i < S.num_tuple; i++)
	{
        cout << S.i_A[i] << "\t" << S.i_B[i] << "\t" << S.i_C[i] <<endl;
		cout << "--------------------" << endl;
	}
	C =car_pro_relate(R,S);
	cout << "\n" << "笛卡尔积：" << endl;
	for (i = 0; i < C.num_tuple; i++)
	{
		cout << C.i_A[i] << "\t" << C.i_B[i] << "\t" << C.i_C[i] << "\t" << C.i_D[i] << "\t" << C.i_E[i] << "\t" << C.i_F[i] <<endl;
		cout << "---------------------------------------------" << endl;
	}
}

//自然连接
void natural(void)
{
	relate R, S, N;
	int i = 0;
	for (i = 0; i < 25; i++) 
    {
		R.num_tuple = 4;    //记录元组个数
		R.num_row = 3;      //记录列数
		S.num_tuple = 3;    //记录元组个数
		S.num_row = 3;      //记录列数
        R.i_A[i] = 0;
        R.i_B[i] = 0;
        R.i_C[i] = 0;
        R.i_D[i] = 0;
        R.i_E[i] = 0;
        R.i_F[i] = 0;
		S.i_A[i] = 0;
        S.i_B[i] = 0;
        S.i_C[i] = 0;
        S.i_D[i] = 0;
        S.i_E[i] = 0;
        S.i_F[i] = 0;
    }
	//            R              |              S
	//-----------------------------------------------------
	//    A   |   B    |   C     |      B   |   C   |   D
	//-----------------------------------------------------
	//    2   |   4    |   6     |      5   |   7   |   3
	//    3   |   5    |   7     |      4   |   6   |   2   
	//    7   |   4    |   6     |      5   |   7   |   9
	//    5   |   4    |   7     |
	//----------------------------------------------------
	R.i_A[0] = 2;
    R.i_A[1] = 3;
    R.i_A[2] = 7;
    R.i_A[3] = 5;
    R.i_B[0] = 4;
    R.i_B[1] = 5;
    R.i_B[2] = 4;
    R.i_B[3] = 4;
    R.i_C[0] = 6;
    R.i_C[1] = 7;
    R.i_C[2] = 6;
    R.i_C[3] = 7;

    S.i_B[0] = 5;
    S.i_B[1] = 4;
    S.i_B[2] = 5;
    S.i_C[0] = 7;
    S.i_C[1] = 6;
    S.i_C[2] = 7;
    S.i_D[0] = 3;
    S.i_D[1] = 2;
    S.i_D[2] = 9;
	cout << "\n" << "R:" << endl;
	cout << "R.A" << "\t" << "R.B" << "\t" << "R.C" <<endl;
	cout << "--------------------" << endl;
	for (i = 0; i < R.num_tuple; i++)
	{
        cout << R.i_A[i] << "\t" << R.i_B[i] << "\t" << R.i_C[i] <<endl;
		cout << "--------------------" << endl;
	}
	cout << "S:" << endl;
	cout << "S.B" << "\t" << "S.C" << "\t" << "S.D" <<endl;
	for (i = 0; i < S.num_tuple; i++)
	{
        cout << S.i_B[i] << "\t" << S.i_C[i] << "\t" << S.i_D[i] <<endl;
		cout << "--------------------" << endl;
	}
	N = join_relate(R, S);
	cout << "\n" << "自然连接：" << endl;
	cout << "A" << "\t" << "B" << "\t" << "C" << "\t" << "D" <<endl;
	cout << "-----------------------------" << endl;
	for (i = 0; i < N.num_tuple; i++)
	{
		cout << N.i_A[i] << "\t" << N.i_B[i] << "\t" << N.i_C[i] << "\t" << N.i_D[i] <<endl;
		cout << "-----------------------------" << endl;
	}
	return;
}

//除法
void div(void)
{
	relate R, S, D;
	int i = 0;
	for (i = 0; i < 25; i++) 
    {
		R.num_tuple = 5;    //记录元组个数
		R.num_row = 3;      //记录列数
		S.num_tuple = 2;    //记录元组个数
		S.num_row = 2;      //记录列数
        R.i_A[i] = 0;
        R.i_B[i] = 0;
        R.i_C[i] = 0;
        R.i_D[i] = 0;
        R.i_E[i] = 0;
        R.i_F[i] = 0;
		S.i_A[i] = 0;
        S.i_B[i] = 0;
        S.i_C[i] = 0;
        S.i_D[i] = 0;
        S.i_E[i] = 0;
        S.i_F[i] = 0;
    }
	//            R              |          S
	//----------------------------------------------
	//    A   |   B    |   C     |      A   |   B   
	//----------------------------------------------
	//    1   |   3    |   2     |      1   |   3   
	//    5   |   7    |   2     |      5   |   7    
	//    1   |   3    |   4     |     
	//    1   |   3    |   6     |
	//    5   |   7    |   6     | 
	//-----------------------------------------------
	R.i_A[0] = 1;
    R.i_A[1] = 5;
    R.i_A[2] = 1;
    R.i_A[3] = 1;
    R.i_A[4] = 5;
    R.i_B[0] = 3;
    R.i_B[1] = 7;
    R.i_B[2] = 3;
    R.i_B[3] = 3;
    R.i_B[4] = 7;
	R.i_C[0] = 2;
    R.i_C[1] = 2;
    R.i_C[2] = 4;
    R.i_C[3] = 6;
    R.i_C[4] = 6;
	
    S.i_A[0] = 1;
    S.i_A[1] = 5;
    S.i_B[0] = 3;
    S.i_B[1] = 7;
	cout << "\n" << "R:" << endl;
	cout << "R.A" << "\t" << "R.B" << "\t" << "R.C" <<endl;
	cout << "--------------------" << endl;
	for (i = 0; i < R.num_tuple; i++)
	{
        cout << R.i_A[i] << "\t" << R.i_B[i] << "\t" << R.i_C[i] <<endl;
		cout << "--------------------" << endl;
	}
	cout << "S:" << endl;
	cout << "S.A" << "\t" << "S.B" <<endl;
	for (i = 0; i < S.num_tuple; i++)
	{
        cout << S.i_A[i] << "\t" << S.i_B[i] <<endl;
		cout << "-------------" << endl;
	}
	D = div_relate(R, S);
	cout << "\n" << "除法：" << endl;
	cout << "\t" << "C" <<endl;
	cout << "----------------" << endl;
	for (i = 0; i < D.num_tuple; i++)
	{
		cout  << "\t" << D.i_A[i] <<endl;
		cout << "----------------" << endl;
	}

	cout << "\t\t\tOK! \n\t功能基本上实现了，但还是有多处不能推广（比如说有些属性组被限制）！\n " << endl;
	return;
}
int main()
{

	UIE();
	Car_pro();
	natural();
    div();
    return 0;
}






好，commom.h里的内容只是声明函数和定义结构体：






//commom.h

#ifndef COMMON_H_INCLUDED
#define COMMON_H_INCLUDED


typedef struct
{
    int num_tuple;    //记录元组个数
    int num_row;      //记录列数,即：目
    int i_A[25];
    int i_B[25];
    int i_C[25];
    int i_D[25];
    int i_E[25];
    int i_F[25];
}relate;

relate union_relate(relate u_R, relate u_S);      //union
relate except_relate(relate e_R, relate e_S);     //except
relate intersect_relate(relate i_R, relate i_S);  //intersection
relate car_pro_relate(relate c_R, relate c_S);    //cartesian product


relate project_relate(relate p_R, char ch);     //projection
relate join_relate(relate j_R, relate j_S);        //join
relate div_relate(relate d_R ,relate d_S);         //division

#endif // COMMON_H_INCLUDED









看看效果：


2011031014302931.jpg2011031014310910.jpg2011031014311770.jpg2011031014312737.jpg2011031014313955.jpg

                

        




    

    
  


            

                    
            


    



                



	

		

			

				
					
Python编程

				
			

			

				

					xu_aml的博客
				

				

					04-26
					
					1171
					
				

			

		

		

			
				
Python编程学习input函数创建列表列表常用函数和方法删除元素修改列表元素查询列表元素位置列表常用操作元组字典（dict）集合运算程序流程控制语句if多路分支（else、elif）for 循环whilerange 函数breakcontinue函数创建并使用匿名函数面向对象编程绑定 self删除对象私有化方法生成迭代器返回迭代器继承父类属性和方法文件基础
最后一次更新，要离开了
python
input函数
>>> zz=input()
我心光明
>>> zz
'我

			
		

	



                

            
              



	

		

			

				
					
软件设计师之关系代数运算全解析：从基础到复杂查询

					
最新发布

				
			

			

				

					wj_rdk的博客
				

				

					03-27
					
					1381
					
				

			

		

		

			
				
在软件开发领域，数据库操作是极为关键的部分，而关系代数作为关系数据库操作的理论基石，对于软件设计师来说是必须掌握的核心知识。我写这篇博客，就是希望能和大家一起深入学习关系代数，在技术成长的道路上共同进步。

			
		

	



              


  
              

                


	

		

			

				
					
（数据库）Java对于关系（即表）交差并（关系代数）运算的实现（含代码和文件）

				
			

			

				

					t____t__的博客
				

				

					09-04
					
					498
					
				

			

		

		

			
				
用Java模拟实现数据表的交并差运算

			
		

	





	

		

			

				
					
数据库复习——SQL实现关系代数操作、分组查询与过滤

				
			

			

				

					无由页的博客
				

				

					08-09
					
					3072
					
				

			

		

		

			
				
前言
基本SQL查询的另一块内容
正文
一、分组查询

分组：SQL可以将检索到的元组按照某一条件进行分类，具有相同条件值的元组划到一个组或一个集合中，同时处理多个组或集合的聚集运算

示例： 求每一个学生的平均成绩
Select S#, AVG(Score) 
From SC
Group by S#; 

上例是按学号进行分组，即学号相同的元组划到一个组中并求平均值

示例：求每一门课程的平均成绩
Select C#, AVG(Score) 
From SC
Group by C#;

上例是按课号进行分

			
		

	



		

			
		



	

		

			

				
					
求大佬们解答

				
			

			

				

					m0_46578664的博客
				

				

					03-22
					
					1340
					
				

			

		

		

			
				
建立集合R，F，S分别保存长跑、羽毛球、游泳运动的参加者。通过集合运算，找出（1）仅参加了1项、（2）参加任意2项、（3）参加全部3项 运动的参加者名单及人数。

...

			
		

	





	

		

			

				
					
【数据库】关系代数基本运算

					
热门推荐

				
			

			

				

					习惯成自然
				

				

					11-01
					
					8万+
					
				

			

		

		

			
				
前言

 

       关系代数是以关系为运算对象的一组高级运算的集合。由于关系定义为属性个数相同的元组的集合，因此集合代数的操作就可以引入到关系代数中。关系代数中的操作可以分为两类：传统的关系操作，并、差、交、笛卡尔积（乘）、笛卡尔积的逆运算（除）；扩充的关系操作，对关系进行垂直分割（投影）、水平分割（选择）、关系的结合（连接、自然连接）等。

 

五个基本的关系代数操作

 

    ...

			
		

	





	

		

			

				
					
实现关系代数运算

				
			

			

				

					05-07
				

			

		

		

			
				
本篇文章将深入探讨关系代数运算在SQL中的应用及其重要性。  一、关系代数的基本概念  1. **关系**: 在数据库中，关系可以理解为一张二维表格，包含行（记录）和列（属性）。每个列有一个特定的数据类型，而行代表...

			
		

	





	

		

			

				
					
数据库关系代数习题.pdf

				
			

			

				

					04-22
				

			

		

		

			
				
本资源提供了多种关系代数习题，涵盖了关系数据库的基本概念和高级查询技术。  1. 检索"英语"专业学生所学课程的信息，包括学号、姓名、课程名和分数。  关系代数表达式：Π 学号，姓名，课程名，分数 (σ 专业='...

			
		

	





	

		

			

				
					
软考41-上午题-【数据库】-关系代数运算3-外连接

				
			

			

				

					qq_31532983的博客
				

				

					02-24
					
					895
					
				

			

		

		

			
				
外连接：左外连接、右外连接、全外连接

			
		

	





	

		

			

				
					
关系数据库模型与关系代数运算综述

				
			

			

				

					
				

			

		

		

			
				
在关系代数方面，关系代数运算涉及运算对象、运算结果和运算符这三个要素，通过不同的关系代数运算符实现数据的处理和查询。关系代数运算的分类主要包括集合运算符、专门的关系运算符、算术比较符和逻辑运算符，用于...

			
		

	





	

		

			

				
					
关系代数基本运算 数据库

				
			

			

				

					qq_49175846的博客
				

				

					09-25
					
					6954
					
				

			

		

		

			
				
关系代数的八种基本运算
并
并，就是将两个或多个表并连起来，需要注意的就是在并的过程中，我们并不是直接一笼统地并起来，而且还要对相同的元祖进行合并，即并操作后的表中，相同的元组不可多次出现（该操作需满足表之间数据结构相同的条件）
例如R∪S，最后的结果是属于R与S的并集，即新表中的元组一定可以在R或者S中找到。
交
交，与数学中的交相类似，也就是两个或多个表进行交操作，相同的元组被保留到新表，而不同的被舍弃。（该操作同样需满足数据结构相同的条件）
例如R∩S，最后的结果属于R与S的交集，即新表中的元组一定既

			
		

	





	

		

			

				
					
关系代数运算

				
			

			

				

					ACM
				

				

					06-29
					
					2万+
					
				

			

		

		

			
				
转自点击打开链接关系代数的运算是一种数学运算，你主要功能是通过这种数学运行来指导数据库在关系操作上的程序实现。如图所示，下面是关系代数的操作，上面是对应的SQL语句。如果我们熟悉关系代数的操作那么就很容易写出复杂的SQL语句了。关系代数的操作对关系进行运算时，我们可以采用对待集合的方式来操作，这些操作被称为集合操作。其他的一些操作不能在集合上使用，那么被成为纯关系操作。对于集合操作中U,∩，-操作...

			
		

	





	

		

			

				
					
【数据库基础】 几种基本的关系代数运算方法

				
			

			

				

					学渣戊的优快云
				

				

					04-15
					
					2万+
					
				

			

		

		

			
				
关系代数是一种抽象的查询语言，用对关系的运算来表达查询，作为研究关系数据语言的数学工具。
基本的关系代数算法：
传统的集合运算：并、交、差、广义笛卡尔积；
专门的集合运算：选择、投影、象集、连接（等值连接、自然连接）、除；
Refences

			
		

	





	

		

			

				
					
【数据库复习】关系代数

				
			

			

				

					mmdev
				

				

					04-29
					
					2504
					
				

			

		

		

			
				

关系代数

问：为何称为代数？

答：因为存在操作符和操作数，操作数为表，操作符为交、并等；

关系代数有分为基于集合的关系代数和基于包的关系代数；


关系代数的基本操作：并、选择、投影、笛卡尔积、差、重命名；
基本操作的意思是其他的操作符可以通过基本操作推出；

注意：如果我们使用并、交、差运算，必须保证R和S的属性集合是相同的，当然如果不同，也可以通过重命名操作；...

			
		

	





	

		

			

				
					
关系代数——基本运算(1)

				
			

			

				

					weixin_33982670的博客
				

				

					12-18
					
					899
					
				

			

		

		

			
				
关系代数的基本运算主要包括选择、投影、并、集合差、笛卡尔积和更名运算。
选择、投影和更名运算是一元运算。另外三个是二元运算。
选择 (σ)
广义选择是写为的一元运算，这里的是由正常选择中所允许的原子和逻辑算子(与)、(或) 和(非)构成的命题公式。这种选择选出中使成立的所有元组。
为了选择loan关系中支行名称为"Perryridge"的那些元...

			
		

	





	

		

			

				
					
二、关系数据库——（3）关系代数

				
			

			

				

					csdn_yaohailong的博客
				

				

					05-16
					
					1154
					
				

			

		

		

			
				
关系代数运算符

传统的集合运算
（1）并：

(2)差：
（3）交：
（4）笛卡尔积：

专门的关系运算
（1）选择（Selection）：
（2）投影（Projection）：
(3)连接（Join）：
分为一般连接、自然连接、等值连接、外连接（左外连接、右外连接）

（4）除运算（Division）：
需要利用象集

例子


...

			
		

	





	

		

			

				
					
关系代数运算So Easy

				
			

			

				

					小火子
				

				

					10-21
					
					1万+
					
				

			

		

		

			
				
关系代数是以关系为运算的一组高级运算的集合。由于定义为属性个数 相同的元组的集合，因此集合代数的操作就可以引入到关系代数中。关系代数也可以看做是一种抽象的查询语言，是对关系的运算来表达查询的。任何一种运算都是将一定的运算符作用于一定的运算对象上，得到预期的运算结果。所以运算对象、运算符、运算结果是运算的三大要素。 
关系代数的运算对象是关系，运算结果亦为关系。关系代数用到的运算符包括四类:集合运

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值