//　結構定義
　　typedef struct LNode { // 結點結構 
　　　ElemType data; 
　　　struct LNode *next;
　　} *SLink; 
　   
　　本節將討論利用有序表表示集合并實現集合的并、交、差三種操作。

　　以鏈式存儲結構表示有序表，首先定義一個有序鏈表類型。
　   
  
　　typedef struct { 　　　　// 鏈表結構 
　　　SLink head,　　　　　　　// 指向有序鏈表中的頭結點
　　　　　　tail,　　　　　　　// 指向有序鏈表中最后一個結點
　　　　　　curPtr;　　　　　　// 指向操作的當前結點，稱為"當前指針" 
　　　int length, 　　　　　　// 指示有序鏈表的長度
　　　　　curPos;　　　　　　　// 指示當前指針所指結點的位序
　　} OrderedLinkList;



其中部分操作的偽碼算法如下：

　　bool MakeNode( SLink &p, ElemType e )
　{ 
　　// 生成一個數據元素和 e 相同的新結點 *p，并返回TRUE，
　　// 若存儲分配失敗，則返回 FALSE。
　　p = new LNode; 
　　if (!p) return FALSE;
　　p->data = e; p->next = NULL; 
　　return TRUE;
　} 
  
　　bool InitList( OrderedLinkList &L )
　{ 
　　// 構造一個空的有序鏈表 L，若存儲分配失敗，
　　// L.head = NULL 并返回 FALSE，否則返回 TRUE。
　　if ( MakeNode( L.head, 0 ) ) 
　　{ L.tail = L.curPtr = L.head;
　 　 L.length= L.curPos = 0;
　 　 return TRUE; }
　　else 
　　{ L.head = NULL;
　 　 return FALSE; }
　} // InitList 
  
　　bool GetPos (OrderedLinkList L, int pos )
　{
　　// 若1≤pos≤LengthList(L)，則移動當前指針指向第pos個結點,
　　// 且返回函數值為TRUE,否則不移動當前指針且返回函數值為FALSE。
　　if ( pos < 1 || pos > L.len )
　　　return FALSE; 
　　if ( L.curPos > pos )
　　{ L.curPtr = L.head -> next; L.curPos = 1; }
　　while ( L.curPos < pos ) 
　　{ L.curPtr = L.curPtr -> next; ++L.curPos; }
　　return TRUE;
　} 

bool LocateElem ( OrderedLinkList L, ElemType e, 
　　　　　　　　　　 int ( *compare )( ElemType, ElemType ) )
　{ 
　// 若有序鏈表L中存在和e相同的數據元素，則當前指針指向第1個
　// 和e相同的結點，并返回 TRUE，
　// 否則當前指針指向第一個大于e 的元素的前驅，并返回FALSE。
　　L.current = L.head; L.curPos = 0; 
　　while ( L.current -> next && 
　　　　　　　　　 compare( e,L.current -> next -> data )> 0 ) 
　　{
　　　L.current = L.current -> next;　　// 指針后移，繼續查詢 
　　　L.curPos ++; 
　　}   
  　　if ( L.current -> next && 
　　　　　　　　　 compare( e,L.current -> next -> data ) == 0 ) 
　　{ 　　　　　　　　　　　　　 　　 // 查到和 e 相同元素，當前指針后移 
　　　L.current = L.current -> next; L.curPos ++; 
　　　return TRUE; 
　　}
　　else return FALSE; 　　　　　　　// 當前指針所指后繼元素大于 e
　} // LocateElem

void InsAfter ( LinkList &L, SLink s )
　{ 
　　// 在有序鏈表L中當前指針所指結點之后插入一個新的結點 *s，
　　// 并移動當前指針指向新插入的結點。
　　L.curPtr -> next = s;
　　if ( L.tail == L.curPtr )
　　　L.tail = s; 　　　　　　// 若新結點插入在尾結點之后，則修改尾指針 
　　L.curPtr = s; ++L.curPos; // 移動當前指針 
　　++L.length;　　　　　　　 // 表長增 1
　}
  
　　bool DelAfter( LinkList &L, ElemType& e )
　{
　// 若當前指針所指非單鏈表L中最后一個結點，
　// 則刪除當前指針所指結點之后的結點，以 e 帶回它的數據元素
　// 并返回 TRUE，否則不進行刪除操作且返回 FALSE。
  //若當前指針已經指向最后一個結點，它沒有后繼，因此不能進行刪除。
　　if ( L.curPtr == L.tail )
　　　return FALSE;
　　p = L.curPtr -> next; e = p -> data;
　　L.curPtr -> next = p -> next; 　 　　　　// 修改當前結點的指針
　　if ( L.tail == p ) 
　　　L.tail = L.curPtr;　　　　　　　　　　 // 刪除尾結點時修改尾指針
　　delete p; 　　　　　　　　　　　　　　　// 釋放被刪結點
　　--L.length;　　　　　　　　　　　　　　　// 表長減1
　　return TRUE;
　} // DelAfter

　　void union ( OrderLinkList A, OrderLinkList B, OrderLinkList &C )
　{
　　// 已知有序鏈表 A 和 B 分別表示兩個集合，
　　// 本算法求得有序鏈表 C 中所含元素是 A 和 B 的并集
　　if ( InitList(C) )　　　　　　　　　 　　　 // 初始化建空表 
　　{
　　　m = ListLength(A); n = Listlength(B);　　 // 分別求得表長
　　　i = 1; j = 1; 
　　　while ( i <= m || j <= n )　　 　　　　　// 順序考察表中元素
　　　{　   
  　　　　if ( GetPos(A,i) && GetPos(B,j) )
　　　　{ 　　　　　　 　　　　 　　　　// 兩個表中都還有元素未曾考察到
　　　 　　GetCurElem(A,ea); GetCurElem(B,eb ); 
　　　 　　if ( ea <= eb ) 
　　　　　　{ 　　　　　　　　　　　　　　　 // 插入和  相同的元素 
　　　　　　　if ( !MakeNode( s,ea ) ) exit(1);
　　　　　　　++i; 
　　　　　　　if ( ea == eb )
　　　　　　　++j;　　　　　　　　　　　　　　// 舍棄B表中相同元素 
　　　　　　}
  　　　　　else
　　　　　{ 　　　　　　　 　　　　　 　　　// 插入和  相同的元素
　　　　　　if ( !MakeNode( s,eb ) ) exit(1);
　　　　　　++j; 
　　　　　} 
　 　 　}//if
　　　　else if ( GetPos(A,i) ) 　　　　　　　// A表中尚有元素未曾插入 
　　　　{ 
　　　　　GetCurElem( A,ea ); 
　　　　　if ( !MakeNode( s,ea ) ) exit(1); 
　　　　　++i; 
　　　　}//else
　　　　else 　　　　　　　　　　　　　　　 // B表中尚有元素未曾插入 
　　　　{
　　　　　GetCurElem( B,eb ); 
　　　　　if ( !MakeNode( s,eb ) ) exit(1);
　　　　　++j; 
　　　　}//else
　　　　InsAfter(C,s); 　　　　　　　　　 　　// 插入到C表 
　　}
　} // union

void Intersection (OrderLinkList A, 
　　　　　　　　　　　　OrderLinkList B, OrderLinkList &C)
　{ 
　　// 已知有序鏈表 A 和 B 分別表示兩個集合，
　　// 本算法求得有序鏈表 C 中所含元素是 A 和 B 的交集
　　if ( InitList(C) )　　　　　　　　　　// 初始化建空表 
　　{
　　　m = ListLength(A); n = Listlength(B); // 分別求得表長
　　　i = 1; j = 1;    
  　　　while ( i <= m && j <= n )　　　 　// 順序考察表中元素
　　　{
　　　　if ( GetPos(A,i) && GetPos(B,j) ) 
　　　　{　　　　　　　　　　　　　　　　// 兩個表中都還有元素未曾考察 
　　　　　GetCurElem( A,ea ); GetCurElem( B,eb );
　　　　　if ( ea < eb ) ++i; 
　　　　　else if ( ea > eb ) ++j;
　　　　　else 
　　　　　{　　　　 　　　　　　　　　　　　// 插入和  相同的元素 
　　　　　　if ( !MakeNode( s,ea ) ) exit(1); 
　　　　　　++i;++j; 
　　　　　　InsAfter(C,s);
　　　　　} // else 
　　　　} // if
　　　} // while 
　　} // if
　} // Intersection