并查集类的c++封装，比较union_find algorithm四种实现方法之间的性能差别

问题描述：

在计算机科学中，并查集是一种树型的数据结构，其保持着用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（union-find algorithm）定义了两个操作用于此数据结构：

Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集；

Union：将两个子集合并成同一个集合；

实现并查集的关键是实现union-find algorithm, 本文根据常用的四种算法，实现了这个类，具体算法实现请参看维基百科；

制造测试数据集，测试几种方法之间性能的指标；

程序代码：

[cpp] view plaincopy

#ifndef _DISJOINT_SET_H_
#define _DISJOINT_SET_H_
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <time.h>
#include <math.h>
#include "windows.h"
enum DISJOINTWAY
{
COMMON_WAY,
COMPREE_WAY,
WEIGHT_WAY,
WEIGHT_COMPRESS_WAY
};
/*
* encapsulate the class of disjoint set
*
*/
#define MAXDISJOINTSET 0xffffff
class DisjointSet
{
public:
DisjointSet( int maxSize = MAXDISJOINTSET ):m_item(0), m_size(maxSize)
{
m_item = new int[maxSize];
for( int i = 0; i < m_size; i++ )
{
m_item[i] = i;
}
m_path = new int[maxSize];
memset( m_path, 1, sizeof(int)*maxSize );
}
~DisjointSet()
{
Clear();
}
/*
* find interface
*
*/
int Find( DISJOINTWAY way, int input )
{
assert( input < m_size );
switch( way )
{
case COMMON_WAY:
return ImplFindFirst( input );
case COMPREE_WAY:
return ImplFindSecond( input );
case WEIGHT_WAY:
return ImplFindWeight( input );
case WEIGHT_COMPRESS_WAY:
return ImplFindWeightCompree( input );
default:
return -1;
}
}
/*
* make union
*
*/
void Union( DISJOINTWAY way, int first, int second )
{
assert( first < m_size && second < m_size );
switch( way )
{
case COMMON_WAY:
ImplUnionFirst( first, second );
break;
case COMPREE_WAY:
ImplUnionSecond( first, second );
break;
case WEIGHT_WAY:
ImplUnionWeighted( first, second );
break;
case WEIGHT_COMPRESS_WAY:
ImplUnionCompree( first, second );
break;
default:
break;
}
}
/*
*
*
*/
void Clear()
{
delete [] m_item;
m_item = 0;
delete [] m_path;
m_path = 0;
m_size = 0;
}
protected:
int ImplFindFirst( int input )
{
assert( input < m_size );
return m_item[input];
}
int ImplFindSecond( int input )
{
int i = input;
for( ; i != m_item[i]; i = m_item[i] );
return i;
}
int ImplFindWeight( int input )
{
int i = input;
for( ; i != m_item[i]; i = m_item[i] );
return i;
}
int ImplFindWeightCompree( int input )
{
int i = input;
for( ; i != m_item[i]; i = m_item[i] )
m_item[i] = m_item[m_item[i]];
return i;
}
/*
*
*
*/
void ImplUnionFirst( int first, int second )
{
int x = m_item[first];
int y = m_item[second];
if( x != y )
{
m_item[first] = y;
}
for( int i = 0; i < m_size; i++ )
{
if( x == m_item[i] )
m_item[i] = y;
}
}
/*
*
*
*/
void ImplUnionSecond( int& first, int& second )
{
if( first != second )
{
m_item[first] = second;
}
}
/*
*
*
*/
void ImplUnionWeighted( int first, int second )
{
if( first != second )
{
if( m_path[first] < m_path[second] )
{
m_item[first] = second;
m_path[second] += m_path[first];
}
else
{
m_item[second] = first;
m_path[first] += m_path[second];
}
}
}
/*
*
*
*/
void ImplUnionCompree( int first, int second )
{
if( first != second )
{
if( m_path[first] < m_path[second] )
{
m_item[first] = second;
m_path[second] += m_path[first];
}
else
{
m_item[second] = first;
m_path[first] += m_path[second];
}
}
}
protected:
int* m_item;
int m_size;
int* m_path;
};
void TestDisjointSetSimple()
{
DisjointSet djoint;
int i = djoint.Find( COMMON_WAY, 1 );
int j = djoint.Find( COMMON_WAY, 3 );
if( i != j )
djoint.Union( COMMON_WAY, 1, 3 );
i = djoint.Find( COMMON_WAY, 2 );
j = djoint.Find( COMMON_WAY, 5 );
if( i != j )
djoint.Union( COMMON_WAY, i, j );
i = djoint.Find( COMMON_WAY, 2 );
j = djoint.Find( COMMON_WAY, 6 );
if( i != j )
djoint.Union( COMMON_WAY, i, j );
i = djoint.Find( COMMON_WAY, 6 );
j = djoint.Find( COMMON_WAY, 7 );
if( i != j )
djoint.Union( COMMON_WAY, i, j );
assert( djoint.Find( COMMON_WAY, 2 ) == djoint.Find( COMMON_WAY, 7 ) );
i = djoint.Find( COMMON_WAY, 1 );
j = djoint.Find( COMMON_WAY, 7 );
if( i != j )
djoint.Union( COMMON_WAY, i, j );
assert( djoint.Find( COMMON_WAY, 3 ) == djoint.Find( COMMON_WAY, 7 ) );
}
void TestDisjointSetComplex( DISJOINTWAY way, const char* str )
{
unsigned long start = GetTickCount();
DisjointSet djoint;
const int len = 1000000;
const int base = 60000;
int halfLen = len / 2;
srand( time(NULL) );
for( int i = 0; i < len; i++ )
{
int first = rand() % base;
int second = rand() % base;
if( i > halfLen )
{
first += base;
second += base;
}
if( first != second )
{
first = djoint.Find( way, first );
second = djoint.Find( way, second );
if( first != second )
djoint.Union( way, first, second );
assert( djoint.Find( way, first ) == djoint.Find( way, second ) );
}
}
unsigned long interval = GetTickCount() - start;
printf(" %s way consume time is %d \n", str, interval );
}
void TestSuiteDisjointSet()
{
TestDisjointSetSimple();
const char* str[] = {"common", "compress", "weight", "weight compress"};
for( int i = WEIGHT_COMPRESS_WAY; i >= 0; i--)
{
TestDisjointSetComplex((DISJOINTWAY)i, str[i] );
}
}
#endif

compile and run in visual studio 2005

下面图片是几种方法运行时间之比较，最直白方法的时间到现在还没输出，所以就没有显示：

并查集类的c++封装，比较union_find algorithm四种实现方法之间的性能差别相关推荐

美食类短视频如何定位？分享四种类型，选对适合的方向很重要
美食类短视频如何定位?分享四种类型,选对适合的方向很重要人人都是"干饭人",所以美食类短视频从来都是不会缺少粉丝的.但是这并不说明做美食类短视频的小伙伴们可以随心所欲的做内容,比 ...
经典算法-并查集、快速排序、字典序算法、二分搜索、牛顿开方法、求质数(筛选法)、编辑距离、滑动窗口、异或求重、长除法
目录并查集快速排序字典序算法二分搜索开根号-牛顿开方法求质数编辑距离滑动窗口异或求重长除法并查集并查集用于解决相同元素集合动态连接 ...
并查集问题 G: 极品飞车XX星有许多城市，城市之间通过一种奇怪的高速公路SARS(Super Air Roam Structure---超级空中漫游结构）进行交流，每条SARS都对行驶在上面的Fl
转载于https://www.cnblogs.com/liyinggang/p/5474341.html 负责解说题目描述 XX星有许多城市,城市之间通过一种奇怪的高速公路SARS(Super Ai ...
2020.1.30 封装和隐藏（四种访问权限修饰符）、this、JavaBean、继承、方法的重写
面对对象特征之一:封装和隐藏 Java中通过数据声明为私有的(private),再提供公共的(public)方法:getXxx()和setXxx()实现对属性的操作. 四种访问权限修饰符在同一个ja ...
四种Sandcastle方法生成c#.net帮助类帮助文档
阅读目录(Content) 方法一.Visual Studio新建documentation生成帮助文档一.下载二.安装三.设置五.生成方法二.cmd生成帮助文档方法三.Sandcastl ...
怎样判断java成员方法,【判断题】在Java中,针对类、成员方法和属性提供了四种访问级别,分别是private、static、protected和public...
参考答案如下判断不属于宋徽宗作品的是() 据美国媒体报道,中针美国 CNN电视台5月15日错将总统布什全国电视演讲前的一段失误连连的彩排内容实况播出.画面显示布什彩排时神情极不自信,中针与他在正式演 ...
java成员访问属性,在Java中，针对类、成员方法和属性提供了四种访问级别，分别是private、static、prot...
You have a file server that runs Windows Server 2008. A user restores a large file by using thePrevi ...
【模板】并查集两种路径压缩写法（类模板和函数模板）
并查集函数模板写法: #include <bits/stdc++.h> using namespace std; typedef long long ll; #define MAX_N 1 ...
POJ 并查集题目汇总 ——czyuan原创（转）
继续数据结构的复习,本次的专题是:并查集. 并查集,顾名思义,干的就是"并"和"查"两件事.很多与集合相关的操作都可以用并查集高效的解决. 两个操作代码: ...

并查集类的c++封装，比较union_find algorithm四种实现方法之间的性能差别

问题描述：

程序代码：

并查集类的c++封装，比较union_find algorithm四种实现方法之间的性能差别相关推荐

最新文章

热门文章