Online Training
Q4 2024
Nov 19 to Dec 10
11.00 AM EST: USA, UK, Canada, Mexico and Europe
06.00 AM GMT: MiddleEast, Asia and Australia
A Node is a building block for more complex data structures. It stores a value and can link to another Node. In Python, you can create a Node class to handle these values and links.
class Node:
def __init__(self, value, next_node=None):
self.value = value
self.next_node = next_node
def set_next_node(self, next_node):
self.next_node = next_node
def get_next_node(self):
return self.next_node
def get_value(self):
return self.value
A Node is a part of a data structure that holds data and can link to other Nodes. Nodes are used in structures like linked lists and trees, where you can move from one Node to another.
Nodes that are not connected to any other nodes are called orphaned. For example, if you remove certain nodes from a linked list, the remaining nodes might become orphaned.
In data structures, a Node typically stores two pieces of information: the data it holds and a link to the next Node.
A linked list is a series of Nodes where each Node points to the next one. This allows for efficient insertion and removal of elements. Here’s how you can implement a simple linked list in Python.
class LinkedList:
def __init__(self, value=None):
self.head_node = Node(value)
def get_head_node(self):
return self.head_node
def insert_beginning(self, new_value):
new_node = Node(new_value)
new_node.set_next_node(self.head_node)
self.head_node = new_node
def stringify_list(self):
string_list = ""
current_node = self.get_head_node()
while current_node:
if current_node.get_value() != None:
string_list += str(current_node.get_value()) + "\n"
current_node = current_node.get_next_node()
return string_list
def remove_node(self, value_to_remove):
current_node = self.get_head_node()
if current_node.get_value() == value_to_remove:
self.head_node = current_node.get_next_node()
else:
while current_node:
next_node = current_node.get_next_node()
if next_node and next_node.get_value() == value_to_remove:
current_node.set_next_node(next_node.get_next_node())
break # Exit after removal
current_node = next_node
To remove a node from a linked list, you need to adjust the link of the previous node so that it points to the node after the one being removed.
A linked list is a type of data structure where each element (or Node) points to the next. This way, elements are not stored in consecutive memory locations but are linked together.
To add a new node to the beginning of a linked list, you need to make this new node point to the current head node, and then update the head node to the new node.
The head node is the first node in a linked list. When adding a new node at the start, the new node becomes the new head and points to the old head.
The head node is the starting point of a linked list. If the list is empty, the head node is set to None.
A Stack is a data structure where items are added and removed from the top only. Think of it like a stack of plates: you add plates to the top and also remove them from the top.
from node import Node
class Stack:
def __init__(self, limit=1000):
self.top_item = None
self.size = 0
self.limit = limit
def push(self, value):
if self.has_space():
item = Node(value)
item.set_next_node(self.top_item)
self.top_item = item
self.size += 1
else:
print("All out of space!")
def pop(self):
if self.size > 0:
item_to_remove = self.top_item
self.top_item = item_to_remove.get_next_node()
self.size -= 1
return item_to_remove.get_value()
else:
print("This stack is totally empty.")
def peek(self):
if self.size > 0:
return self.top_item.get_value()
else:
print("Nothing to see here!")
def has_space(self):
return self.limit > self.size
def is_empty(self):
return self.size == 0
A stack overflow occurs when you try to add an item to a stack that is already full. This is like trying to add another plate to a stack that's already at its limit.
A stack keeps track of how many items are in it. If you try to add an item to a full stack, you’ll get a stack overflow error.
A stack typically supports operations like push (adding an item), pop (removing the top item), and peek (looking at the top item without removing it).
A queue has several basic methods like enqueue (adding an item), dequeue (removing an item), and peek (looking at the first item).
A queue is a data structure where items are added at the end and removed from the front, following the First In, First Out (FIFO) principle.
Favourites
Monitor your IT infrastructure effortlessly with Site24x7 and get comprehensive insights and ensure smooth operations with 24/7 monitoring.
Sign up now
Welcome to our comprehensive collection of programming language cheatsheets! Whether you're a seasoned developer or a beginner, these quick reference guides provide essential tips and key information for all major languages. They focus on core concepts, commands, and functions—designed to enhance your efficiency and productivity.
ManageEngine Site24x7, a leading IT monitoring and observability platform, is committed to equipping developers and IT professionals with the tools and insights needed to excel in their fields.
Monitor your IT infrastructure effortlessly with Site24x7 and get comprehensive insights and ensure smooth operations with 24/7 monitoring.
Sign up now!
Java
HTML and CSS 
Python
Javascript
Troubleshooting
Blogs
Learn
Tools