LeetCode之Copy List with Random Pointer

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.

Return a deep copy of the list.

结构体定义如下：

struct RandomListNode {
    int label;
    struct RandomListNode *next;
    struct RandomListNode *random;
};

函数定义如下

struct RandomListNode *copyRandomList(struct RandomListNode *head) 

看到此题的标签是HashTable，知道应该用hash表，但是如何使用呢？

设原先的链表为list1，新的链表为list2

如果可以通过list1中的node1的random指针，找到list2中的node2的指针，

也就是说，假如random指向了list1中的第三个节点，那么random对应的node2也应该是第三个

如何建立node1和node2之间的联系呢？hash表

建立联系的过程如下：

    struct RandomListNode newhead = {0, NULL, NULL};
    struct RandomListNode* p = head;
    struct RandomListNode* q = &newhead;
    Hashtable* ht = createHashTable(1023);
    while(p){
        q->next = (struct RandomListNode*)malloc(sizeof(struct RandomListNode));
        q->next->label = p->label;
        insert(ht, (Key)p, (Value)q->next);
        q = q->next;
        p = p->next;
    }

可以看到将list1中的节点指针，和list2中的节点指针，通过一个hash表联系起来。

现在已经构建了新的链表和hash表，剩余的工作就是添加random指针。

就是使用random指针作为key，在hash表中查找对应的value，也就是list2中对应的节点指针。

但是，第一步的构建过程好像没有添加random指针，添加的是节点本身的指针，这么查找真的对吗？

仔细想一下，random指针其实是节点指针的子集。即以random为key的hash节点肯定是存在的。

添加random指针的过程如下：

    q = newhead.next;
    p = head;
    while(q){
        q->random = NULL;
        if(p->random){
            node* n1 = find(ht, (Key)p->random, comp);
            if(n1){
                q->random = (struct RandomListNode*)n1->value;
            }
        }
        p = p->next;
        q = q->next;
    }

为此，我还特意写了一个hash表，其实没有必要。

直接用STL中的unordered_map就行，为了练手，就自己写了一个。（其实是为了准备线上笔试，怕时间来不及，提前写好）

template<class Key, class Value>
class Hashtable;
template<class Key, class Value>
class node{
private:
    friend class Hashtable<Key, Value>;
    Key key;
    Value value;
    node* next;
public:
    node(const Key& k, const Value& v):key(k),value(v),next(NULL){}
    node():key(),value(),next(NULL){}
    Value& data(){ return value; }
    Key& index(){return key;}
    ~node(){ }
};

template<class Key, class Value>
class Hashtable{
private:
    node<Key,Value>* listheads;
    int size;
public:
    Hashtable(int size);
    ~Hashtable();
    void insert(const Key& key, const Value& value);
    node<Key, Value>* find(const Key& key);
};
template<class Key, class Value>
Hashtable<Key, Value>::Hashtable(int __size)
{
    listheads = new node<Key,Value>[__size];    //表头节点
    size = __size;
}
template<class Key, class Value>
Hashtable<Key, Value>::~Hashtable()
{
    node<Key, Value>* nd;
    node<Key, Value>* p;
    for(int i = 0;i<size;i++){
        nd = (listheads + i)->next;
        while(nd){
            p = nd;
            nd = nd->next;
            delete p;
        }
    }
    delete [] listheads;
}

template<class Key, class Value>
void Hashtable<Key, Value>::insert(const Key& key, const Value& value)
{
    node<Key,Value>* listhead = listheads + (key % size);
    node<Key,Value>* nd = new node<Key,Value>(key, value);
    nd->next = listhead->next;
    listhead->next = nd;       //后进先出式进链
}

template<class Key, class Value>
node<Key, Value>* Hashtable<Key, Value>::find(const Key& key){
    node<Key,Value>* nd = listheads + (key % size);
    while(nd && key != nd->key){
        nd = nd->next;
    }
    return nd;
}

功能很不完善，没有删除和修改功能，没有实现rehash，没有提供迭代器，更没有考虑线程安全性，更像是一个玩具。

想想项目中用到的hash表，确实比我这个要健全多了。