1.
Array Implementation
An array is a collection of elements, all of the same type, stored in contiguous memory locations.
public class ArrayExample
{
private int[] arr; // Array to store elements
private int size; // Size of the array
// Constructor to initialize the array with a given size
public ArrayExample(int size)
{
this.size = size;
arr = new int[size];
}
// Method to insert a value at a specific index
public void Insert(int index, int value)
{
if (index >= 0 && index < size)
{
arr[index] = value; // Insert the value if the index is valid
Console.WriteLine("Inserted {0} at index {1}", value, index);
}
else
{
Console.WriteLine("Index out of bounds."); // Handle invalid index
}
}
// Method to retrieve a value at a specific index
public int Get(int index)
{
if (index >= 0 && index < size)
{
return arr[index]; // Return the value if the index is valid
}
else
{
Console.WriteLine("Index out of bounds.");
return -1; // Return a sentinel value for an invalid index
}
}
// Method to display all elements in the array
public void DisplayArray()
{
Console.WriteLine("Array elements:");
for (int i = 0; i < size; i++)
{
Console.Write(arr[i] + " ");
}
Console.WriteLine();
}
}
Explanation:
Array Declaration: int[] arr; declares an array to store integer elements.
Insert Method: Adds an element at a specified index. It checks if the index is within bounds before inserting
the value.
Get Method: Retrieves an element at a specified index. It checks if the index is valid and returns the
element; otherwise, it returns a sentinel value.
DisplayArray Method: Loops through the array and prints all elements.
2. Stack Implementation
A stack is a linear data structure that follows the Last In, First Out (LIFO) principle, meaning the last element added is
the first to be removed.
public class StackExample
{
private int[] stackArray; // Array to store stack elements
private int top; // Index of the top element
private int maxSize; // Maximum size of the stack
// Constructor to initialize the stack with a given size
public StackExample(int size)
{
maxSize = size;
stackArray = new int[maxSize];
top = -1; // Stack is initially empty
}
// Method to push an element onto the stack
public void Push(int value)
{
if (top == maxSize - 1)
{
Console.WriteLine("Stack Overflow! Cannot push {0}.", value);
}
else
{
stackArray[++top] = value; // Increment top and add value
Console.WriteLine("Pushed {0} to stack.", value);
}
}
// Method to pop the top element from the stack
public int Pop()
{
if (top == -1)
{
Console.WriteLine("Stack Underflow! No element to pop.");
return -1; // Return a sentinel value for an empty stack
}
else
{
return stackArray[top--]; // Return the top element and decrement top
}
}
// Method to display all elements in the stack
public void DisplayStack()
{
if (top == -1)
{
Console.WriteLine("Stack is empty.");
return;
}
Console.WriteLine("Stack elements are:");
for (int i = 0; i <= top; i++)
{
Console.Write(stackArray[i] + " ");
}
Console.WriteLine();
}
}
Explanation:
Push Method: Adds an element to the top of the stack. It checks if the stack is full (overflow) before adding
the element.
Pop Method: Removes and returns the top element. It checks if the stack is empty (underflow) before
removing the element.
DisplayStack Method: Prints all the elements currently in the stack from bottom to top.
3. Queue Implementation
A queue is a linear data structure that follows the First In, First Out (FIFO) principle, meaning the first element added
is the first to be removed.
public class QueueExample
{
private int[] queueArray; // Array to store queue elements
private int front; // Index of the front element
private int rear; // Index of the rear element
private int maxSize; // Maximum size of the queue
// Constructor to initialize the queue with a given size
public QueueExample(int size)
{
maxSize = size;
queueArray = new int[maxSize];
front = 0;
rear = -1; // Queue is initially empty
}
// Method to enqueue an element to the rear of the queue
public void Enqueue(int value)
{
if (rear == maxSize - 1)
{
Console.WriteLine("Queue Overflow! Cannot enqueue {0}.", value);
}
else
{
queueArray[++rear] = value; // Increment rear and add value
Console.WriteLine("Enqueued {0} to queue.", value);
}
}
// Method to dequeue the front element from the queue
public int Dequeue()
{
if (front > rear)
{
Console.WriteLine("Queue Underflow! No element to dequeue.");
return -1; // Return a sentinel value for an empty queue
}
else
{
return queueArray[front++]; // Return the front element and increment front
}
}
// Method to display all elements in the queue
public void DisplayQueue()
{
if (front > rear)
{
Console.WriteLine("Queue is empty.");
return;
}
Console.WriteLine("Queue elements are:");
for (int i = front; i <= rear; i++)
{
Console.Write(queueArray[i] + " ");
}
Console.WriteLine();
}
}
Explanation:
Enqueue Method: Adds an element to the rear of the queue. It checks if the queue is full (overflow) before
adding the element.
Dequeue Method: Removes and returns the front element. It checks if the queue is empty (underflow)
before removing the element.
DisplayQueue Method: Prints all the elements currently in the queue from front to rear.
4. Linked List Implementation
A linked list is a linear data structure where each element (node) contains a reference to the next node, forming a
chain.
public class Node
{
public int Data; // The value stored in the node
public Node Next; // The reference to the next node
public Node(int data)
{
Data = data;
Next = null; // Initialize the next reference as null
}
}
public class LinkedList
{
private Node head; // Reference to the first node in the list
public LinkedList()
{
head = null;
}
// Method to add a node at the end of the list
public void AddNode(int data)
{
Node newNode = new Node(data); // Create a new node
if (head == null) // If the list is empty
{
head = newNode;
}
else
{
Node current = head;
while (current.Next != null)
{
current = current.Next; // Traverse to the end of the list
}
current.Next = newNode; // Attach the new node
}
}
// Method to remove a node with specific data
public void RemoveNode(int data)
{
if (head == null)
{
Console.WriteLine("List is empty.");
return;
}
if (head.Data == data)
{
head = head.Next; // Remove the head node
return;
}
Node current = head;
Node previous = null;
while (current != null && current.Data != data)
{
previous = current;
current = current.Next; // Traverse the list
}
if (current == null)
{
Console.WriteLine("Node with data {0} not found.", data);
return;
}
previous.Next = current.Next; // Remove the node
}
// Method to traverse and print the list
public void PrintList()
{
Node current = head;
if (current == null)
{
Console.WriteLine("List is empty.");
return;
}
while (current != null)
{
Console.Write(current.Data + " -> ");
current = current.Next;
}
Console.WriteLine("null");
}
}
Explanation:
Node Class: Represents each element in the linked list. It contains the data and a reference to the next node.
LinkedList Class: Manages the linked list operations like adding, removing, and printing nodes.
AddNode Method: Adds a new node to the end of the list.
RemoveNode Method: Removes the first node that contains the specified data.
PrintList Method: Traverses the list and prints all the nodes from head to the last node.
Summary:
Array: A simple, fixed-size data structure that stores elements in contiguous memory locations. Allows direct
access via indices.
Stack: A LIFO data structure implemented using an array. Elements are added and removed from the same
end (top).
Queue: A FIFO data structure implemented using an array. Elements are added to the rear and removed
from the front.
Linked List: A dynamic data structure where each element points to the next. Allows easy insertion and
deletion of nodes without the need for shifting elements, unlike arrays.
