仅用一个指针域，实现双向循环链表

原题出自"Introduction to Algorithms"中的练习题，10.2.8. 今天恰巧看到，觉得挺有意思，就写一写。

 

问题：

10.2-8
Explain how to implement doubly linked lists using only one pointer value np[x]
per item instead of the usual two (next and prev). Assume that all pointer
values can be interpreted as k-bit integers, and define np[x] to be np[x] =
next[x] XOR prev[x], the k-bit “exclusive-or” of next[x] and prev[x]. (The value
NIL is represented by 0.) Be sure to describe what information is needed to access
the head of the list. Show how to implement the S EARCH, I NSERT, and D ELETE
operations on such a list. Also show how to reverse such a list in O(1) time.

期望的调用方法

search(list, key)

insert(list, node)

delete(list, node)

reverse(list)

 

代码

#include <stdio.h>
#include <stdlib.h>

/**
 * circular doubly linked list with only one pointer value
 * SENTINEL <-> ELE1 <-> ELE2 <...> ELEn
 * ELEn <-> SENTINEL
 *
 */ 

/**
 * Operations
 * search
 * insert
 * delete
 * traverse
 * reverse
 *
 */

struct node {
	int id;
	unsigned long np;
};

struct list {
	struct node SENTINEL;
	struct node *HEAD;
	struct node *HEAD_PREV;
	struct node *prevNode;
	struct node *tmpNode;
};


/* global variable, just for demonstration purpose */
static int ID = 0;

/* auxiliary function */
unsigned long toUlong(struct node *pNode) {
	return (unsigned long)(void*)pNode;
}

struct node *toPNode(unsigned long ul) {
	return (struct node*)(void*)ul;
}

/* operations */

/* init list */
void INIT_LIST(struct list* pList) {
	pList->SENTINEL.id = -1; pList->SENTINEL.np = 0;
	pList->HEAD_PREV = pList->HEAD = &(pList->SENTINEL);
	pList->prevNode = pList->tmpNode = NULL;
}

/* allocate a new Node */
int spawn(struct node **ppNode) {
	*ppNode = (struct node*)malloc(sizeof(struct node));
	if (*ppNode == NULL) {
		perror("spawn node failure");
		exit(1);
	}
	(*ppNode)->id = ID;
	(*ppNode)->np = 0;
	ID += 1;
	return ID-1;
}

/* insert pNode into the list */
void insert(struct list *pList, struct node *pNode) {
	if (pList->HEAD_PREV == pList->HEAD) {
		pList->HEAD_PREV = pNode;
	}
	else {
		struct node *pNext = toPNode(pList->HEAD->np ^ toUlong(pList->HEAD_PREV));
		pList->HEAD->np = toUlong(pList->HEAD_PREV) ^ toUlong(pNode);
		pNode->np = toUlong(pList->HEAD) ^ toUlong(pNext);
		pNext->np = toUlong(pList->HEAD) ^ pNext->np ^ toUlong(pNode);
	}
}

/* iterate over the list */
#define ITER_LIST(pList, pNode)						\
	for (pList->prevNode = pList->HEAD, pList->tmpNode = NULL, \
		     pNode = toPNode(toUlong(pList->HEAD_PREV) ^ pList->HEAD->np);	   \
	     pNode != pList->HEAD;						\
	     pList->tmpNode = pNode, pNode = toPNode(toUlong(pList->prevNode) ^ pNode->np), \
		     pList->prevNode = pList->tmpNode)

/* reverse list */
void reverse(struct list *pList) {
	pList->HEAD_PREV = toPNode(toUlong(pList->HEAD_PREV) ^ pList->HEAD->np);
}

/* search item in list */
struct node* search(struct list *pList, int key) {
	struct node *pNode;
	ITER_LIST(pList, pNode) {
		if (pNode->id == key)
			return pNode;
	}
	return NULL;
}

/* delete item from list */
void delete(struct list *pList, struct node *pNode) {
	struct node *current, *next;
	ITER_LIST(pList, current) {
		if (current->id == pNode->id && current->np == pNode->np) {
			break;
		}
	}
	if (current != pList->HEAD) {
		/* node found, delete node */
		next = toPNode(toUlong(pList->prevNode) ^ current->np);
		pList->prevNode->np = pList->prevNode->np ^ toUlong(current) ^ toUlong(next);
		next->np = next->np ^ toUlong(current) ^ toUlong(pList->prevNode);
		free(current);
	}
}

/* test */
int main() {
	int ret, i;
	struct node *ptmpNode;
	struct list L;
	struct list *pL = &L;
	INIT_LIST(&L);
	/* test1 - basic */
	printf("======================Test Basic======================\n");
	printf("SENTINEL->id = %d \n", pL->HEAD->id);
	/* test2 - spawn */
	printf("======================Test spawn======================\n");
	for (i=0; i<10; i++) {
		ret = spawn(&ptmpNode);
		printf("id = %d \t np = %lu \t ret = %d\n",
		       ptmpNode->id, ptmpNode->np, ret);
		free(ptmpNode);
	}
	/* test3 - insert */
	printf("======================Test insert======================\n");
	for (i=0; i<10; i++) {
		ret = spawn(&ptmpNode);
		insert(&L, ptmpNode);
		printf("INSERT: id = %d \t np = %lu \n",
		       ptmpNode->id, ptmpNode->np);
	}
	/* test4 - traverse */
	printf("======================Test traverse======================\n");
	ITER_LIST(pL, ptmpNode) {
		printf("id = %d \t np = %lu \n",
		      ptmpNode->id, ptmpNode->np);
	}
	/* test5 - reverse */
	printf("======================Test reverse======================\n");
	reverse(&L);
	ITER_LIST(pL, ptmpNode) {
		printf("id = %d \t np = %lu \n",
		      ptmpNode->id, ptmpNode->np);
	}
	/* test6 - search */
	printf("======================Test search======================\n");
	for (i=0; i<20; i++) {
		ptmpNode = search(&L, i);
		if (ptmpNode) {
			printf("SEARCH: id = %d, np = %lu \n",
			       ptmpNode->id, ptmpNode->np);
		}
		else {
			printf("SEARCH: id = %d, NOT FOUND \n", i);
		}
	}
	/* test7 - delete */
	printf("======================Test delete======================\n");
	ptmpNode = search(&L, 15);
	if (ptmpNode) {
		delete(pL, ptmpNode);
	}
	ITER_LIST(pL, ptmpNode) {
		printf("id = %d \t np = %lu \n",
		      ptmpNode->id, ptmpNode->np);
	}	
	return 0;
}

 

遗留问题

1. 是否可以不用到sentinel？

2. delete操作是否有可能在O(1)内完成？