zoukankan      html  css  js  c++  java
  • disjoint set

    MAKE-SET.x/ creates a new set whose only member (and thus representative)

    is x. Since the sets are disjoint, we require that x not already be in some other

    set.

    UNION.x; y/ unites the dynamic sets that contain x and y, say Sx and Sy, into a

    new set that is the union of these two sets. We assume that the two sets are disjoint

    prior to the operation. The representative of the resulting set is any member

    of Sx [ Sy, although many implementations of UNION specifically choose the

    representative of either Sx or Sy as the new representative. Since we require

    the sets in the collection to be disjoint, conceptually we destroy sets Sx and Sy,

    removing them from the collection S. In practice, we often absorb the elements

    of one of the sets into the other set.

    FIND-SET.x/ returns a pointer to the representative of the (unique) set containing

    x.

    linklist implement

     

    In the worst case, the above implementation of the UNION procedure requires an

    average of ‚.n/ time per call because we may be appending a longer list onto

    a shorter list; we must update the pointer to the set object for each member of

    the longer list. Suppose instead that each list also includes the length of the list

    (which we can easily maintain) and that we always append the shorter list onto the

    longer, breaking ties arbitrarily. With this simple weighted-union heuristic, a single

    UNION operation can still take _.n/ time if both sets have _.n/ members. As

    the following theorem shows, however, a sequence of m MAKE-SET, UNION, and

    FIND-SET operations, n of which are MAKE-SET operations, takes O.m C n lg n/

    time.

    Tree implement

     

    Heuristics to improve the running time

    So far, we have not improved on the linked-list implementation. A sequence of

    n 1 UNION operations may create a tree that is just a linear chain of n nodes. By

    using two heuristics, however, we can achieve a running time that is almost linear

    in the total number of operations m.

    The first heuristic, union by rank, is similar to the weighted-union heuristic we

    used with the linked-list representation. The obvious approach would be to make

    the root of the tree with fewer nodes point to the root of the tree with more nodes.

    Rather than explicitly keeping track of the size of the subtree rooted at each node,

    we shall use an approach that eases the analysis. For each node, we maintain a

    rank, which is an upper bound on the height of the node. In union by rank, we

    make the root with smaller rank point to the root with larger rank during a UNION

    operation.

    The second heuristic, path compression, is also quite simple and highly effective.

    As shown in Figure 21.5, we use it during FIND-SET operations to make each

    node on the find path point directly to the root. Path compression does not change

    any ranks(more nodes linked to the root will cause much possibility to find it).

    When we use both union by rank and path compression, the worst-case running
    time is O.m ˛.n//, where ˛.n/ is a very slowly growing function, which we define
    in Section 21.4. In any conceivable application of a disjoint-set data structure,
    ˛.n/  4; thus, we can view the running time as linear in m in all practical situations.
    Strictly speaking, however, it is superlinear. In Section 21.4, we prove this
    upper bound.

     1 package disjoint_sets;
     2 // there have two ways,one is the linkedlist,the other is the tree,use the tree here
     3 public class disjoint_set {
     4     private static class Node{
     5         private Node p;
     6         private int rank;
     7         private String name;
     8         public Node(String na){
     9             p = this; rank = 0;name = na;
    10         }
    11     }
    12     public static void union(Node x,Node y){
    13         link(findset(x),findset(y));
    14     }
    15     public static void link(Node x,Node y){
    16         if(x.rank > y.rank){
    17             y.p = x;
    18         }
    19         else if(y.rank > x.rank){
    20             x.p = y;
    21         }
    22         else{
    23             y.p = x;
    24             x.rank = x.rank + 1;
    25         }
    26     }
    27     public static Node findset(Node x){
    28         if(x != x.p){
    29             x.p = findset(x.p);  //path compression
    30         }
    31         return x.p;
    32     }
    33     public static void print(Node x){
    34         
    35             System.out.println(x.name);
    36             if(x != x.p){
    37             x = x.p;
    38             print(x);
    39             }
    40             return;
    41     }
    42     public static void main(String[] args) {
    43         Node a = new Node("a");
    44         Node b = new Node("b");
    45         Node c = new Node("c");
    46         Node d = new Node("d");
    47         union(a,b);
    48         union(b,c);
    49         union(a,d);
    50         print(d);
    51         
    52         
    53     }
    54 
    55 }
  • 相关阅读:
    代码改变世界,随手写了点代码解决了一个小学生级别的作业题,编程要从娃娃抓起
    智和信通实现信创国产化适配 助力信创生态智能运维体系建设
    智和信通赋能国产信创 建设IT智能监控运维体系
    北京智和信通智慧档案馆网络监控运维解决方案
    图书馆网络运维监控安全态势感知方案-智和信通
    广播电视网络运维安全态势感知解决方案
    北京智和信通荣膺2020智能运维星耀榜最具影响力企业
    直播新规出台!如何用技术管住乱打赏的「熊孩子」?
    是什么让你在赛博空间更好看?
    Niu Talk 数据科学系列论坛:明晚,我们聊聊大数据与开源
  • 原文地址:https://www.cnblogs.com/wujunde/p/7126933.html
Copyright © 2011-2022 走看看