本文內容：
1、集合是什麼？
2、集合的操作集。
3、集合的 C 實現。
總表：《資料結構？》
工程程式碼 Github: Data_Structures_C_Implemention -- Set
預備知識 資料結構：連結串列
1、集合是什麼？
集合，是由一堆無序的、相關聯的，且不重複的記憶體結構【數學中稱為元素】組成的組合；集合：
1、集合在數學中的表示， S = {1, 5 , 4};
2、沒有元素的集合稱為空集；
3、包含所有可能元素的集合稱為全域，如：四位數字密碼的集合，全域就是[0000 －－ 9999] (10 * 10 * 10 * 10) 種可能所有的資料；
4、兩個集合的元素完全相同，稱這兩個集合相等；
5、集合1中所有的元素在集合2中均有【它們不相等】，則集合1 是集合2 的子集；
2、集合的操作集。
集合操作有插入、刪除、交集、並集、差集；交集、並集、差集圖示：
解析：
1、集合交集，指兩個集合中相同的元素組合成的集合；
2、集合並集，指兩個集合所有不相同的元素組成的集合；
3、集合差集，指兩個 集合除相同元素外剩下元素的集合，分兩種情況：Sd1 = S1 - S2; Sd2 = S2 - S1; S1 與 S2 中相同的元素集記為 Si，前者 Sd1 是 S1 與 Si 的交集，後者 Sd2 是 S2 與 Si 的交集；
集合操作集圖示：
3、集合的 C 實現。
這裡直接使用單連結串列來實現集合的所有操作！
typedef List Set;
Set 就是單連結串列；
實現圖：
集合的操作集：
/* Set Create */
Set Set_Create(MatchFunc mat, DestroyFunc des); // 建立
void Set_Init(Set set, MatchFunc mat, DestroyFunc des); // 初始化
void Set_Destroy(Set set); // 銷燬
/* Set Operations */
_BOOL Set_Insert(Set set, ElementTypePrt x); // 插入
_BOOL Set_Remove(Set set, ElementTypePrtPrt data); // 刪除
_BOOL Set_Union(Set uSet, const Set set1, const Set set2); // 並集
_BOOL Set_Intersection(Set iSet, const Set set1, const Set set2); // 交集
_BOOL Set_Difference(Set dSet, const Set set1, const Set set2); // 差集
_BOOL Set_IsMember(const Set set, const ElementTypePrt data); // 是否包含元素
_BOOL Set_IsSubset(const Set subSet, const Set totalSet); // 是否是集合的子集
_BOOL Set_IsEqual(const Set set1, const Set set2); // 集合是否相等
複製程式碼集合的建立與銷燬：
建立，與單連結串列的唯一不同就是，增加了 MatchFunc 參量，它用於集合元素的匹配；
Set Set_Create(MatchFunc mat, DestroyFunc des) {
Set set = List_Create(des);
set->matchFunc = mat;
return set;
}
複製程式碼初始化，與單連結串列的唯一不同就是，增加了 MatchFunc 參量，它用於集合元素的匹配；
void Set_Init(Set set, MatchFunc mat, DestroyFunc des) {
List_Init(set, des);
set->matchFunc = mat;
}
複製程式碼銷燬，與單連結串列的一致；
void Set_Destroy(Set set) { List_Destroy(set); }
複製程式碼集合的插入與刪除：
插入，直接使用單連結串列的插入方法，只是因為集合中元素本是無序的，所以為了方便直接在鏈尾處插入新的元素；
_BOOL Set_Insert(Set set, ElementTypePrt x) {
if ( ! Set_IsEmpty(set) && Set_IsMember(set, x)) {
printf("ERROR: Duplicates Member !");
return LINKEDLIST_FALSE;
}
return List_Insert(set, List_Tail(set), x);
}
複製程式碼解析，集合中的元素雖說無序但不能重複，所以在插入新元素前要先判斷集合是是否已經有該元素，而這個判斷由 Set_IsMember(set, x) 函式完成，它的原型是，
_BOOL Set_IsMember(const Set set, const ElementTypePrt data) {
return (List_Find(set, set->matchFunc, data) == NULL ? LINKEDLIST_FALSE :
LINKEDLIST_TRUE);
}
複製程式碼它的原理就是，遍歷單連結串列看是否能匹配到當前元素；
刪除，與單連結串列的做法是一樣，要先通過要刪除的節點，找到前面的節點，再進行刪除連結串列的操作；
_BOOL Set_Remove(Set set, ElementTypePrtPrt data) {
if (Set_IsEmpty(set)) { printf("ERROR: Empty Set !"); return LINKEDLIST_FALSE;}
ListNode setRemove = List_FindPrevious(set, set->matchFunc, *data);
if (setRemove->next == NULL) { return LINKEDLIST_FALSE; }
return List_Remove(set, setRemove, data);
}
複製程式碼- 集合的交集：
_BOOL Set_Intersection(Set iSet, const Set set1, const Set set2) {
if (iSet == NULL || set1 == NULL || set2 == NULL) {
printf("ERROR: Bad Set !"); return LINKEDLIST_FALSE;
}
if (iSet->matchFunc == NULL) { Set_Init(iSet, set1->matchFunc, set1->destroyFunc); }
ListNode node = NULL;
ElementTypePrt data;
for (node = List_Head(set1); node != NULL; node = List_NodeNext(node)) {
data = List_NodeData(node);
if (Set_IsMember(set2, data)) {
if ( ! List_Insert(iSet, List_Tail(iSet), data) ) {
List_Destroy(iSet); return LINKEDLIST_FALSE;
}
}
}
return LINKEDLIST_TRUE;
}
複製程式碼解析，交集的意思就是兩個集合是否有相同的元素，若有則把它們做成一個新的集合，而它就是兩個集合的交集;
交集的圖示，
// 對應的核心程式碼
for (node = List_Head(set1); node != NULL; node = List_NodeNext(node)) {
data = List_NodeData(node);
if (Set_IsMember(set2, data)) {
if ( ! List_Insert(iSet, List_Tail(iSet), data) ) {
List_Destroy(iSet); return LINKEDLIST_FALSE;
}
}
}
複製程式碼其實就是一個 For 迴圈，不斷地進行判斷；
- 集合的並集：
_BOOL Set_Union(Set uSet, const Set set1, const Set set2) {
if (uSet == NULL || set1 == NULL || set2 == NULL) {
printf("ERROR: Bad Set !"); return LINKEDLIST_FALSE;
}
if (uSet->matchFunc == NULL) { Set_Init(uSet, set1->matchFunc, set1->destroyFunc); }
ListNode node = NULL;
ElementTypePrt data;
for (node = List_Head(set1); node != NULL; node = List_NodeNext(node)) {
data = List_NodeData(node);
if ( ! List_Insert(uSet, List_Tail(uSet), data) ) {
List_Destroy(uSet); return LINKEDLIST_FALSE;
}
}
for (node = List_Head(set2); node != NULL; node = List_NodeNext(node)) {
data = List_NodeData(node);
if (Set_IsMember(uSet, data)) { continue; }
if ( ! List_Insert(uSet, List_Tail(uSet), data) ) {
List_Destroy(uSet); return LINKEDLIST_FALSE;
}
}
return LINKEDLIST_TRUE;
}
複製程式碼解析，並集圖示，
// 對應的核心程式碼
for (node = List_Head(set1); node != NULL; node = List_NodeNext(node)) {
data = List_NodeData(node);
if ( ! List_Insert(uSet, List_Tail(uSet), data) ) {
List_Destroy(uSet); return LINKEDLIST_FALSE;
}
}
for (node = List_Head(set2); node != NULL; node = List_NodeNext(node)) {
data = List_NodeData(node);
if (Set_IsMember(uSet, data)) { continue; }
if ( ! List_Insert(uSet, List_Tail(uSet), data) ) {
List_Destroy(uSet); return LINKEDLIST_FALSE;
}
}
複製程式碼第一個 For 迴圈是把左邊集合的元素全部插入到新的集合中；
第二個 For 迴圈是把右邊集合的元素插入到新的集合中去，但是插入前要先進行判斷，看新的集合中是否已經存在了與右邊集合相同的元素；
- 集合的差集：
_BOOL Set_Difference(Set dSet, const Set set1, const Set set2) {
if (dSet == NULL || set1 == NULL || set2 == NULL) {
printf("ERROR: Bad Set !"); return LINKEDLIST_FALSE;
}
if (dSet->matchFunc == NULL) { Set_Init(dSet, set1->matchFunc, set1->destroyFunc); }
ListNode node = NULL;
ElementTypePrt data;
for (node = List_Head(set1); node != NULL; node = List_NodeNext(node)) {
data = List_NodeData(node);
if ( ! Set_IsMember(set2, data) ) {
if (!List_Insert(dSet, List_Tail(dSet), data)) {
List_Destroy(dSet); return LINKEDLIST_FALSE;
}
}
}
return LINKEDLIST_TRUE;
}
複製程式碼解析，差集這裡要注意是誰差誰的，結果是不一樣的，當然對於程式而言，誰差誰根本不重要，不過您要知道而已；
差集圖示，
// 對應的核心程式碼
for (node = List_Head(set1); node != NULL; node = List_NodeNext(node)) {
data = List_NodeData(node);
if ( ! Set_IsMember(set2, data) ) {
if (!List_Insert(dSet, List_Tail(dSet), data)) {
List_Destroy(dSet); return LINKEDLIST_FALSE;
}
}
}
複製程式碼- 集合的子集：
_BOOL Set_IsSubset(const Set subSet, const Set totalSet) {
if (subSet == NULL || totalSet == NULL) {
printf("ERROR: Bad Set !"); return LINKEDLIST_FALSE;
}
if (List_Size(subSet) > List_Size(totalSet)) { return LINKEDLIST_FALSE; }
ListNode node = NULL;
ElementTypePrt data;
for (node = List_Head(subSet); node != NULL; node = List_NodeNext(node)) {
data = List_NodeData(node);
if ( ! Set_IsMember(totalSet, data) ) { return LINKEDLIST_FALSE; }
}
return LINKEDLIST_TRUE;
}
複製程式碼解析，比如有集合1和集合2，要讓集合1是集合2的子集，那麼集合1的元素個數要小於或等於集合2，而且集合1中的元素在集合2中都有【即集合1與集合2的交集是空集】；
- 集合相等：
_BOOL Set_IsEqual(const Set set1, const Set set2) {
if (set1 == NULL || set2 == NULL) {
printf("ERROR: Bad Set !"); return LINKEDLIST_FALSE;
}
if (List_Size(set1) != List_Size(set2)) { return LINKEDLIST_FALSE; }
return Set_IsSubset(set1, set2);
}
複製程式碼解析，這裡就很好理解了，要讓集合相等，首先它們的元素個數得相等，再判斷它們的元素是否完全相同就可以了【因為子集本身就要判斷元素相等性，所以可以直接使用 Set_IsSubset(set1, set2) 來判斷】；
參考書籍：
1、《演算法精解_C語言描述(中文版)》
寫到這裡，本文結束！下一篇，《資料結構：雜湊表 [雜湊表] 》