算法导论习题（10）

10.2-8 说明如何在每个元素仅使用一个指针x.np的（而不是通常的两个指针next和pre）情况下实现双向链表，假设所有的指针的值都可以视为k位的整型数，且定义x.np = x.next ^ x.pre，即 x.next 和 x.pre 的异或，（NULL的值为0）注意要说明获取表头所需的信息，并说明如何在该表上实现SEARCH、INSERT、DELETE和REVERSE，REVERSE要求时间复杂度为：O(1)。

需要了解的是异或运算的特点：a = b ^ c，则：b = a ^ c，c = a ^ b。

算法实现上，要注意的是如果要将指针地址转换为整型数，不能简单的使用int，因为在32位机上地址为4字节，64位机上为8字节，所以应当根据自己操作系统的硬件情况选择使用int还是long。（目前为止，下面的代码地址转换还是存在问题，之后纠正） 

＊出现的问题：

1）地址问题，不应该使用&取地址符，这样得到的是物理地址的值，而不是逻辑地址，导致本应使用NULL的逻辑0地址变成了物理地址；

2）new操作，在测试函数中使用它导致每次都会申请到同一个地址，而且这个地址应该是在脱离函数以后就被释放了；

3）当我尝试把新的Node的指针申请放在main函数中时，插入没有问题，但是在SHOW函数执行的时候，出现"error: segment fault 11"，似乎是不能访问；

4）循环处的问题，pre不能直接在cur之前重新赋值，修改成这样：

temp = cur;
cur = (Node*) ((long)(cur->np) ^ (long)pre);
pre = cur;

主要代码（不包括以上修改）：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>

using namespace std;

struct Node {
	int value;
	Node* np;
};

// define class: LIST
class LIST {
private:
	Node* head;
	Node* tail;

public:
	LIST();
	void INSERT(int);
	void DELETE(int);
	Node* SEARCH(int);
	void REVERSE();
	void SHOW();
};

// construct
LIST::LIST() {
	head = NULL;
	tail = NULL;
}

// insertion
void LIST::INSERT(int val) {
	printf("begin-INS\n");
	Node* p = new Node();
	p->value = val;

	if (head != NULL) {
		head->np = (Node*)((long)&(head->np) ^ (long)&p);  // modify the old head's np
	}

	// new head: modify its np (head->np ^ 0), 
	// and the first elem's np = 0, in other words, its next ptr = NULL
	p->np = head;  
	head = p;
	if (tail == NULL) {
		tail = p;  // jump the origin head, ignore it
	}
	delete p;
	printf("end-INS\n");
}

// deleting
void LIST::DELETE(int val) {
	printf("begin-DEL\n");
	Node* cur = head;
	Node* pre = NULL;

	while (cur != NULL && cur->value != val) {
		pre = cur;
		cur = (Node*) ((long)&(cur->np) ^ (long)&pre);
	}

	if (NULL == cur) {
		printf("Cannot find this value!\n");
	} else {
		// delete this value's Node
		Node* next = (Node*) ((long)&pre ^ (long)&(cur->np));
		Node* ppre = (Node*) ((long)&(pre->np) ^ (long)&cur);
		pre->np = (Node*) ((long)&ppre ^ (long)&next);
	}
	printf("end-DEL\n");
}


// searching
Node* LIST::SEARCH(int val) {
	printf("begin-SEAR\n");
	Node* cur = head;
	Node* pre = NULL;
	while (cur != NULL && cur->value != val) {
		pre = cur;
		cur = (Node*) ((long)&(cur->np) ^ (long)&pre);
	}
	printf("end-SEAR\n");
	return cur;
}

// reversing
void LIST::REVERSE() {
	Node* temp = head;
	head = tail;
	tail = temp;
}

void LIST::SHOW() {
	Node* cur = head;
	Node* pre = NULL;

	while (cur != NULL) {
		printf("%d, ", cur->value);
		pre = cur;
		cur = (Node*) ((long)pre ^ (long)cur->np);
	}
	printf("\n");
}

// test func
void test() {
	LIST L;
	for (int i = 0; i < 10; i++) {
		L.INSERT(i + 3);
	}
	L.SHOW();

	Node* node = L.SEARCH(4);
	if (node != NULL) {
		printf("%d\n", node->value);
	} else {
		puts("This value 4 is not exist!");
	}

	Node* node2 = L.SEARCH(100);
	if (node2 != NULL) {
		printf("%d\n", node2->value);
	} else {
		puts("This value 100 is not exist!");
	}

	L.REVERSE();
	L.SHOW();
	
}
int main() {
	test();
	return 0;
}