雅虎面试题─将两个双向循环链表中data值相同的结点删除

有双向循环链表结点定义为：

struct node
{ 
  int data;
  struct node *front,*next;
};

有两个双向循环链表A，B，知道其头指针为：pHeadA,pHeadB，请写一函数将两链表中data值相同的结点删除。

用两个向量A_vec、B_vec分别存储链表A、B的元素值，将A_vec、B_vec排序，用类似归并排序的方法把A_vec、B_vec中值相同的元素放到向量common_vec中。分别遍历链表A、B，用二分查找法查看每个节点元素是否在common_vec中。

 // 链表结点
 template <typename T>
 class dc_list_node
 {
 public:
     dc_list_node(const T &item = T(), dc_list_node<T> *p_front = NULL, dc_list_node<T> *p_next = NULL):
         m_item(item), mp_front(p_front), mp_next(p_next)
     {}

     T m_item;
     dc_list_node<T> *mp_front;
     dc_list_node<T> *mp_next;
 private:
     dc_list_node(const dc_list_node<T> &);
     dc_list_node<T> &operator=(const dc_list_node<T> &);
 };

 void dc_list_erase_node_with_equal_value(dc_list_node<int> *&p_headA, dc_list_node<int> *&p_headB)
 {
     if (p_headA == NULL || p_headB == NULL)
         return;
     // A_vec存储链表A的元素值，B_vec存储链表B的元素值
     std::vector<int> A_vec, B_vec, common_vec;
     dc_list_node<int> *p_node;
     A_vec.push_back(p_headA->m_item);
     p_node = p_headA->mp_next;
     while (p_node != p_headA)
     {
         A_vec.push_back(p_node->m_item);
         p_node = p_node->mp_next;
     }
     B_vec.push_back(p_headB->m_item);
     p_node = p_headB->mp_next;
     while (p_node != p_headB)
     {
         B_vec.push_back(p_node->m_item);
         p_node = p_node->mp_next;
     }
     // 将A_vec和B_vec排序
     std::sort(A_vec.begin(), A_vec.end());
     std::sort(B_vec.begin(), B_vec.end());
     // 合并A_vec和B_vec相同的元素值到common_vec
     std::size_t i = 0, j = 0;
     while (i < A_vec.size() && j < B_vec.size())
     {
         if (A_vec[i] < B_vec[j])
             ++i;
         else if (A_vec[i] > B_vec[j])
             ++j;
         else
         {
             common_vec.push_back(A_vec[i]);
             ++i;
             ++j;
         }
     }
     // 分别遍历链表A和B，删除在元素值common_vec中的结点
     p_node = p_headA;
     for (i = 0; i < A_vec.size(); ++i)
     {
         if (std::binary_search(common_vec.begin(), common_vec.end(), p_node->m_item)) // 当前结点是值相同的结点
         {
             if (p_node == p_headA && p_node->mp_next == p_headA) // 链表中只有头结点一个结点
             {
                 delete p_headA;
                 p_headA = NULL;
                 break;
             }
             else if (p_node == p_headA) // 当前结点是头结点
             {
                 p_headA = p_node->mp_next;
                 p_headA->mp_front = p_node->mp_front;
                 p_node->mp_front->mp_next = p_headA;
                 p_node = p_headA;
             }
             else
             {
                 dc_list_node<int> *p_next = p_node->mp_next, *p_front = p_node->mp_front;
                 p_next->mp_front = p_front;
                 p_front->mp_next = p_next;
                 delete p_node;
                 p_node = p_next;
             }
         }
         else
             p_node = p_node->mp_next;
     }
     p_node = p_headB;
     for (i = 0; i < B_vec.size(); ++i)
     {
         if (std::binary_search(common_vec.begin(), common_vec.end(), p_node->m_item)) // 当前结点是值相同的结点
         {
             if (p_node == p_headB && p_node->mp_next == p_headB) // 链表中只有头结点一个结点
             {
                 delete p_headB;
                 p_headB = NULL;
                 break;
             }
             else if (p_node == p_headB) // 当前结点是头结点
             {
                 p_headB = p_node->mp_next;
                 p_headB->mp_front = p_node->mp_front;
                 p_node->mp_front->mp_next = p_headB;
                 p_node = p_headB;
             }
             else
             {
                 dc_list_node<int> *p_next = p_node->mp_next, *p_front = p_node->mp_front;
                 p_next->mp_front = p_front;
                 p_front->mp_next = p_next;
                 delete p_node;
                 p_node = p_next;
             }
         }
         else
             p_node = p_node->mp_next;
     }
 }