A={1,2,3}
 
R1={<1,1>,<2,2>,<3,3>}
 
R2={<1,3>}
 
说明R1具有自反性.R2是反自反的。
 
R1即是对称的，又是反对称的。
 
R3={<1,1>,<1,2>,<2,1>}
 
R4={<2,1>,<3,2>}
 
对称的逆就是反对称。（<x,y>与<y，x>为对称，如果一个集合中只包括不同的<x,y>且没有<y,x>为反对称）
 
R3是对称的。R4反对称。
 
传递性与非传递性是互斥的。
 
xRy ，yRz 存在关系<x,z>就是传递的。不存在就是非传递的。
 
R4是传递的。
 
 
 
 
 
 

 ua中对table的排序一般是用lua自带的table.sort()函数排序，一般不采用自己写的排序的方式，以下来说一说
 
 table.sort()排序和在工作中遇到的问题 
 
 
1.排序的方式
 

table.sort(tbl,function(a,b)
        return a > b
end)
 
 以上是一个简单的例子，得到的效果是对于待排序的数据的一个升序，你这样认为就是错了，例如a和b是一个样
 
 的，返回的是false，是一个不严格的升序，严格的说可以是一个非降序排列。 
 对于lua中的排序，最好是用lua自带的函数，不要自己造轮子，自己写一个排序的函数
 
 在排序的时候应该是严格弱序，用小于关系。
 
 正确的排序应该满足的条件，才能得到结果 
 1）反自反性
 
cmp(a, a) === false
 
 就是在写的排序的实现中，自己和自己比较，要永远是false 
 2）非对称性
 
 
 cmp(a, b) == true ==> cmp(b, a) == false
 
 就是a和b比较得到的是true，那么b和a比较得到的就是false，否则就不成立 
 
 3）传递性
 
 
cmp(a, b) == true && cmp(b, c) == true ==> cmp(a, c) == true
 
 不可比的传递性 
 
 就是说a和b之间成立，b和c之间成立，那么a和c之间也要成立，才能达到传递性
 
 如cmp（a,b） 
 a == b + 1 这个就是不成立的 
 如果存在这样的cmp(a, b) == true && cmp(b, c) == true，那么就假设a = 2，b = 1，c = 0 
 但是cmp(a, c)就不成立了，所以这个排序是不能成功的
 
 注：table.sort(list,function(a,b) 
 end)在这里面不需要去判断a，b是否存在，他们是一定存在的，它是list中的数据，所以一定是存在的。
 
 二：多个条件的比较 
 在一些需求当中，比较的数据不是一个，是组合的形式出现的，先是比较字段a，如果相等再比较字段b，那么在
 
 处理这样的实例当中，有以下的几种方式 
 1）
 
 
function(a, b)    
  return a.level > b.level or 
  a.level == b.level and a.exp > b.exp
end
 
 2）
 
 
function(a, b)    
if a.level == b.level then
    return a.exp > b.exp
end
    return a.level > b.level
end
 
 3）
 
 
function(a, b)
    if a.level ~= b.level then
        return a.level > b.level
    end
    return a.exp > b.exp
end
 
 这三种方法当中，第三种是最好的，因为它具有很大的延展性，如果以后比较的是三个或者是三个以上的字段，那么直接在后面添加就是，第二种的话，就是要倒序的去比较，讲比较的字段分成比较的先后顺序为1，2，3，4.那么按照第二种的话，就先去判断4是否相等，然后依次是3，2是否相等。不好理解
 
 三：排序与最值 
 对于不同的排序方式，算法得到的效果不同，那么就要考虑一下算法的复杂度。 
 任意table 线性查找最值 O(n) 
 排序 O(nlgn) 
 只需要最值且数组规模不小的时候不排序
 
 四：多次排序 
 由于在现实的例子中，可能对于要排序的条件不止一个，是两个或者是两个以上的时候，需要在一个函数中，一
 
 次性排完。 
 排序的稳定性： 
 快排不具备稳定性，所以不可以按照条件顺序多次排序 
 多次排序效率也不高
 

 

 

暂时当草稿存放在这里，后面再补充


//分别将自反性、对称性、传递性的编号为Func1、Func2,Func3。
#include <iostream>
#include <cstring>
#include <fstream>
using namespace std;

const int LEN = 140 + 10;
int arr[LEN][2+10];      //存储集合元素
int relation[LEN][LEN];  //关系矩阵
int nnn; //集合元素个数
int num; //集合关系个数
void Func1();
void Func2();
void Func3();

int main()
{
 //   freopen("datain.txt", "r", stdin);
    cout << "请输入集合中的元素个数 : " << endl;
    cin >> nnn;
    cout << "请输入集合中的关系个数 : " << endl;
    cin >> num;
    cout << "集合中一共有" << num << "对关系" << "," << num*2 <<"个元素(请以整数形式输入) : " << endl;
    memset(arr, 0, sizeof(arr));   //用数组做参数传递给标准函数memset()，以让其将数组设置成全0：
    memset(relation, 0, sizeof(relation)); //这里不懂得话可以参考https://blog.csdn.net/qq_37796444/article/details/80181632
    int num1, num2;
    for(int i = 1; i <= num; i++)
    {
        cin >> num1 >> num2;
        arr[i][1] = num1;
        arr[i][2] = num2;
        relation[num1][num2] = 1;
    }

    cout << "输出关系矩阵 : " << endl;
    for(int i = 1; i <= nnn; i++)
    {
        for(int j = 1; j <= nnn; j++)
        {
            cout << relation[i][j] << "     ";
        }
        cout << endl;
    }
    cout << endl;

    cout << "判断结论 : " << endl;
    //判断是否满足自反性
    Func1();
    //判断是否满足对称性
    Func2();
    //判断是否满足传递性
    Func3();
    return 0;
}

void Func1()   //判断是否满足自反性
{
    bool flag = true;
    for(int i = 1; i <= nnn; i++)
    {
        if(relation[i][i] != 1)
        {
            flag = false;
            break;
        }
    }
    if(flag == true)
    {
        cout << "满足自反性" << endl;
    }
    else
    {
        cout << "不满足自反性" << endl;
    }
}

void Func2()  //判断是否满足对称性
{
    bool flag = true;
    for(int i = 1; i <= nnn; i++)
    {
        for(int j = 1; j <=nnn; j++)
        {
            if(relation[i][j] != relation[j][i])
            {
                flag = false;
            }
        }
    }
    if(flag == true)
    {
        cout << "满足对称性" << endl;
    }
    else
    {
        cout << "不满足对称性" << endl;
    }
}

void Func3()  //判断是否满足传递性
{
    bool flag = true;
    for(int i = 1; i <= num - 1; i++)  //num表示关系个数
    {
        for(int j = 2; j <= num; j++)
        {
            if(arr[i][2] == arr[j][1])   //arr数组表示存储集合元素
            {
                int num1 = arr[i][1], num2 = arr[j][2];
                if(relation[num1][num2] != 1)
                {
                    flag = false;
                    break;
                }
            }
        }
        if(flag == false)
            break;
    }
    if(flag == true)
    {
        cout << "满足传递性" << endl;
    }
    else
    {
        cout << "不满足传递性" << endl;
    }
}

 
在 JDK 7 版本以上， Comparator 要满足自反性，传递性，对称性，不然 Arrays . sort ，
Collections . sort 会报 IllegalArgumentException 异常。
说明：
1 ） 自反性： x ， y 的比较结果和 y ， x 的比较结果相反。
2 ） 传递性： x > y , y > z ,则 x > z 。
3 ） 对称性： x = y ,则 x , z 比较结果和 y ， z 比较结果相同。
反例：下例中没有处理相等的情况，实际使用中可能会出现异常：
new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getId() > o2.getId() ? 1 : -1;
}
}
 
转载于:https://www.cnblogs.com/amos-s/p/6387439.html