How to reduce complexity in multiple if-else algorithms?

Your naming of isLeftExist is not correct. The variable holds a list containing th number left. So its name should be listContainingLeft. The same applies to the isRightExist list.

Regarding the if-else construct: One clause is redundant (the second isRightExist) so you my either omit this or rewrite the conditions like this.

public void Union(int left, int right)
{
  var listContainingLeft = this.source.FirstOrDefault(o => o.Contains(left));
  var listContainingRight = this.source.FirstOrDefault(o => o.Contains(right));

  if (listContainingLeft == null)
    if (listContainingRight == null)
      AddBranch(left, right);
    else
      listContainingRight.Add(left);
  else if (listContainingRight == null)
    listContainingLeft.Add(right);
  else
    Combine(listContainingLeft, listContainingRight);
}

private void AddBranch(int left, int right)
{
  var hash = new HashSet<int>();
  hash.Add(left);
  hash.Add(right);
  this.source.Add(hash);
}

private void Combine(HashSet<int> isLeftExist, HashSet<int> isRightExist)
{
  this.source.Remove(isRightExist);
  foreach (var item in isRightExist)
  {
     isLeftExist.Add(item);
  }
}

Building on @alzaimar's answer:

You can unfold the conditionals with early return. The linear flow makes it slightly easier to follow.

if (listContainingLeft == null && listContainingRight == null)
{
    AddBranch(left, right);
    return;
}

if (listContainingLeft != null && listContainingRight != null)
{
    Combine(listContainingLeft, listContainingRight);
    return;
}

if (listContainingLeft != null)
{
    listContainingLeft.Add(right);
    return;
}

if (listContainingRight != null)
{
    listContainingRight.Add(left);
    return;
}

I find these practices helpful:

• Buy a licence of Resharper or something similar. It points out potential improvements ;-)
• Extract all conditions as variables and name them after their meaning.
• Check all positives first, then it's easier to understand the following ifs.

• As a bonus, I can remove the comment in the (initial) last branch

  public void Union(int left, int right)
  {
      var lefts = source.FirstOrDefault(o => o.Contains(left));
      var rights = source.FirstOrDefault(o => o.Contains(right));
  
      var foundRight = rights != null;
      var foundLeft = lefts != null;
  
      if (foundLeft && foundRight)
      {
          source.Remove(rights);
  
          foreach (var item in rights)
          {
              lefts.Add(item);
          }
      }
      else if (foundRight)
      {
          rights.Add(left);
      }
      else if (foundLeft)
      {
          lefts.Add(right);
      }
      else
      {
          var hash = new HashSet<int> {left, right};
          source.Add(hash);
      }
  }
  

Here is my code for Union method:

public class UnionFind
{
    private readonly List<HashSet<int>> source;

    public static UnionFind Create()
    {
        return new UnionFind();
    }

    private UnionFind()
    {
        this.source = new List<HashSet<int>>();
    }

    private readonly HashSet<int> selfConnectedSet = new HashSet<int>();

    private HashSet<int> AddSet() {
        var hash = new HashSet<int>();
        this.source.Add(hash);
        return hash;
    }

    public void Union(int left, int right)
    {
        if (left == right)
        {
            selfConnectedSet.Add(left);
        }
        else
        {
            var leftSet = this.source.FirstOrDefault(o => o.Contains(left));
            var rightSet = this.source.FirstOrDefault(o => o.Contains(right));
            if (leftSet != null && rightSet != null)
            {
                // found left and right
                this.source.Remove(rightSet);
                leftSet.UnionWith(rightSet);
            }
            else
            {
                var hash = leftSet ?? (rightSet ?? AddSet());
                hash.Add(left);
                hash.Add(right);
            }
        }
    }

    public bool AreConnected(int left, int right)
    {
        if (left == right)
        {
            return selfConnectedSet.Contains(left);
        }
        else
        {
            return this.source
                .Any(o => o.Contains(left) && o.Contains(right));
        }
    }
}

Few points for my refactoring

• is should be used for boolean variable only, as some already mentioned earlier.
• Except the first if, the logic just to find the target HashSet to add the values to, so I normalised that by using conditional operator. We can add left and right no matter it's leftSet or rightSet because it's a HashSet so the value could never be duplicated.
• Same value for left and right has to be supported according to the unit test, so I add a separated HashSet to keep self-connected number