功能：集合，包含新增，刪除，計算交集，並集，補集，是否為子集

using System;
using System.Collections;
using System.Collections.Generic;
public class CSet
{
    private Hashtable data;  //定義集合的散列表

    public CSet()
    {
        data = new Hashtable();  //定義散列表
    }

    //計算hash值
    private string Hash(Object item)
    {
        char[] chars;  //定義chars
        string s = item.ToString();  //將輸入的值轉換為字串
        int hashvalue = 0;
        chars = s.ToCharArray();  //將字串轉換我字元陣列
        for (int i = 0; i <= chars.GetUpperBound(0);i++)
        {
            hashvalue += (int) chars[i];
        }
        return hashvalue.ToString();  //轉化為字元
    }

    //向集合中新增資料
    public void Add(Object item)
    {
        if (!data.Contains(item))
        {
            data.Add(Hash(item),item);  //使用字串的asc和作為hash值來新增到雜湊報中

        }
    }

    //移除資料
    public void Remove(Object item)
    {
        data.Remove(Hash(item)); //首先計算hash值，並移除這個hash值的資料
    }

    //放回集合的大小
    public int Size()
    {
        return data.Count;
    }

    //計算並集
    public CSet Union(CSet aSet)
    {
        CSet tempSet=new CSet();  //定義最後的集合
        foreach (Object hashObject in data.Keys)
        {//將原來的集合的資料新增到新的集合中
            tempSet.Add(this.data[hashObject]);
        }

        foreach (Object hashObject in aSet.data.Keys)
        {
            if(!this.data.ContainsKey(hashObject))
                tempSet.Add(aSet.data[hashObject]);
     
        }
        return tempSet;  //返回這個集合

    }

    //計算交集
    public CSet Intersection(CSet aSet)
    {
        CSet tempSet=new CSet();  //最後返回的集合
        foreach(Object hashObject in data.Keys)
            if(aSet.data.Contains(hashObject))
                tempSet.Add(aSet.data[hashObject]);
        return tempSet;  //返回這個集合
    }

    //計算是否是子集
    public bool Subset(CSet aSet)
    {
        if (this.Size() > aSet.Size())
            return false;  //計算大小如果比後一個集合大返回假
        else
        {
            foreach (Object key in this.data.Keys)
            {
                if (!aSet.data.Contains(key))
                    return false;
            }
            
        }
        return true;
    }

    //計算差集合
    public CSet Difference(CSet aSet)
    {
        CSet tempSet=new CSet();
        foreach (Object hashObject in data.Keys)
         if(!aSet.data.Contains(hashObject))
             tempSet.Add(data[hashObject]);
        return tempSet;
    }

    public override string ToString()
    {
        string s = " ";
        foreach (Object key in data.Keys)
        {
            s += data[key] + " ";

        }
        return s;
    }
}

public class Test
{
    public static void Main()
    {
        CSet setA=new CSet();  //計算集合a和集合b
        CSet setB=new CSet();

        setA.Add("milk");
        setA.Add("eggs");
        setA.Add("bacon");
        setA.Add("cereal");
        setB.Add("bacon");
        setB.Add("eggs");
        setB.Add("bread");
        CSet setC=new CSet();
        setC = setA.Union(setB);
        Console.WriteLine();
        Console.WriteLine("A:"+setA.ToString());
        Console.WriteLine("B:"+setB.ToString());
        Console.WriteLine("C:"+setC.ToString());
    }
}