Java 编写 并查集 算法—— [针对自己最新确认的代码编写规范]

日期：2020.03.24

博客期：168

星期二

 

　　【博客前言】

　　　　众所周不知啊，我在上大一的时候，进入了我们学校的ACM-算法竞赛协会，当时学习的成员还不多，但是学习氛围很好，我上的第一堂课就是关于并查集的使用，我就用当时才学完的 C语言实现了。我对于这个算法可以说是记忆犹新吧！这个例子我学了C++以后也实现过，那么今天就轮到我使用 Java 在设计模式和最近新确定好的Java代码规范的基础下再来实现这个“并查集”算法！

　　【代码功能】

　　　　并查集的适用场景：在分散的许多结点中，人为的添加一些点到点的线，使其构成多条树（每条树对应一个分组），可以判定两个结点是否有线路可以流通、可以人为地将两个分组连接起来。

       【实装代码】

　　　　com.bcj 包：

　　　　　　数字并查集类：

package com.bcj;

import java.util.ArrayList;
import java.util.List;

// Readme:
//
//    English Name: UnionCheckingSet Class
//    Chinese Name: 数字并查集类
//
// Writen by NS-Studio in 2020-03-24 17:41
//
public class UnionCheckingSet{
    //----------------------<成员属性>----------------------//
    //
    //---[基本类型]
    
    //最大长度
    private int max_len;
    
    //父节点集合
    private List <Integer> self_list;
    
    //父节点连线权值集合
    private List <Integer> par_list;
    
    //----------------------<成员方法>----------------------//
    //
    //---[配置方法]
    
    //初始化
    private void init() {
        this.reset();
    }
    
    //重新初始化
    public void reset() {
        // 初始化 长度
        this.self_list = new ArrayList <Integer> ();
        this.par_list = new ArrayList <Integer> ();
        
        // 给 数据 加上 1 对 1 的索引
        for(int i=0;i<this.max_len;++i)
        {
            this.self_list.add(i);
            this.par_list.add(0);
        }
    }
    
    //
    //---[实用方法]
    
    //查找根节点
    public int find_root_code(int index) {
        // 我们 获取 它的父节点
        int tmp = this.self_list.get(index);
        
        // 如果 父节点 是 它本身，说明 它就是 根节点
        if(index == tmp)
            return index;
        // 否则 它的根节点 就是 它的 父节点的 根节点
        else
            return this.find_root_code(tmp);
    }
    
    //两个结点是否相互连接
    public boolean is_linked(int index_1,int index_2) {
        // 如果 两个结点 所对应的 根节点 相同，那么 我们认为 它们是在连在一起的
        return this.find_root_code(index_1) == this.find_root_code(index_2);
    }
    
    //两个结点相互连接
    public void unite_code(int index_1,int index_2) {
        // 将 结点 由 它们各自的 根节点 代替
        index_1 = this.find_root_code(index_1);
        index_2 = this.find_root_code(index_2);
        
        // 如果 这两个结点 不在同一组内， 则将 根节点 相连
        if(index_1!=index_2)
        {
            // 准备 权值信息 储存器
            int par_1,par_2;
            
            // 储存器 赋值
            par_1 = this.par_list.get(index_1);
            par_2 = this.par_list.get(index_2);
            
            // 储存器值 高的 一方 作为 根节点
            if(par_1 < par_2)
            {
                this.self_list.set(index_1,index_2);
            }
            // 如果 储存器值 相等 ，则 需要 轻微 调高 作为 根结点的 储存器值（不等不强制）
            else
            {
                this.self_list.set(index_2,index_1);
                this.par_list.set(index_1, par_1 + 1);
            }
        }
    }
    
    //
    //---[构造方法]
    
    //无参构造 : 参数 max_len 默认值为 1010
    public UnionCheckingSet() {
        super();
        // 无参的 设置默认值
        this.max_len = 1010;
        this.init();
    }
    
    //单参构造
    public UnionCheckingSet(int max_len) {
        super();
        // 单参的 设置 max_len 值
        this.max_len = max_len;
        this.init();
    }
    
    //
    //---[测试方法]
    
    // -----
    // 主方法
    //
    //        测试用例 :
    //            分成三组——(1,3,4,6),(2,7),(5)
    //            测试 1，3 和 2，5 分别 是否处在同一组
    public static void main(String[] args) {
        // 实例化 一个 并查集 对象
        UnionCheckingSet ucs = new UnionCheckingSet();
        
        // 定义 一个 变量 ：用于 存储 boolean 数据
        boolean is = false;
        
        // 连接对象 分组
        //         ---[A组]
        ucs.unite_code(1,3);
        ucs.unite_code(3,4);
        ucs.unite_code(1,6);
        //         ---[B组]
        ucs.unite_code(2,7);
        
        // 测试 1，3 是否在同一组
        //         ---[改数值]
        is = ucs.is_linked(1,3);
        //         ---[数据查看]
        System.out.println(is);
        
        // 测试 2，5 是否在同一组
        //         ---[改数值]
        is = ucs.is_linked(2,5);
        //         ---[数据查看]
        System.out.println(is);
    }
}

　　　　　　并查集类：

package com.bcj;

import java.util.ArrayList;
import java.util.List;

// Readme:
//
//    English Name: MapCheckingSet Class
//    Chinese Name: 并查集类
//
// Writen by NS-Studio in 2020-03-24 18:35
//
public class MapCheckingSet <T>{
    //----------------------<成员属性>----------------------//
    //
    //---[基本类型]
    
    //最大长度
    private int max_len;
    
    //数据列表
    private List <T> map_data;
    
    //并查集
    private UnionCheckingSet ucs;
    
    //----------------------<成员方法>----------------------//
    //
    //---[配置方法]
    
    //初始化
    private void init() {
        this.reset();
    }
    
    //重新初始化
    public void reset() {
        // 初始化 长度
        this.ucs = new UnionCheckingSet(this.max_len);
        
        // 初始化 数据表
        this.map_data = new ArrayList<T>();
    }
    
    //
    //---[实用方法]
    
    //添加结点
    public void add_code(T code_been_added) {
        // 如果 表中 没有，就 加进去
        if(!this.map_data.contains(code_been_added))
            this.map_data.add(code_been_added);
    }
    
    //查找结点的 index
    private int index_of_list(T code_been_selected) {
        // 位置 信息 索引
        return this.map_data.indexOf(code_been_selected);
    }
    
    //两个结点是否相互连接
    public boolean is_linked(T code_1,T code_2) {
        // this.index_of_list( index ) 是 list 中的索引地址 
        int index_1 = this.index_of_list(code_1);
        int index_2 = this.index_of_list(code_2);
        
        // 根据 实际的值 调用 数值型 并查集
        return this.ucs.is_linked(index_1, index_2);
    }
    
    //两个结点相互连接
    public void unite_code(T code_1,T code_2) {
        // this.index_of_list( index ) 是 list 中的索引地址 
        int index_1 = this.index_of_list(code_1);
        int index_2 = this.index_of_list(code_2);
        
        // 根据 实际的值 调用 数值型 并查集
        this.ucs.unite_code(index_1, index_2);
    }
    
    //
    //---[构造方法]
    
    //无参构造 : 参数 max_len 默认值为 1010
    public MapCheckingSet() {
        super();
        // 无参的 设置默认值
        this.max_len = 1010;
        this.init();
    }
    
    //单参构造
    public MapCheckingSet(int max_len) {
        super();
        // 单参的 设置 max_len 值
        this.max_len = max_len;
        this.init();
    }
    
    //
    //---[测试方法]
    
    // -----
    // 主方法
    //
    //        测试用例 :
    //            分成三组——(“李法”,“刘汉”,“王旺教”),(“孟兴”,“陶保”),(“田冒”,“赵埔彤”)
    //            测试 “李法”，“刘汉” 和 “孟兴”，“田冒” 分别 是否处在同一组
    public static void main(String[] args) {
        // 实例化 一个 并查集 对象
        MapCheckingSet <String> mcs = new MapCheckingSet<String>();
        
        // 定义 一个 变量 ：用于 存储 boolean 数据
        boolean is = false;
        
        //加入数据
        mcs.add_code("李法");
        mcs.add_code("刘汉");
        mcs.add_code("王旺教");
        mcs.add_code("孟兴");
        mcs.add_code("陶保");
        mcs.add_code("田冒");
        mcs.add_code("赵埔彤");
        
        // 连接对象 分组
        //         ---[A组]
        mcs.unite_code("李法","刘汉");
        mcs.unite_code("刘汉","王旺教");
        //         ---[B组]
        mcs.unite_code("孟兴","陶保");
        //         ---[C组]
        mcs.unite_code("田冒","赵埔彤");
        
        // 测试 “李法”，“刘汉” 是否在同一组
        //         ---[改数值]
        is = mcs.is_linked("李法","刘汉");
        //         ---[数据查看]
        System.out.println(is);
        
        // 测试 “孟兴”，“田冒” 是否在同一组
        //         ---[改数值]
        is = mcs.is_linked("孟兴","田冒");
        //         ---[数据查看]
        System.out.println(is);
    }
}

　　【项目结构图】

　　【类图】

 　　　　目前就两个类，实际上没什么看点

　　【使用到的设计模式】

 　　　　1、模板方法模式：并查集的算法部分是模板方法（可以套用）

　　　　 2、适配器模式：这次还是隐式的对象适配器模式，把 UnionChckingSet 作为 对象成员 ，数据表成员 是伪子类！

 　　【测试】

　　　　由于代码中测试信息较为详细，博主在这里不过多摄入。