数据结构（四）树---集合的表示及查找（并查集）

一：集合运算

交，并，补，差，判断一个元素是否属于某一集合

并查集将在判断连通性和是否成环上面起到至关重要的作用

二：并查集

（一）集合并

并集间有一元素相连

（二）查某元素属于什么集合

可用树来表示集合，每个结点代表一个集合元素

　　　　S1={1,2,4,7}　　　　　　　　　　　　S2={3,5,8}　　　　　　　　　　S3={6,9,10}

我们可以使用双亲表示法来判断某个结点的根结点，从而判断是否是使用某个集合

#define MAX_TREE_SIZE 100

typedef int TElemType;

typedef struct PTNode    //结点结构
{
    TElemType data;    //结点数据
    int parent;        //双亲位置
}PTNode;

typedef struct //树结构
{
    PTNode nodes[MAX_TREE_SIZE];    //结点数组
    int r, n;    //r是根位置，n是结点数
}PTree;

三：查找（根）的实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

typedef int TElemType;

typedef struct _PTNode
{
    int data;
    int parent;
}PTNode;

typedef struct
{
    PTNode set[MAX_SIZE];
    int n;
}SetType;

结构定义

void CreateSets(SetType *Set)
{
    //输入数据，使第一个数变为根节点
    int d=0,parent=0;
    int i = 0;
    Set->n = 0;
    printf("input number(data,parent) to create set Number(<-1,-1> to exit):
");
    while (1)
    {
        scanf("%d,%d", &d,&parent);
        if (d == -1&&parent==-1)
            break;
        Set->set[i].data = d;
        Set->set[i].parent = parent;
        Set->n++;
        i++;
    }
    printf("create set finish
");
}

创建集合

void ShowSet(SetType s)
{
    int i;
    for (i = 0; i < s.n; i++)
        printf("%d %d %d
", i, s.set[i].data, s.set[i].parent);
}

显示集合数据

int Find(SetType s, TElemType e)
{
    int i;
    for (i = 0; i < s.n&&e != s.set[i].data; i++)
        ;
    if (i >= s.n)
        return -1;
    for (; s.set[i].parent >= 0; i = s.set[i].parent)
        ;
    return i;
}

int main()
{
    SetType set;
    TElemType n;
    int root;
    CreateSets(&set);
    ShowSet(set);
    printf("input number to find root:
");
    scanf("%d", &n);
    root=Find(set, n);
    printf("Finf Root in %d
", root);
    system("pause");
    return 0;
}

在下面创建了两个集合，我们判断其中一个数是属于哪个集合

四：并运算

（一）步骤

1.找到x1,x2两个元素根节点
2.将其中一个根添加到另一个树下面

（二）改进

用小树合入大数，尽可能将新合并的树的高度变小，提高查找效率，如果树太高，find效率会变低

1.大树合入小树：我们对于新合并的数据查找根的效率会很低

2.小树合入大树：效率并未降低多少

（三）问题

树高我们应该如何获取？是在每次合并前去计算一遍吗？似乎计算量还不小。那我们应该如何做？
想到根节点了吗？原来是存放-1的，我们现在将其数据存放为"-高",这样获取高度将变得十分方便

（四）代码实现

1.修改代码，在创建集合后面，更新根节点的树高度

void CreateSets(SetType *Set)
{
    //输入数据，使第一个数变为根节点
    int d=0,parent=0;
    int j,i = 0;
    int min,high;
    Set->n = 0;
    printf("input number(data,parent) to create set Number(<-1,-1> to exit):
");
    while (1)
    {
        scanf("%d,%d", &d,&parent);
        if (d == -1&&parent==-1)
            break;
        Set->set[i].data = d;
        Set->set[i].parent = parent;
        Set->n++;
        i++;
    }

    //更新每个根节点的数据
    for (i = Set->n; i >= 0;i--)
    {
        j = i;
        high = 1;
        for (; Set->set[j].parent >= 0; j = Set->set[j].parent)
            high++;
        if (-high<Set->set[j].parent)
            Set->set[j].parent = -high;
    }

    printf("create set finish
");
}

2.根据高度实现合并操作

void Union(SetType* s, SetName Root1, SetName Root2)
{
    if (s->set[Root1].parent<s->set[Root2].parent)//由于高度存放是负数，所以我们比较大小是不一样的
    {
        //说明Root1高
        s->set[Root2].parent = Root1;
    }
    else if (s->set[Root1].parent == s->set[Root2].parent)
    {
        //随便合并，不过高度加一
        s->set[Root2].parent = Root1;
        s->set[Root1].parent -= 1;
    }
    else
    {
        //说明Root2高
        s->set[Root1].parent = Root2;
    }
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

typedef int TElemType;
typedef int SetName;    //默认根节点下标作为集合名称

typedef struct _PTNode
{
    int data;
    int parent;
}PTNode;

typedef struct
{
    PTNode set[MAX_SIZE];
    int n;
}SetType;


void CreateSets(SetType *Set)
{
    //输入数据，使第一个数变为根节点
    int d=0,parent=0;
    int j,i = 0;
    int min,high;
    Set->n = 0;
    printf("input number(data,parent) to create set Number(<-1,-1> to exit):
");
    while (1)
    {
        scanf("%d,%d", &d,&parent);
        if (d == -1&&parent==-1)
            break;
        Set->set[i].data = d;
        Set->set[i].parent = parent;
        Set->n++;
        i++;
    }

    //更新每个根节点的数据
    for (i = Set->n; i >= 0;i--)
    {
        j = i;
        high = 1;
        for (; Set->set[j].parent >= 0; j = Set->set[j].parent)
            high++;
        if (-high<Set->set[j].parent)
            Set->set[j].parent = -high;
    }

    printf("create set finish
");
}

void Union(SetType* s, SetName Root1, SetName Root2)
{
    if (s->set[Root1].parent<s->set[Root2].parent)//由于高度存放是负数，所以我们比较大小是不一样的
    {
        //说明Root1高
        s->set[Root2].parent = Root1;
    }
    else if (s->set[Root1].parent == s->set[Root2].parent)
    {
        //随便合并，不过高度加一
        s->set[Root2].parent = Root1;
        s->set[Root1].parent -= 1;
    }
    else
    {
        //说明Root2高
        s->set[Root1].parent = Root2;
    }
}

int Find(SetType s, TElemType e)
{
    int i;
    for (i = 0; i < s.n&&e != s.set[i].data; i++)
        ;
    if (i >= s.n)
        return -1;
    for (; s.set[i].parent >= 0; i = s.set[i].parent)
        ;
    return i;
}

void ShowSet(SetType s)
{
    int i;
    for (i = 0; i < s.n; i++)
        printf("%d %d %d
", i, s.set[i].data, s.set[i].parent);
}

int main()
{
    SetType set;
    TElemType n;
    int root;
    CreateSets(&set);
    ShowSet(set);
    printf("input number to find root:
");
    scanf("%d", &n);
    root=Find(set, n);
    printf("Finf Root in %d
", root);
    printf("Union root1 and root2:
");
    Union(&set, Find(set, 5), Find(set, 9));
    ShowSet(set);
    printf("Union root1 and root2 finished
");
    system("pause");
    return 0;
}

全部代码

五：实例一：检测网络是否连通

局域网中有5台主机，我们要检测这五台主机之间是否联网，并实现实时连接和检测

C代表检测，I代表连接
C 3 2代表检测3,2号两台主机是否联网
I 3 2代表将3,2两台主机连接
C 1 5
I 4 5
I 2 4
C 3 5
S表示结束

实现方法和上面并查集相似，只是调用方法不一样而已

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

typedef int TElemType;
typedef int SetName;    //默认根节点下标作为集合名称

typedef struct _PTNode
{
    int data;
    int parent;
}PTNode;

typedef struct
{
    PTNode set[MAX_SIZE];
    int n;
}SetType;


void CreateSets(SetType *Set)
{
    //输入数据，使第一个数变为根节点
    int d=0,parent=0;
    int i = 0;
    Set->n = 0;
    printf("input number of hosts to operate:
");
    scanf("%d", &d);
    while (d)
    {
        Set->set[i].data = i + 1;
        Set->set[i].parent = -1;
        Set->n++;
        i++;
        d--;
    }
    //由于是初始n台独立的主机，所以我们不需要去初始其高

    printf("create hosts finish
");
}

void Union(SetType* s, SetName Root1, SetName Root2)
{
    if (s->set[Root1].parent<s->set[Root2].parent)//由于高度存放是负数，所以我们比较大小是不一样的
    {
        //说明Root1高
        s->set[Root2].parent = Root1;
    }
    else if (s->set[Root1].parent == s->set[Root2].parent)
    {
        //随便合并，不过高度加一
        s->set[Root2].parent = Root1;
        s->set[Root1].parent -= 1;
    }
    else
    {
        //说明Root2高
        s->set[Root1].parent = Root2;
    }
}

int Find(SetType s, TElemType e)
{
    int i;
    for (i = 0; i < s.n&&e != s.set[i].data; i++)
        ;
    if (i >= s.n)
        return -1;
    for (; s.set[i].parent >= 0; i = s.set[i].parent)
        ;
    return i;
}

void ShowSet(SetType s)
{
    int i;
    for (i = 0; i < s.n; i++)
        printf("%d %d %d
", i, s.set[i].data, s.set[i].parent);
}

void OperateNetwork(SetType *set)
{
    TElemType n;
    int host1, host2;
    char op;
    CreateSets(set);
    ShowSet(*set);
    while (1)
    {
        scanf("%c %d %d", &op, &host1, &host2);
        switch (op)
        {
        case 'C':
            if (Find(*set, host1) != Find(*set, host2))
                printf("No
");
            else
                printf("Yes
");
            break;
        case 'I':
            Union(set, Find(*set, host1), Find(*set, host2));
            break;
        case 'S':
            return;
        default:
            break;
        }
    }
}

void CheckNetWork(SetType s)
{
    int i,n=0;
    for (i = 0; i < s.n; i++)
        if (s.set[i].parent < 0)
            n++;
    if (n == 1)
        printf("The network is connection
");
    else
        printf("There are %d components
", n);
}

int main()
{
    SetType set;

    OperateNetwork(&set);
    printf("CheckNetwork Finished
");
    ShowSet(set);
    CheckNetWork(set);
    system("pause");
    return 0;
}

全部代码

六：实例二:在克鲁斯卡尔算法中判断一棵生成树中若是加入一条边是否形成回路

问：我们现在连接边v4-v2是否形成回路？如何判断？我们若是连接v4-v6是否还是一棵树？

解决思路：

使用并查集

我们通过判断我们要加入的边的两个顶点是否在同一集合来决定是否生成环，若是不在一个集合，我们连接后，依旧是一个生成树，但是如果在一个集合中，连接两顶点，一定是形成回路

实现代码基本和上面是一致的，不再赘述

1.将各个结点的parent置为-1
2.开始连接各个树，使用并操作
3.在连接的同时去判断连接的那条边的两个顶点对于的树的根对应的下标是不是同一位置，若是一个位置，就会生成环，不是同一个根，我们就可以正常连接

相关阅读:
Dubbo的使用入门
 Centos7安装Tomcat并部署DubboAdmin的War包并配置自动启动
 JPA中自动使用@Table(name = "userTab")后自动将表名、列名添加了下划线的问题
 JAVA和C#检测IP地址段是否交叉和获取地址段IP列表的方法
 MySQL中的insert ignore into, replace into用法总结
 SpringBootWEB项目和非Web项目的全局异常捕获
 SpringBoot中配置起动时的数据库初始化角本
 树莓派中编译Opencv3.4.1和OpenCVSharp库
 树莓派简单摄像头录像并保存视频文件
 树莓派中编译OpenCV3.4.1和OpenCvSharp
原文地址：https://www.cnblogs.com/ssyfj/p/9490764.html

数据结构（四）树---集合的表示及查找（并查集）

一：集合运算

二：并查集

（一）集合并

（二）查某元素属于什么集合

S1={1,2,4,7} S2={3,5,8} S3={6,9,10}

三：查找（根）的实现

四：并运算

（一）步骤

（二）改进

（三）问题

（四）代码实现

1.修改代码，在创建集合后面，更新根节点的树高度

2.根据高度实现合并操作

五：实例一：检测网络是否连通

六：实例二:在克鲁斯卡尔算法中判断一棵生成树中若是加入一条边是否形成回路

解决思路：

实现代码基本和上面是一致的，不再赘述

　　　　S1={1,2,4,7}　　　　　　　　　　　　S2={3,5,8}　　　　　　　　　　S3={6,9,10}