Med tanke på en enskilt länkad lista är uppgiften att ta bort den mellersta noden på listan.
- Om listan innehåller ett jämnt antal noder kommer det att finnas två mellannoder. I detta fall radera den andra mellersta noden.
- Om den länkade listan består av endast en nod, returnera noll.
Exempel:
Input: LinkedList: 1-> 2-> 3-> 4-> 5
Produktion: 1-> 2-> 4-> 5
Förklaring:
Input: LinkedList: 2-> 4-> 6-> 7-> 5-> 1
Produktion: 2-> 4-> 6-> 5-> 1
Förklaring:
Input: LinkedList: 7
Produktion:
Innehållsbord
- [Naivt tillvägagångssätt] Användning av två -pass -traversal - O (n) Tid och O (1) utrymme
- [Förväntat tillvägagångssätt] En -pass -traversal med långsamma och snabba pekare - O (n) Tid och O (1) utrymme
[Naivt tillvägagångssätt] Användning av två -pass -traversal - O (n) Tid och O (1) utrymme
Den grundläggande idén bakom detta tillvägagångssätt är att först korsa hela den länkade listan för att räkna det totala antalet noder. När vi vet det totala antalet noder kan vi beräkna positionen för den mellersta noden som är vid index n/2 (där n är det totala antalet noder). Gå sedan igenom den länkade listan igen men den här gången stannar vi precis före mellersta noden. När vi är där modifierar vi nästa pekare på noden före den mellersta noden så att den hoppar över den mellersta noden och pekar direkt på noden efter den
Nedan är implementeringen av ovanstående tillvägagångssätt:
C++
// C++ program to delete middle of a linked list #include
// C program to delete middle of a linked list #include
// Java program to delete middle of a linked list class Node { int data; Node next; Node(int x) { data = x; next = null; } } public class GfG { // Function to delete middle node from linked list. public static Node deleteMid(Node head) { // Edge case: return null if there is only // one node. if (head.next == null) return null; int count = 0; Node p1 = head p2 = head; // First pass count the number of nodes // in the linked list using 'p1'. while (p1 != null) { count++; p1 = p1.next; } // Get the index of the node to be deleted. int middleIndex = count / 2; // Second pass let 'p2' move toward predecessor // of the middle node. for (int i = 0; i < middleIndex - 1; ++i) p2 = p2.next; // Delete the middle node and return 'head'. p2.next = p2.next.next; return head; } public static void printList(Node head) { Node temp = head; while (temp != null) { System.out.print(temp.data + ' -> '); temp = temp.next; } System.out.println('null'); } public static void main(String[] args) { // Create a static hardcoded linked list: // 1 -> 2 -> 3 -> 4 -> 5. Node head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); System.out.print('Original Linked List: '); printList(head); // Delete the middle node. head = deleteMid(head); System.out.print ('Linked List after deleting the middle node: '); printList(head); } }
# Python3 program to delete middle of a linked list class Node: def __init__(self data): self.data = data self.next = None # Function to delete middle node from linked list. def deleteMid(head): # Edge case: return None if there is only # one node. if head.next is None: return None count = 0 p1 = head p2 = head # First pass count the number of nodes # in the linked list using 'p1'. while p1 is not None: count += 1 p1 = p1.next # Get the index of the node to be deleted. middleIndex = count // 2 # Second pass let 'p2' move toward the predecessor # of the middle node. for i in range(middleIndex - 1): p2 = p2.next # Delete the middle node and return 'head'. p2.next = p2.next.next return head def printList(head): temp = head while temp is not None: print(temp.data end=' -> ') temp = temp.next print('None') if __name__ == '__main__': # Create a static hardcoded linked list: # 1 -> 2 -> 3 -> 4 -> 5. head = Node(1) head.next = Node(2) head.next.next = Node(3) head.next.next.next = Node(4) head.next.next.next.next = Node(5) print('Original Linked List:' end=' ') printList(head) # Delete the middle node. head = deleteMid(head) print('Linked List after deleting the middle node:' end=' ') printList(head)
// C# program to delete middle of a linked list using System; class Node { public int data; public Node next; public Node(int x) { data = x; next = null; } } class GfG { // Function to delete middle node from linked list. static Node deleteMid(Node head) { // Edge case: return null if there is only // one node. if (head.next == null) return null; int count = 0; Node p1 = head p2 = head; // First pass count the number of nodes // in the linked list using 'p1'. while (p1 != null) { count++; p1 = p1.next; } // Get the index of the node to be deleted. int middleIndex = count / 2; // Second pass let 'p2' move toward the predecessor // of the middle node. for (int i = 0; i < middleIndex - 1; ++i) p2 = p2.next; // Delete the middle node and return 'head'. p2.next = p2.next.next; return head; } static void printList(Node head) { Node temp = head; while (temp != null) { Console.Write(temp.data + ' -> '); temp = temp.next; } Console.WriteLine('null'); } static void Main(string[] args) { // Create a static hardcoded linked list: // 1 -> 2 -> 3 -> 4 -> 5. Node head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); Console.Write('Original Linked List: '); printList(head); // Delete the middle node. head = deleteMid(head); Console.Write ('Linked List after deleting the middle node: '); printList(head); } }
class Node { constructor(data) { this.data = data; this.next = null; } } // Function to delete middle node from linked list. function deleteMid(head) { // Edge case: return null if there is only // one node. if (head.next === null) return null; let count = 0; let p1 = head p2 = head; // First pass count the number of nodes // in the linked list using 'p1'. while (p1 !== null) { count++; p1 = p1.next; } // Get the index of the node to be deleted. let middleIndex = Math.floor(count / 2); // Second pass let 'p2' move toward the predecessor // of the middle node. for (let i = 0; i < middleIndex - 1; ++i) p2 = p2.next; // Delete the middle node and return 'head'. p2.next = p2.next.next; return head; } function printList(head) { let temp = head; while (temp !== null) { console.log(temp.data + ' -> '); temp = temp.next; } console.log('null'); } // Create a static hardcoded linked list: // 1 -> 2 -> 3 -> 4 -> 5. let head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); console.log('Original Linked List: '); printList(head); // Delete the middle node. head = deleteMid(head); console.log('Linked List after deleting the middle node: '); printList(head);
Produktion
Original Linked List: 1 -> 2 -> 3 -> 4 -> 5 -> nullptr Linked List after deleting the middle node: 1 -> 2 -> 4 -> 5 -> nullptr
Tidskomplexitet: På). Två övergångar i den länkade listan behövs
Hjälputrymme: O (1). Inget extra utrymme behövs.
[Förväntat tillvägagångssätt] en -pass -traversal med långsamma och snabba pekare - O (n) Tid och O (1) utrymme
Ovanstående lösning kräver två övergångar i den länkade listan. Mittnoden kan raderas med en traversal. Tanken är att använda två pekare slow_ptr och fast_ptr . Den snabba pekaren rör sig två noder åt gången medan den långsamma pekaren rör sig en nod åt gången. När den snabba pekaren når slutet av listan kommer den långsamma pekaren att placeras vid den mellersta noden. Nästa måste du ansluta noden som kommer före mellersta noden ( föregångare ) till den nod som kommer efter den mellersta noden. Detta hoppar effektivt över den mellersta noden som tar bort den från listan.
Nedan är implementeringen av ovanstående tillvägagångssätt
C++// C++ program to delete middle of a linked list #include
// C program to delete middle of a linked list #include
// Java program to delete the middle of a linked list class Node { int data; Node next; Node(int x) { data = x; next = null; } } class GfG { // Function to delete middle node from linked list static Node deleteMid(Node head) { // If the list is empty return null if (head == null) return null; // If the list has only one node // delete it and return null if (head.next == null) { return null; } Node prev = null; Node slow_ptr = head; Node fast_ptr = head; // Move the fast pointer 2 nodes ahead // and the slow pointer 1 node ahead // until fast pointer reaches end of list while (fast_ptr != null && fast_ptr.next != null) { fast_ptr = fast_ptr.next.next; // Update prev to hold the previous // slow pointer value prev = slow_ptr; slow_ptr = slow_ptr.next; } // At this pointslow_ptr points to middle node // Bypass the middle node prev.next = slow_ptr.next; // Return the head of the modified list return head; } static void printList(Node head) { Node temp = head; while (temp != null) { System.out.print(temp.data + ' -> '); temp = temp.next; } System.out.println('NULL'); } public static void main(String[] args) { // Create a static hardcoded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); System.out.print('Original Linked List: '); printList(head); // Delete the middle node head = deleteMid(head); System.out.print ('Linked List after deleting the middle node: '); printList(head); } }
# Python program to delete the middle of a linked list class Node: def __init__(self data): self.data = data self.next = None # Function to delete middle node from linked list def deleteMid(head): # If the list is empty return None if head is None: return None # If the list has only one node # delete it and return None if head.next is None: return None prev = None slow_ptr = head fast_ptr = head # Move the fast pointer 2 nodes ahead # and the slow pointer 1 node ahead # until fast pointer reaches end of the list while fast_ptr is not None and fast_ptr.next is not None: fast_ptr = fast_ptr.next.next # Update prev to hold the previous # slow pointer value prev = slow_ptr slow_ptr = slow_ptr.next # At this point slow_ptr points to middle node # Bypass the middle node prev.next = slow_ptr.next # Return the head of the modified list return head def printList(head): temp = head while temp: print(temp.data end=' -> ') temp = temp.next print('NULL') if __name__ == '__main__': # Create a static hardcoded linked list: # 1 -> 2 -> 3 -> 4 -> 5 head = Node(1) head.next = Node(2) head.next.next = Node(3) head.next.next.next = Node(4) head.next.next.next.next = Node(5) print('Original Linked List: ' end='') printList(head) # Delete the middle node head = deleteMid(head) print('Linked List after deleting the middle node: ' end='') printList(head)
// C# program to delete middle of a linked list using System; class Node { public int data; public Node next; public Node(int x) { data = x; next = null; } } class GfG { // Function to delete middle node from linked list public static Node deleteMid(Node head) { // If the list is empty return null if (head == null) return null; // If the list has only one node // delete it and return null if (head.next == null) { return null; } Node prev = null; Node slow_ptr = head; Node fast_ptr = head; // Move the fast pointer 2 nodes ahead // and the slow pointer 1 node ahead // until fast pointer reaches end of the list while (fast_ptr != null && fast_ptr.next != null) { fast_ptr = fast_ptr.next.next; // Update prev to hold the previous // slow pointer value prev = slow_ptr; slow_ptr = slow_ptr.next; } // At this point slow_ptr points to middle node // Bypass the middle node prev.next = slow_ptr.next; // Return the head of the modified list return head; } // Function to print the linked list public static void printList(Node head) { Node temp = head; while (temp != null) { Console.Write(temp.data + ' -> '); temp = temp.next; } Console.WriteLine('NULL'); } public static void Main(string[] args) { // Create a static hardcoded linked list: // 1 -> 2 -> 3 -> 4 -> 5 Node head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); Console.Write('Original Linked List: '); printList(head); // Delete the middle node head = deleteMid(head); Console.Write ('Linked List after deleting the middle node: '); printList(head); } }
// javascript program to delete middle of a linked list class Node { constructor(data) { this.data = data; this.next = null; } } // Function to delete the middle node from the linked list function deleteMid(head) { // If the list is empty return null if (head === null) { return null; } // If the list has only one node delete it and return // null if (head.next === null) { return null; } let prev = null; let slow_ptr = head; let fast_ptr = head; // Move the fast pointer 2 nodes ahead // and the slow pointer 1 node ahead // until the fast pointer reaches the end of the list while (fast_ptr !== null && fast_ptr.next !== null) { fast_ptr = fast_ptr.next.next; // Update prev to hold the previous slow pointer // value prev = slow_ptr; slow_ptr = slow_ptr.next; } // At this point slow_ptr points to the middle node // Bypass the middle node prev.next = slow_ptr.next; // Return the head of the modified list return head; } function printList(head) { let temp = head; while (temp !== null) { process.stdout.write(temp.data + ' -> '); temp = temp.next; } console.log('null'); } // Create a static hardcoded linked list: // 1 -> 2 -> 3 -> 4 -> 5 let head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); process.stdout.write('Original Linked List: '); printList(head); // Delete the middle node head = deleteMid(head); process.stdout.write( 'Linked List after deleting the middle node: '); printList(head);
Produktion
Original Linked List: 1 -> 2 -> 3 -> 4 -> 5 -> NULL Linked List after deleting the middle node: 1 -> 2 -> 4 -> 5 -> NULL
Tidskomplexitet: På). Endast en genomgång av den länkade listan behövs
Hjälputrymme: O (1). Eftersom inget extra utrymme behövs.
Relaterad artikel:
- Hitta mitten av den länkade listan