Невозможно создать или вернуть Перевернутый Связанный список - PullRequest
Новая
       50

Невозможно создать или вернуть Перевернутый Связанный список

0 голосов
/ 19 января 2020

Здесь с помощью функции returnReverseLinkedList я возвращаю перевернутый связанный список данного связанного списка. Но проблема с этим подходом состоит в том, что я теряю оригинальный связанный список. Поэтому я создаю еще одну функцию под названием createReversedLinkedList, чтобы создать copy of the original linked list и reverse the copy и сохранить владение обоими. к сожалению createReversedLinkedList дает Runtime error. очевидно, моей конечной целью является проверка if the given linked list is palindrome or not. Эта проблема - только ступенька. Может кто-нибудь сказать мне, почему? 

//Check if a linked list is a palindrome
#include <iostream>
using namespace std;
class node
{
public:
    int data;
    node *next;
    node(int data)
    {
        this->data = data;
        this->next = NULL;
    }
};

node *returnReverseLinkedList(node *head)
{
    // Will Lose original Linked List
    if (head == NULL)
        return NULL;
    else if (head != NULL && head->next == NULL)
        return head;

    node *prev = NULL;
    node *curr = head;
    node *tempNext = head->next;

    while (tempNext != NULL)
    {
        curr->next = prev;
        prev = curr;
        curr = tempNext;
        tempNext = tempNext->next;
    }

    curr->next = prev;
    return curr;
}
node *createReversedLinkedList(node *head)
{
    if (head == NULL)
        return NULL;
    else if (head != NULL && head->next == NULL)
        return NULL;
    else
    {
        node *temp = head;

        node *newHead = NULL;
        node *newTail = NULL;

        while (temp != NULL)
        {
            node *newNode = new node(temp->data);
            if (newHead == NULL)
            {
                newHead = newNode;
                newTail = newNode;
            }
            else
            {
                newTail->next = newNode;
                newTail = newNode;
            }
        }
        return returnReverseLinkedList(newHead);
    }
}

bool check_palindrome(node *head)
{
    node *original = head;
    node *reverse = returnReverseLinkedList(head);

    while (original->next != NULL || reverse->next != NULL)
    {
        if (original->data != reverse->data)
            return false;
        cout << "debug 2" << endl;
        original = original->next;
        reverse = reverse->next;
    }

    return true;
}
// #include "solution.h"
node *takeinput()
{
    int data;
    cin >> data;
    node *head = NULL, *tail = NULL;
    while (data != -1)
    {
        node *newnode = new node(data);
        if (head == NULL)
        {
            head = newnode;
            tail = newnode;
        }
        else
        {
            tail->next = newnode;
            tail = newnode;
        }
        cin >> data;
    }
    return head;
}
void print(node *head)
{
    node *temp = head;
    while (temp != NULL)
    {
        cout << temp->data << " ";
        temp = temp->next;
    }
    cout << endl;
}
int main()
{
    node *head = takeinput();
    node *revese2 = createReversedLinkedList(head);
    print(revese2);
    // bool ans = check_palindrome(head);
    // if (ans)
    //     cout << "true";
    // else
    //     cout << "false";
    // return 0;
}

1 Ответ

0 голосов
/ 19 января 2020

В соответствии с запросом OP, построение обратной ссылки просто выполняется путем построения, как если бы стек (например, LIFO), а не дублировал одну и ту же исходную прямую цепочку. Например: 

node *createReversedLinkedList(const node *head)
{
    node *newHead = NULL;
    for (; head; head = head->next)
    {
        node *p = new node(head->data)
        p->next = newHead;
        newHead = p;
    }
    return newHead;
}

Обратите внимание, что мы не вешаем наши скопированные узлы на хвост нового списка; они висят в заголовке нового списка и становятся новыми в каждом добавлении. Вот и все. Нет необходимости составлять идентичный список, а затем изменять его; вы можете перевернуть его при создании копии для начала.

Примечание к оставшейся части кода. У вас ужасная утечка памяти, даже если вы исправите процесс обращения, как я показал выше. В вашей функции check_palindrome вы никогда не освобождаете обратную динамическую c копию (и на самом деле вы не можете этого сделать, потому что после первого обхода вы отбрасываете оригинальный указатель, ссылающийся на его голову: 

bool check_palindrome(node *head)
{
    node *original = head;
    node *reverse = returnReverseLinkedList(head); // only reference to reversed copy

    while (original->next != NULL || reverse->next != NULL)
    {
        if (original->data != reverse->data)
            return false; // completely leaked entire reversed copy
        original = original->next;
        reverse = reverse->next; // lost original list head
    }

    return true;
}

Наиболее очевидный метод борьбы с этой ужасной утечкой - запомнить исходный список и использовать другой указатель для итерации, и не выходить из функции до тех пор, пока копия не будет освобождена. 

bool check_palindrome(const node *head)
{
    bool result = true;
    node *reverse = returnReverseLinkedList(head);

    for (node *p = reverse; p; p = p->next, head = head->next)
    {
        if (p->data != head->data)
        {
            result = false;
            break;
        }
    }

    while (reverse)
    {
        node *tmp = reverse;
        reverse = reverse->next;
        delete tmp;
    }

    return result;
}
...