XOR链表–在特定位置插入元素

给定一个XOR链表以及两个整数位置和值，任务是插入一个包含value的节点作为XOR链表的^第th个节点。

例子：

Input: 4<–>7<–>9<–>7, position = 3, value = 6
Output: 4<–>7<–>6<–>9<–>7
Explanation:
Inserting a node at the 3^rd position with value 6 modifies the given XOR Linked List to 4<–>7<–>6<–>9<–>7.

Input: 4<–>7<–>9<–>7, position=6, value=6
Output: Invalid Position
Explanation: Since the given list consists of only 4 elements, 6th position is an invalid position in the given list.

方法：请按照以下步骤解决问题：

• 初始化一个变量，例如说ctr，以在给定的XOR链表中保留遍历的节点数。
• 遍历给定的XOR链表。对于XOR链接列表的每个节点，检查当前节点的位置是否等于position 。如果发现是真的，则将节点插入给定的XOR链接列表中。
• 否则，将ctr增加1 。
• 如果遍历整个列表并且^{未获得第th个}节点的位置，则打印“ Invalid Position” 。

下面是上述方法的实现：

C

// C++ program to implement
// the above approach
  
#include 
#include 
#include 
  
// Structure of a node
// in XOR linked list
struct Node {
  
    // Stores data value
    // of a node
    int data;
  
    // Stores XOR of previous
    // pointer and next pointer
    struct Node* nxp;
};
  
// Function to find the XOR of two nodes
struct Node* XOR(struct Node* a,
                 struct Node* b)
{
    return (struct Node*)((uintptr_t)(a)
                          ^ (uintptr_t)(b));
}
  
// Function to insert a node with
// given value at given position
struct Node* insert(struct Node** head,
                    int value, int position)
{
    // If XOR linked list is empty
    if (*head == NULL) {
  
        // If given position
        // is equal to 1
        if (position == 1) {
  
            // Initialize a new Node
            struct Node* node
                = (struct Node*)malloc(
                    sizeof(struct Node));
  
            // Stores data value in
            // the node
            node->data = value;
  
            // Stores XOR of previous
            // and next pointer
            node->nxp = XOR(NULL, NULL);
  
            // Update pointer of head node
            *head = node;
        }
  
        // If required position was not found
        else {
            printf("Invalid Position\n");
        }
    }
  
    // If the XOR linked list
    // is not empty
    else {
  
        // Stores position of a node
        // in the XOR linked list
        int Pos = 1;
  
        // Stores the address
        // of current node
        struct Node* curr = *head;
  
        // Stores the address
        // of previous node
        struct Node* prev = NULL;
  
        // Stores the XOR of next
        // node and previous node
        struct Node* next
            = XOR(prev, curr->nxp);
  
        // Traverse the XOR linked list
        while (next != NULL && Pos < position - 1) {
  
            // Update prev
            prev = curr;
  
            // Update curr
            curr = next;
  
            // Update next
            next = XOR(prev, curr->nxp);
  
            // Update Pos
            Pos++;
        }
  
        // If the position of the current
        // node is equal to the given position
        if (Pos == position - 1) {
  
            // Initialize a new Node
            struct Node* node
                = (struct Node*)malloc(
                    sizeof(struct Node));
  
            // Stores pointer to previous Node
            // as (prev ^ next ^ next) = prev
            struct Node* temp
                = XOR(curr->nxp, next);
  
            // Stores XOR of prev and new node
            curr->nxp = XOR(temp, node);
  
            // Connecting new node with next
            if (next != NULL) {
  
                // Update pointer of next
                next->nxp = XOR(node,
                                XOR(next->nxp, curr));
            }
  
            // Connect node with curr and
            // next curr<--node-->next
            node->nxp = XOR(curr, next);
            node->data = value;
        }
  
        // Insertion node at beginning
        else if (position == 1) {
  
            // Initialize a new Node
            struct Node* node
                = (struct Node*)malloc(
                    sizeof(struct Node));
  
            // Update curr node address
            curr->nxp = XOR(node,
                            XOR(NULL, curr->nxp));
  
            // Update new node address
            node->nxp = XOR(NULL, curr);
  
            // Update head
            *head = node;
  
            // Update data value of
            // current node
            node->data = value;
        }
        else {
            printf("Invalid Position\n");
        }
    }
    return *head;
}
  
// Function to print elements of
// the XOR Linked List
void printList(struct Node** head)
{
    // Stores XOR pointer
    // in current node
    struct Node* curr = *head;
  
    // Stores XOR pointer of
    // in previous Node
    struct Node* prev = NULL;
  
    // Stores XOR pointer of
    // in next node
    struct Node* next;
  
    // Traverse XOR linked list
    while (curr != NULL) {
  
        // Print current node
        printf("%d ", curr->data);
  
        // Forward traversal
        next = XOR(prev, curr->nxp);
  
        // Update prev
        prev = curr;
  
        // Update curr
        curr = next;
    }
}
  
// Driver Code
int main()
{
    /* Create following XOR Linked List
    head-->20<-->40<-->10<-->30 */
    struct Node* head = NULL;
    insert(&head, 10, 1);
    insert(&head, 20, 1);
    insert(&head, 30, 3);
    insert(&head, 40, 2);
  
    // Print the new list
    printList(&head);
  
    return (0);
}

输出：

20 40 10 30

时间复杂度： O(N)
辅助空间： O(1)