Question

我编写了两个函数来在“链表”中插入节点。当一个函数（insertNth）更新头指针时，第二个函数（sortedInsert）不会在函数调用之间更新头指针。推功能正在引用头指针。


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

void printList(node *head)
{
    node *current = head;

    while(current!=NULL)
    {
        cout<<current->data<<" ";
        current = current->next;
    }

}

void push(node* &head, int data)
{
    node *newNode = new node();

    newNode->data = data;
    newNode->next = head;
    head = newNode;
}

void insertNth(node *&head, int index, int val)
{
    node *current = head;

    int cnt = 0;

    while(current!=NULL)
    {
        if(cnt == index)
        {
            if(cnt==0)
            {
                push(head, val);
            }
            else
            {
                push(current->next, val);
            }
        }
        current=current->next;
        cnt++;
    }
}

void sortedInsert(node *head, int val)
{
    node *current = head;

    if(head != NULL && val < head->data)
    {
        node *newNode = new node();

        push(head,val);

        return;
    }

    while(current!=NULL)
    {
        if(current->data < val && current->next->data > val)
        {
            push(current->next, val);
            return;

        }
        current = current->next;
    }
}

int main()
{
    node *head;

    push(head, 3);
    cout<<"\n";
    printList(head);

    cout<<"\nInsertNth: ";
    insertNth(head,0, 2);
    printList(head);

    cout<<"\nsortedInsert: ";
    sortedInsert(head, 1);
    printList(head);

    return 0;
}

我得到以下输出：

3 
InsertNth: 2 3 
sortedInsert: 2 3

为什么第三行不打印1 2 3？

// 更新资料 //

正确的SortedInsert如下：

void sortedInsert(node *&head, node *newNode)
{
    node *current = head;

    if(head == NULL || newNode->data < head->data)
    {

        newNode->next = head;
        head = newNode;

        return;
    }

    while(current!=NULL && current->next != NULL)
    {
        if(current->data < newNode->data && current->next->data > newNode->data)
        {

            newNode->next = current->next;
            current->next = newNode;

            return;

        }

        current = current->next;
    }
    if(current->next == NULL)
    {
        current->next = newNode;
        newNode->next = NULL;
    }
}

Answer 1

要求提供样品。请注意，我将其作为模板进行，但是您可以跳过模板事务，可以使用结构节点*代替T *。这不是通用目的，但可能更容易理解。

template <class T>
class MyLinkedList {
    class Entry {
    public:
        Entry * previous;
        Entry * next;
        T * node;
    }

    Entry * head;
    Entry * tail;

    void push(T * nodeToPush) { pushBefore(head, nodeToPush); }
    void insertNth(int whereToInsert, T * nodeToInsert) {
         ... find the nth Entry pointer
         pushBefore(head, nodeToPush);
    }

private:
    void pushBefore(Entry *entry, T * nodeToPush) {
        Entry *newEntry = new Entry();
        newEntry->node = nodeToPush;
        if (entry != NULL) {
            newEntry->previous = entry->previous;
        }
        newEntry->next = entry;
        entry->previous = newEntry;
        if (head == entry) {
            head = newEntry;
        }
        if (tail == NULL) {
            tail = newEntry;
        }
    }

    // Other methods as necessary, such as append, etc.
}

除了将指向要插入的对象的指针传递到链接列表中之外，您绝对无需以一种方法对这些指针也产生副作用的方式传递指针。班级应该知道如何管理班级，并且不要怪异地传递变量。

对您的论点施加副作用时应格外小心。如果要将对象传递给方法，则可以合理地操作该对象。但是我真的不喜欢传递指针和让方法自己修改指针。

那将导致（充其量）混乱。

注意：我没有测试此代码。可能不是很完美。

引用调用时链接列表头指针未更新

1 个答案: