比较链表，C++，相同的顺序但可以不同的抓住

Question

假设我们得到了函数定义

bool sameValsOrder(node *p , node *q)

我们必须编写一个函数来比较两个链表，如果它们具有相同的顺序，则返回 true 否则返回 false [77777] 和 [77] -> 正确

[1234567] 和 [1234555567] -> 真

bool sameValsOrder (node *p , node *q)
{
     if ( q==NULL && p==NULL)
        return true;
     else if ((q=NULL && p != NULL)|| (p=NULL && q!= NULL))
         return false;
     else if ( q != NULL && p != NULL)
           while ( q != 0 && p != 0)
            {
                if (p->data != q->data)
                    {
                        return false;
                        break;
                    }
                else 
                    {
                  p= p-> next ;
                  q= q-> next;
                    } 
            }
             return true;
    }

上面的代码是我的答案，但我意识到了一些事情。我是否需要在 while 循环中添加更多 if 语句，以便 [77777] 和 [7] 的链接列表应该返回 true，因为它的相同顺序只是更少。

Answer 1

根据您所写的内容，您实际上并不关心这些值，但如果列表是有序的，您想返回 true 吗？似乎您只需要遍历列表中的每个值。只要 NEXT 值不小于 PREVIOUS 值，就继续遍历列表。如果到达末尾，则返回 true，因为列表是有序的。如果在任何时候你遇到一个小于任何先前值的值，那么就在此处返回 false。

#include <iostream>

using namespace std;

class node{
public:
    node(){next = NULL;}
    int data;
    node * next;
};
class myList{
public:
    myList(){pRoot = NULL;}
    void add(int data);
    node * pRoot;
};
bool sameValsOrder (node *p , node *q)
{
     if ( q==NULL && p==NULL) // If both lists are empty
        return true;
     else if ((q==NULL && p != NULL)|| (p==NULL && q!= NULL)) // One list is empty and the other is not
         return false;
     else if ( q != NULL && p != NULL) //Both lists contain values we must check
     {      
         int temp; //I am going to assume a singly linked list (no access to previous value), need this to hold previous value
         temp = p->data; 
         while (p->next != NULL) //The list still contains elements
         {
            if (p->next->data < temp) //The value in the current node is LESS than our temp, then list is out of order so return false
                return false;
            else { //Otherwise move to the next node
                temp = p->data;
                p = p->next;
            }
         }
         temp = q->data; //Reset temp for q
         //Do the same thing for q
         while (q->next != NULL) //The list still contains elements
         {
            if (q->next->data < temp) //The value in the current node is LESS than our temp, then list is out of order so return false
                return false;
            else { //Otherwise move to the next node
                temp = q->data;
                q = q->next;
            }
         }
     }
     return true; //If we are this are then both lists should be ordered
}
int main()
{
    myList * p = new myList();
    myList * q = new myList();
    p->add(7);
    p->add(6);
    p->add(5);
    p->add(4);
    p->add(3);
    p->add(2);
    p->add(1);

    q->add(7);
    q->add(6);
    q->add(5);
    q->add(5);
    q->add(5);
    q->add(5);
    q->add(4);
    q->add(3);
    q->add(2);
    q->add(1);
    cout << sameValsOrder (p->pRoot, q->pRoot) << endl;
    return 0;
}
void myList::add(int data)
{
    node * nodeToAdd = new node();
    nodeToAdd->data = data;
    if(pRoot == NULL) //List is empty
    {
        pRoot = nodeToAdd;
        pRoot->next = NULL;
    }
    else //List not empty insert new node at beginning
    {
        nodeToAdd->next = pRoot;
        pRoot = nodeToAdd;
    }
}

Answer 2

 while ( q != 0 && p != 0)
        {
            if (p->data != q->data)
                    return false;
                    break;
            else 
              p= p-> next ;
              q= q-> next;
        }

这是错误的，当它不相同但 p 和 q 的大小可能不同时，你返回 false [1112] [12] 将返回不应该的假

Answer 3

while(q!=NULL || p!=NULL)
{    
    if(q->data==p->data)    
    { 
        p=p->next;
        break;
    }
    else(q->data <  p->data)
    q=q->next;
}

基本上，只有当值不匹配时，您才应该在第一个链表中前进，否则遍历第二个链表直到匹配。

Answer 4

OP 已在 cmets 中表示，他希望考虑具有相同数据的节点的“运行”作为匹配，即使这些运行在 2 个列表中具有不同的长度。这简化了(q->data == p->data) 然后跳过组成运行的节点。

这是一些伪代码； C 实现实际上并不复杂（尽管可能要多几行）：

bool sameValsOrder (node *p , node *q)
{
    while not at the end of either list, and the current nodes are the same {

        skip run in q, taking care to deal with the NULL at the end of the list

        skip run in p, taking care to deal with the NULL at the end of the list
    }

    if we've reached the end of both lists, they are equivalent
}

C 实现：

bool sameValsOrder (node *p , node *q)
{
    while (q && p && (q->data == p->data)) {
        /* find next different node in each list (ie., skip runs) */

        int tmp = q->data;  /* or whatever type `data` is */

        while (q && (q->data == tmp)) {
            q = q->next;
        }

        while (p && (p->data == tmp)) {
            p = p->next;
        }
    }

    /*
     * we've either reached the end of one or both lists, 
     *  or have found a `data` difference
     */

    if (p == q) {
        /* should happen only when `q` and `p` are NULL */
        assert(q == NULL);
        assert(p == NULL);

        /* we've reached the end of both lists, so they're 'equivalent' */

        return true;
    }

    return false;
}