zoukankan html css js c++ java

关系代数运算基本实现

传统的集合运算：

（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

看看效果：

作者：涵曦（www.hanxi.cc）
出处：hanxi.cnblogs.com
GitHub：github.com/hanxi
Email：im.hanxi@gmail.com
文章版权归本人所有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

《 Skynet 游戏服务器开发实战》

学习地址：
- https://www.lanqiao.cn/courses/2770
优惠推荐码： 2CZ2UA5u
可以先免费试学前 2 章内容

查看全文

相关阅读:
java spring-WebSocket json参数传递与接收
 java实现zabbix接口开发
 Linux 系统中的MySQL数据库默认区分大小写
 获取Linux下的IP地址 java代码
 Java多线程问题总结
 Easyui之accordion修改Title样式，字体等
 机器学习算法随机数据生成
 神经网络MPLClassifier分类
 给定数据利用神经网络算法模型进行计算
 vue $refs获取dom元素

原文地址：https://www.cnblogs.com/hanxi/p/1979792.html