Delete Node In A Linked List

                                            
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 
class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
    }
};

                                            
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

void deleteNode(struct ListNode* node) {
    struct ListNode* temp = node->next;
    node->val = temp->val;
    node->next = temp->next;
    free(temp);
}

                                            
/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
var deleteNode = function(node) {
    node.val = node.next.val;
    node.next = node.next.next;
};

                                            
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     val: number
 *     next: ListNode | null
 *     constructor(val?: number, next?: ListNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.next = (next===undefined ? null : next)
 *     }
 * }
 */
function deleteNode(node: ListNode | null): void {
    if (node && node.next) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

                                            
/**
 * Definition for a singly-linked list.
 * class ListNode {
 *     public $val = 0;
 *     public ListNode $next = null;
 *     function __construct($val = 0) {
 *         $this->val = $val;
 *     }
 * }
 */

class Solution {

    /**
     * @param ListNode $node
     * @return NULL
     */
    function deleteNode($node) {
        $node->val = $node->next->val;
        $node->next = $node->next->next;
    }
}

                                            
/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func deleteNode(node *ListNode) {
    node.Val = node.Next.Val
    node.Next = node.Next.Next
}

                                            
class ListNode
    attr_accessor :val, :next
    def initialize(val)
        @val = val
        @next = nil
    end
end

def delete_node(node)
    node.val = node.next.val
    node.next = node.next.next
end

                                            
/**
 * Definition for singly-linked list.
 * class ListNode(var _x: Int = 0) {
 *   var next: ListNode = null
 */

object Solution {
    def deleteNode(node: ListNode): Unit = {
        node.x = node.next.x
        node.next = node.next.next
    }
}

To solve this coding challenge, you need to manipulate a singly-linked list such that a given node (excluding the last node) is effectively "deleted" from the list. A clever trick here involves copying the value from the next node into the node to be "deleted," then unlinking the next node.

Explanation

In a singly linked list, each node contains two parts: a value and a reference (or pointer) to the next node in the sequence. The challenge specifies that you will be given access only to the node to be deleted and not the head of the list. This is a crucial detail that influences the approach.

Detailed Steps in Pseudocode:

Step-by-Step Explanation

Understand Node Structure: Each node in a singly-linked list typically contains a value and a reference to the next node. Let's call the node to be deleted
node

.
Copy Next Node’s Value: Take the value from the node that comes immediately after
node

(i.e.,
node.next

) and copy it into
node

. This effectively overwrites the current node's value with the value of the next node.
Skip the Next Node: Adjust the
next

pointer of
node

to skip over the immediate next node. This can be done by setting
node.next

to
node.next.next

. This step essentially removes the next node from the list by bypassing it in the sequence.
Completion: After these operations, the
node

will contain the value that was in
node.next

, and the list will effectively skip over the original
node.next

.

Pseudocode with Comments:

                                            
# Define the function which takes the node to be deleted
function deleteNode(node):
# Step 1: Copy the value from the next node into the current node
node.value = node.next.value

# Step 2: Bypass the next node by pointing this node's next to next node's next
node.next = node.next.next

Detailed Steps in Pseudocode

Step 1: Copy the Value

Access the value of the node that comes immediately after the current node (i.e.,
node.next.value

).
Overwrite the current node's value with this value. This makes the current node act as if it is the next node.

Step 2: Adjust the Next Pointer

Change the
next

pointer of the current node to point to the node after the next node (i.e.,
node.next.next

).
This step effectively removes the "next" node from the linked list sequence because no nodes will be directly pointing to it anymore.

Example Walkthrough

Let's illustrate these steps using an example from the problem description:

Example 1:

Input: head = [4,5,1,9], node = 5

The node to be deleted has the value 5.

Before deletion:

List:
4 -> 5 -> 1 -> 9

Step-by-Step Execution:

Copy the value from the next node:

node.value

is
5

, and
node.next.value

is
1

.
After copying,
node.value

becomes
1

.

List state:

4 -> 1 -> 1 -> 9

Adjust the pointer:

node.next

is currently pointing to the node with value
1

.
Change
node.next

to point to
node.next.next

, which is the node with value
9

.

List state after deletion:

4 -> 1 -> 9

By following these detailed steps closely, you can ensure that the node is effectively deleted from the list without requiring access to the head of the list. The pseudocode provided gives a clear and concise way to achieve this in a coding implementation.