如何检验一个集合是否自反、对称、反对称和/或传递

我只读了reflexive，但你需要重新考虑一下。一般来说，如果A中的第一个元素不等于B中的第一个元素，则打印"Reflexive - No"并停止。我觉得你没想清楚。

[EDIT]好了，现在我们终于确定了int a[]和int b[]的值，我必须重新开始。以前所有人的想法都是完全错误的。(尤其是我，我以前的"自反"真的是对称的，而且对输入的解释是错误的。)如果你已经学习了c++类/容器，我强烈建议用以下内容替换int a[]和int b[]:

template <class T>
struct relation {
    typedef std::pair<T,T> single_relation;
    std::set<T> elements;
    std::set<single_relation> all_relations;
};

或类似的东西，但那只是我。

reflexive:
    set holds to true
    for each element e in a
        if pair(e,e) is not in b
            set holds to false
            break
symmetric:
    set holds to true
    for each pair(e,f) in b
        if pair(f,e) is not in b
            set holds to false
            break
antisymetric: 
    set holds to true
    for each pair(e,f) in b
        if pair(f,e) is in b
            if f is not e
                set holds to false
                break
transitive:
    set holds to true
    for each pair(e,f) in b
        for each pair(f,g) in b
            if pair(e,g) is not in b
                set holds to false
                break
        if holds is false
            break

注意，实际上只有自反才需要a[]。
演示:

bool pair_is_in_relation(int left, int right, int b[], int sizeOfB)
{
    for(int i=0; i+1<sizeOfB; i+=2) {
        if (b[i]==left && b[i+1]==right)
            return true;
    }
    return false;
}
bool antiSymmetric(int b[], int sizeOfB) 
{
    bool holds = true;
    for(int i=0; i+1<sizeOfB; i+=2) {
        int e = b[i];
        int f = b[i+1];
        if(pair_is_in_relation(f, e, b, sizeOfB)) {
            if (e != f) {
                holds = false;
                break;
             }
        }
    }
    if (holds)
        std::cout << "AntiSymmetric - Yes" << endl; 
    else
        std::cout << "AntiSymmetric - No" << endl; 
    return holds;
}

对于初学者来说，这个从不增加迭代变量的for循环的目的是什么?

for(j = 0; j < sizeOfB;)
{
    ...
}

如果你在第一次迭代时就打破它，为什么要有这样一个过于复杂的for无尽循环?

如果需要遍历两个集合的叉积，可以使用以下代码片段作为开始:

for( int i = 0; i < sizeOfA; ++i )
{
    for( int j = 0; j < sizeOfB; ++j )
    {
        int elemA = a[i];
        int elemB = b[j];
        ... do your magic ...
    }
}

首先，你需要弄清楚你的术语:集合S不是自反的、对称的、传递的或任何类似的东西。这就是为什么你很难想象传递物(…)应该做什么。

在特殊集合S上，只有特殊二元关系b是自反的、对称的和可传递的。

现在，让我们用一个集合和一个关系来考虑这个。假设您有一个函数，方便地称为relation:

bool relation(int a, int b) 
{
    /* some code here that implements whatever 'relation' models. We will
     * pick some relation we know to be reflective, transitive and symmetric.
     * For example: 
     */
    return (a == b);
}

让我们也添加一个坏关系，只是为了好玩。您可以使用它来测试:

bool relation_bad(int a, int b) 
{
    /* some code here that implements whatever 'relation' models. This is
     * a relation that isn't symmetric, but it is reflexive and transitive. 
     */
    return (a >= b);
}

现在，你想要编码'reflexive'。反身性意味着一个项目与自身相关:

bool reflexive(int *s, int items) 
{
    for(int i = 0; i != items; i++)
    {
        if(!relation(s[i], s[i]))
            return false;
    }
    return true;
}

现在是'对称'。对称意味着如果a与be相关，那么b一定与a相关:

bool symmetric(int *s, int items)
{
    for(int i = 0; i != items; i++)
    { // for every item in the set:
        for(int j = 0; j != items; j++)
        { // check against every other items (including itself!)
            if(relation(s[i], s[j]) != relation(s[j], s[i])
                return false;
        }
    }
    return true;
}

我就不写传递性了，传递性意味着如果a与b相关，b与c相关，那么a一定与c相关。

你可以看到你将需要三个循环和更复杂的检查这里

\to find symetric relation
#include<iostream.h>
using namespace std;
main() {
    int a[5],b[5],c,d=0,e,f;
    cout<<"Enter 1st elemtnts: ";
    for(int i=0;i<5;i++){
        cin>>a[i];
    }
    cout<<"Enter second elemnt :";
    for(int j=0;j<5;j++){
        cin>>b[j];
    }
    for(c=0;c<5;c++){
        for(d=0;d<5;d++){
            if(a[c]==b[d]){
                cout<<"("<<a[c]<<",";
                cout<<b[d]<<")";
            }     
        }
    }   
    cout<<" Are the symetric nn";
    system("pause");
}