Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Golang Program to Insert a Node in a Sorted Doubly Linked List
A doubly linked list could be an information structure where each node contains a reference to both its previous and following nodes. The program points to preserve the sorted arrangement of the linked list whereas inserting an unused node. In this article, we will learn to create a Golang program that focuses on inserting a node into a sorted doubly linked list. Here we are going to use the method insertNode along with examples to elaborate on the concept.
Syntax
func insertNode(head *Node, value int) *Node
This Syntax represents a function named "insertNode" that takes a pointer to the head node of a doubly linked list and an integer value as parameters. It will insert a new node with the given value into the list and return the updated head node.
head.prev
head represent a node that is a starting point of a list., the prev represent the last node of the list.
current = next.prev
This is used to update the current node by moving to its previous node.
current.value
This represents the value stored in the current node of the list.
Algorithm
Create a new node with the given data that needs to be inserted.
If the doubly linked list is empty, make the new node the head of the list and return it.
Traverse the doubly linked list starting from the head until you find the appropriate position to insert the new node.
Compare the data of the current node with the data of the new node to determine the correct position.
Once the correct position is found, update the pointers of the previous and next nodes to include the new node.
Adjust the pointers of the new node to connect it with the previous and next nodes in the doubly linked list.
Return the updated doubly linked list with the new node inserted at the appropriate position
Example
In this example, we have implemented a method called insertNode for inserting a node in a sorted doubly linked list. The method takes the head of the list and the value of the node to be inserted as input parameters. In the main function, we create a sample doubly linked list with values 10, 20, and 30. We print the original list, then call the insertNode method to insert a node with a value of 25. Finally, we print the updated list after the insertion. This code demonstrates how the insertNode method can be used to insert a node in a sorted doubly linked list while maintaining the sorted order.
package main
import "fmt"
type Node struct {
value int
prev, next *Node
}
func insertNode(head *Node, value int) *Node {
newNode := &Node{value: value}
if head == nil {
return newNode
}
if value < head.value {
newNode.next = head
head.prev = newNode
return newNode
}
current := head
for current.next != nil && current.next.value < value {
current = current.next
}
newNode.next = current.next
if current.next != nil {
current.next.prev = newNode
}
current.next = newNode
newNode.prev = current
return head
}
func printList(head *Node) {
current := head
for current != nil {
fmt.Printf("%d ", current.value)
current = current.next
}
fmt.Println()
}
func main() {
head := &Node{value: 10}
node1 := &Node{value: 20}
node2 := &Node{value: 30}
head.next = node1
node1.prev = head
node1.next = node2
node2.prev = node1
fmt.Println("Original List:")
printList(head)
head = insertNode(head, 25)
fmt.Println("Updated List:")
printList(head)
}
Output
Original List: 10 20 30 Updated List: 10 20 25 30
Conclusion
In the Conclusion, we discussed The Golang program for inserting a node in a sorted doubly linked list permits the user to preserve the sorted arrangement of the list whereas inserting unused nodes. By navigating the list and altering the pointers, the program validates that the unused node is inserted at the proper position. This calculation gives a proficient way to oversee sorted doubly connected nodes in Golang.
103 Views
