【数据结构（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 = 1;
    while(p!=L.Right && k<i){ //p指向i, q指向i-1;保证至多扫描一遍后退出
        XorPointer t = p;
        p = XorP(q, p->LRPtr);
        q = t;
        k++;
    }
    if(k+1<i) return ERROR; //表长不够i-1
    if(k+1==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==1) L.Left = s;
    if(i==k+1) 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 = 1;
    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==1) 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,10);
    ElemType e;
    if(Delete(l,5,e))
        Traverse(l,print);
    return 0;
}