O(log n)

O(n^2)

O(n)

O(n log n)

Binary Search requires the data to be unsorted for efficient searching.

Binary Search can only be applied to small datasets for optimal performance.

Binary Search reduces the search space by half with each comparison, achieving O(log n) time complexity.

Binary Search checks every element sequentially, achieving O(n) time complexity.

Insertion, Deletion, Traversal, Searching, Reversing

Sorting, Merging, Filtering

Indexing, Hashing, Stacking

Appending, Cloning, Splitting

Both Stacks and Queues use LIFO order.

Stacks can be accessed from both ends, while Queues can only be accessed from one end.

Stacks use LIFO order, while Queues use FIFO order.

Stacks use FIFO order, while Queues use LIFO order.

Only compare the key with the last element in the sorted part.

Start with the second element (index 1) as the key. Compare the key with the elements in the sorted part (to its left). Shift all elements that are greater than the key to the right. Insert the key in its correct position. Repeat the process for all elements until the entire array is sorted.

Sort the entire array in descending order first.

Start with the last element as the key.

A Linked List allows for random access to elements like an array.

A Linked List is a dynamic data structure with nodes linked sequentially, differing from arrays which are fixed-size and allow direct index-based access.

Arrays are more flexible than Linked Lists in terms of memory allocation.

A Linked List is a static data structure that requires a fixed size.

Selection Sort is faster than Quick Sort for large datasets.

The time complexity of Selection Sort is O(n^2), where n is the number of elements in the list.

The time complexity of Selection Sort is O(n log n).

Selection Sort is an in-place sorting algorithm with O(n) time complexity.

A stack can be implemented using a linked list by using the head as the top and performing push and pop operations on the head.

A stack can be implemented using an array with fixed size.

A stack requires a binary tree for its implementation.

A stack can only be implemented using a queue.

The advantages include dynamic size, efficient O(1) operations, and no wasted space.

Increased memory overhead

Fixed size limits

Inefficient O(n) operations

O(n)

O(log n)

O(n^2)

O(n log n)

Merge Sort sorts the array in place without dividing.

Merge Sort divides the array into three equal parts.

Merge Sort divides the array into two halves recursively.

Merge Sort only sorts the first half of the array.

The head is the starting point for traversal, and the tail indicates the end of the list.

The head is the end of the list, and the tail is the starting point.

The head and tail are used to store data values only.

The head is used for sorting, and the tail is for searching.

Push operation checks if the stack is empty before adding an element.

Push operation adds an element to the middle of the stack.

Push operation removes an element from the bottom of the stack.

Push operation adds an element to the top of the stack.

Binary search can be used on unsorted lists.

Linear search requires sorted lists to function.

Linear search is O(n) and works on unsorted lists; binary search is O(log n) and requires sorted lists.

Linear search is faster than binary search.

A singly linked list has nodes with a single pointer, while a doubly linked list has nodes with two pointers, allowing traversal in both directions.

A singly linked list allows traversal in both directions, while a doubly linked list allows traversal in one direction only.

A singly linked list can only store integer values, while a doubly linked list can store any data type.

A singly linked list is more memory efficient than a doubly linked list.

O(n^2)

O(log n)

O(n)

O(1)

The pop operation removes the top element from the stack and returns it.

The pop operation adds a new element to the top of the stack.

The pop operation retrieves the bottom element of the stack.

The pop operation checks if the stack is empty.

The push operation retrieves the bottom element of the stack.

The push operation checks if the stack is full.

The push operation removes the top element from the stack.

The push operation adds a new element to the top of the stack.

A doubly linked list can only store integer values, while a singly linked list can store any data type.

A doubly linked list is slower in terms of access time compared to a singly linked list.

A doubly linked list allows traversal in both directions, while a singly linked list only allows traversal in one direction.

A doubly linked list is more memory efficient than a singly linked list.

O(log n)

O(n)

O(n^2)

O(n log n)

Stacks are more memory efficient than arrays.

Stacks can only store integer values.

Stacks are useful for implementing recursive algorithms.

Stacks allow for random access to elements.

O(n)

O(n log n)

O(log n)

O(1)

A Binary Search Tree requires more memory than a Hash Table.

A Hash Table is always sorted, while a Binary Search Tree is not.

A Binary Search Tree can store only integer values, while a Hash Table can store any data type.

A Hash Table allows for faster average-case lookups compared to a Binary Search Tree.

O(n^2)

O(n log n)

O(n)

O(log n)

It has a fixed size and allows random access to elements.

It connects the last node back to the first node, forming a circle.

It is less memory efficient than a singly linked list.

It can only be traversed in one direction.

O(n)

O(log n)

O(1)

O(n log n)

O(n log n)

O(log n)

O(n)

O(n^2)

A Queue uses LIFO order while a Stack uses FIFO order.

A Queue allows elements to be added and removed from both ends.

A Queue uses FIFO order while a Stack uses LIFO order.

A Queue can only store integer values, while a Stack can store any data type.

The enqueue operation removes the front element from the queue.

The enqueue operation checks if the queue is empty.

The enqueue operation adds a new element to the back of the queue.

The enqueue operation retrieves the last element of the queue.