[Clone Linked List со следующим и случайным указателем] [Runtime Error]

Question

Я пытаюсь ответить на этот вопрос с помощью хеширования.https://practice.geeksforgeeks.org/problems/clone-a-linked-list-with-next-and-random-pointer/1

Мне нужно только реализовать эту функцию.

Вот мой код.

struct Hash
{
    struct Node*orig;
    struct Node*copy;
};
 struct Hash H[10005];
void put(Node*k,Node*v)
{
    int idx=k->data;
    H[idx].orig=k;
    H[idx].copy=v;
}
Node* get(Node *k)
{
    int idx=k->data;
    return(H[idx].copy);
}
Node*getnode(int v)
{
    Node*newnode=NULL;
    newnode=(Node*)malloc(sizeof(Node));
    newnode->data=v;
    newnode->next=NULL;
    newnode->arb=NULL;
    return newnode;
}
void init_hash()
{
    for(int i=0;i<10005;i++)
    {
        H[i].orig=NULL;
        H[i].copy=NULL;
    }
}
Node * copyList(Node *head)
{
     // Your code her
     Node*curr=head;
     Node*headcopy=NULL;
     Node*tailcopy=NULL;
     init_hash();
     while(curr)
     {
         Node * newnode=getnode(curr->data);    
         if(headcopy==NULL)
         headcopy=newnode;
         put(curr,newnode);
         curr=curr->next;
     }

     curr=head;
     while(curr)
     {
         Node*copycurr=get(curr);
         //if(copycurr!=NULL)
        // copycurr->next=(struct Node*)malloc(sizeof(struct Node));
         copycurr->next=get(curr->next);
         //if(copycurr!=NULL)
         //copycurr->arb=(struct Node*)malloc(sizeof(struct Node));
         copycurr->arb=get(curr->arb);
         curr=curr->next;
     }
    return headcopy;
}

Выдает ошибку RunTime.Я могу думать о причине.Я инициализирую next и random как Null, а затем делаю

copycurr->next=get(curr->next);
copycurr->arb=get(curr->arb);

Если я закомментирую эти строки, прогоны программы, конечно, неправильный вывод.

Я также попытался закомментировать инициализацию next и random как NULLно все та же ошибка.Может кто-нибудь, пожалуйста, предложите, какую ошибку я делаю.Я хочу решить, используя мой собственный хэш.

Edit1: добавление полного кода в соответствии с комментариями:

        #include <bits/stdc++.h>
        using namespace std;
        struct Node
        {
        int data;
        Node* next;
        Node* arb;
        };
        Node *newNode(int data)
        {
            Node *new_node = new Node;
            new_node->data = data;
            new_node->next = NULL;
            new_node->arb=NULL;
            return new_node;
        }
        void print(Node *root)
        {
        Node *temp = root;
        while(temp!=NULL )
        {
        int k;
        if(temp->arb==NULL)k=-1;
        else k=temp->arb->data;
        cout<<temp->data<<" "<<k<<" ";
        temp=temp->next;
        }
        }
        //Node * copyList(Node *head);
        void append( Node** head_ref, Node **tail_ref, int new_data)
        {
            Node* new_node = new Node;
            new_node->data  = new_data;
            new_node->next = NULL;
            new_node->arb=NULL;
            if (*head_ref == NULL){
               *head_ref = new_node;
            }
            else
               (*tail_ref)->next = new_node;
            *tail_ref = new_node;
        }
        bool validation(Node *head,Node * res,Node *cloned_addr,Node *generated_addr)
        {
            if(generated_addr==cloned_addr)
                return false;
            Node* temp1 = head;
            Node *temp2 = res;
            int len1=0,len2=0;
            while(temp1!=NULL)
            {
                len1++;
                temp1=temp1->next;
            }
            while(temp2!=NULL)
            {
                len2++;
                temp2 = temp2->next;
            }
            /*if lengths not equal */
            if(len1!=len2)
            return false;
            temp1= head;
            temp2=res;
            while(temp1!=NULL)
            {
                if(temp1->data!=temp2->data)
                return false;
                if(temp1->arb!=NULL and temp2->arb!=NULL)
                {
                    if(temp1->arb->data!=temp2->arb->data)
                    return false;
                }else if(temp1->arb!=NULL and temp2->arb==NULL)
                    return false;
                temp1= temp1->next;
                temp2=temp2->next;
            }
            return true;
        }

        struct Hash
            {
                struct Node*orig;
                struct Node*copy;
            };
             struct Hash H[10005];
            void put(Node*k,Node*v)
            {
                int idx=k->data;
                H[idx].orig=k;
                H[idx].copy=v;
            }
            Node* get(Node *k)
            {
                int idx=k->data;
                return(H[idx].copy);
            }
            Node*getnode(int v)
            {
                Node*newnode=NULL;
                newnode=(Node*)malloc(sizeof(Node));
                newnode->data=v;
                newnode->next=NULL;
                newnode->arb=NULL;
                return newnode;
            }
            void init_hash()
            {
                for(int i=0;i<10005;i++)
                {
                    H[i].orig=NULL;
                    H[i].copy=NULL;
                }
            }
            Node * copyList(Node *head)
            {
                 // Your code her
                 Node*curr=head;
                 Node*headcopy=NULL;
                 Node*tailcopy=NULL;
                 init_hash();
                 while(curr)
                 {
                     Node * newnode=getnode(curr->data);    
                     if(headcopy==NULL)
                     headcopy=newnode;
                     put(curr,newnode);
                     curr=curr->next;
                 }

                 curr=head;
                 while(curr)
                 {
                     Node*copycurr=get(curr);
                     //if(copycurr!=NULL)
                    // copycurr->next=(struct Node*)malloc(sizeof(struct Node));
                     copycurr->next=get(curr->next);
                     //if(copycurr!=NULL)
                     //copycurr->arb=(struct Node*)malloc(sizeof(struct Node));
                     copycurr->arb=get(curr->arb);
                     curr=curr->next;
                 }
                return headcopy;
            }
        /* Driver program to test above function*/
        int main()
        {
          int T,i,n,l,k;
          Node* generated_addr=NULL;
        /*reading input stuff*/
            cin>>T;
            while(T--){
            generated_addr=NULL;
            struct Node *head = NULL,  *tail = NULL;
                cin>>n>>k;
                for(i=1;i<=n;i++)
                {
                    cin>>l;
                    append(&head, &tail, l);
                }
               for(int i=0;i<k;i++){
               int a,b;
               cin>>a>>b;
               Node *tempA=head;
               int count=-1;
               while(tempA!=NULL)
               {
                   count++;
                   if(count==a-1)
                    break;
                   tempA=tempA->next;
               }
               Node *tempB = head;
               count=-1;
               while(tempB!=NULL)
               {
                   count++;
                   if(count==b-1)
                    break;
                   tempB=tempB->next;
               }
               //when both a is greater than N
               if(a<=n)
               tempA->arb = tempB;
               }
        /*read finished*/
               generated_addr=head;
               Node *res = copyList(head);
               Node *cloned_addr = res;
               cout<<validation(head,res,cloned_addr,generated_addr)<<endl;
               }
            return 0;
        }