有雙向迴圈連結串列結點定義為：

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;
    }
}