【数据结构（ywm版）】异或指针双向链表

在《数据结构题集》中看到这种链表，实际上就是把一般的双向链表的next和prior两个指针通过异或运算合并为一个指针域来存储，每个结点确实可以减少一个指针的空间，但会带来取指针值时运算的开销。

实现的时候，先搞清双向链表，把握异或指针域的原理公式，然后从双向链表出发进行转换即可。

 typedef struct XorNode{ //结点的定义
     ElemType data;
     struct XorNode* LRPtr;
 }XorNode, *XorPointer;

 typedef struct{//无头结点的异或指针双向链表
     XorPointer Left, Right; //只保存指向首、末结点的指针
 }XorList;

每个结点的指针域存的是它的前驱和后继的异或值，即 LRPtr = prior ^ next，指针异或运算本质上就是整型的内存地址的按位异或。

 //指针异或函数，注意指针变量不支持^运算，需要强转为整型（内存地址，长度与机器有关，C将之封装为size_t型）
 XorPointer XorP(XorPointer p, XorPointer q){
     size_t x = (size_t)p;
     size_t y = (size_t)q;
     return (XorPointer)(x^y);
 }

这相当于把前驱和后继的指针编码到一个指针域中了，那么如何解码呢，只凭LRPtr本身是不可以的，必须再已知prior或next才行，这得益于异或运算特有的“对称”性质。

异或运算满足结合律，0为幺元，每个元素和自身互为逆元；所以设a, b为两个内存地址，则有

a^(a^b) = (a^a)^b = b;

(a^b)^b = a^(b^b) = a;

有了这两条，则可推出取得前驱或后继的式子，即

prior = LRPtr ^ next;

next = prior ^ LRPtr;

根据这两个关系，把双向链表的next和prior的运算用LRPtr替换即可。注意由于是循环链表，只有一个元素时，其前驱和后继都为自身。

注意我实现的是无头结点的循环链表，而链表的表长又不是显式维护的，所以要以回到起点作为循环退出条件之一，并设一个记录步数的变量k来避免 i 值超过表长而导致的“兜圈子”；在边界操作时注意修改首末元素指针。

 Status CreateList(XorList& L, int n){
 //头插法建表，无头结点，入口条件：n>=1
     n--;
     XorPointer p;
     p = (XorPointer)malloc(sizeof(XorNode));
     L.Left = L.Right = p;
     p->data = n;
     p->LRPtr = XorP(p, p);
     while(n--){
         p = (XorPointer)malloc(sizeof(XorNode));
         p->data = n;
         p->LRPtr = XorP(L.Right, L.Left);
         L.Left->LRPtr = XorP(p, XorP(L.Right, L.Left->LRPtr));
         L.Right->LRPtr = XorP(XorP(L.Right->LRPtr,L.Left),p);
         L.Left = p;
     }
 }

 Status Insert(XorList& L, int i, ElemType e){
 //在第i个位置前插入结点e（i的合法值为1～表长+1）
 //由于无头结点，故判断表长是否够i，要通过计步变量k
     XorPointer p = L.Left, q = L.Right;
     int k = ;
     while(p!=L.Right && k<i){ //p指向i, q指向i-1;保证至多扫描一遍后退出
         XorPointer t = p;
         p = XorP(q, p->LRPtr);
         q = t;
         k++;
     }
     if(k+<i) return ERROR; //表长不够i-1
     if(k+==i){p = L.Left; q = L.Right;} //插到表长+1的位置，即最后一个元素之后
     XorPointer s = (XorPointer)malloc(sizeof(XorNode));
     s->data = e;
     s->LRPtr = XorP(q, p);
     q->LRPtr = XorP(XorP(q->LRPtr, p), s);
     p->LRPtr = XorP(s, XorP(q, p->LRPtr));
     if(i==) L.Left = s;
     if(i==k+) L.Right = s;
     return OK;
 }

 Status Delete(XorList& L, int i, ElemType& e){
 //删除第i个位置的元素，用e返回其值（i的合法值为1~表长）
     XorPointer p = L.Left, q = L.Right;
     int k = ;
     while(p!=L.Right && k<i){ //p指向i, q指向i-1
         XorPointer t = p;
         p = XorP(q, p->LRPtr);
         q = t;
         k++;
     }
     if(k<i) return ERROR; //表长不够i
     if(p==L.Right) L.Right = q; //删除最后一个结点
     e = p->data;
     XorPointer m = XorP(q, p->LRPtr); //m暂存p的后继
     q->LRPtr = XorP(XorP(q->LRPtr, p), m);
     m->LRPtr = XorP(q, XorP(p, m->LRPtr));
     free(p);
     if(i==) L.Left = m; //删除第一个结点
     return OK;
 }

 Status Traverse(XorList& L, void (*visit)(XorNode)){
     XorPointer p = L.Left, q = L.Right;
     while(p != L.Right){
         visit(*p);
         XorPointer t = p;
         p = XorP(q,p->LRPtr);
         q = t;
     }
     visit(*p);
     return OK;
 }

 void print(XorNode xn){
     printf("[%d]",xn.data);
 }

 int main()
 {
     XorList l;
     CreateList(l,);
     ElemType e;
     if(Delete(l,,e))
         Traverse(l,print);
     return ;
 }