题目如下：

Given a Linked List of node structure asstruct Node { type element; Node *next; Node *arb;};You are asked to create an exact copy this linked list. Pointer arb points to an arbitrary node in the linked list.

先说说我的算法吧。我选择了一个超笨的方法完成：创建一个新的linked list存储原始链表每个节点的顺序号，然后复制链表的时候，通过顺序号，找到arb指针所指向的节点。算法很笨，无论是空间效率还是时间效率，都很差。不过好歹是完成了。

不过，在我看完答案之后，我也wanna kill myslef。太神奇了。

算法首先在每两个节点之间插入一个新的节点。然后循环每组节点：

p->next->arb = p->arb->next;
p = p->next->next;

我顺手写了段实现代码，没编译，没调试，没测试。

typedef struct {
    int data; // assuming data is an integer
    Node *next;
    Node *arb;
}Node;

void copy_linked_list(Node * src, Node ** dst) {
    Node *p;
    Node *q = NULL;

    for (p = src; p; p=p->next->next) {
        // Initialize the new node
        Note *nn = (Node *)malloc(sizeof(Node));
        nn->data = p->data;
        nn->arb = NULL;

        // Add the node to the right of the src node
        nn->next = p->next;
        p->next = nn;
    }

    // Create arb pointer
    for(p = src; p; p = p->next->next)
        p->next->arb = p->arb->next;

    // Detach copy node and create destination linked list
    for (p = src, q = *dst; p; p = p->next-next, q = q->next) {
        r = p->next;
        p->next = p->next-next;
        if (q->next)
            q->next = q->next->next;
        else
            q->next = NULL;
        if (q)
            q = r;
        else
            q->next = r;
    }
}

其实Rui早在3月份就给我发了这道题目，我也早在几个月前，看到了正确答案。一直想把这道题作为面试题，可觉得太难了，不想难为candidate了。

今天看到一个快速平方根算法，很是巧妙。据称是Carmack在QUAKE3中使用了下面的算法，它第一次在公众场合出现的时候，几乎震住了所有的人。

float InvSqrt(float x)
{
    float xhalf = 0.5f*x;
    int i = *(int*)&x; // get bits for floating value
    i = 0x5f3759df - (i>>1); // gives initial guess y0
    x = *(float*)&i; // convert bits back to float
    x = x*(1.5f-xhalf*x*x); // Newton step, repeating increases accuracy
    return x;
}

Chris Lomont写了篇论文，关于这个算法：
http://www.lomont.org/Math/Papers/2003/InvSqrt.pdf

用伪代码写的。

Table of contents

Preface

Chapter 0: Prologue
Chapter 1: Algorithms with numbers
Chapter 2: Divide-and-conquer algorithms
Chapter 3: Decompositions of graphs
Chapter 4: Paths in graphs
Chapter 5: Greedy algorithms
Chapter 6: Dynamic programming
Chapter 7: Linear programming
Chapter 8: NP-complete problems
Chapter 9: Coping with NP-completeness
Chapter 10: Quantum algorithms