DSA Notes

(2023)
Q] Define Data Object?
--> A data object is a region of storage that contains a value or group of values.
Each value can be accessed using its identifier or a more complex expression that
refers to the object. In addition, each object has a unique data type.
Q] Define stable sorting ?
--> A sorting algorithm is said to be stable if two objects with equal keys appear in
the same order in sorted output as they appear in the input data set.
Q] List Linear search variations ?
--> Sequential search algorithm are:
(1) the sentinel search, (2) the probability search, and (3) the ordered list search.
Q] What is time complexity of merge sort ?
--> Merge Sort is a recursive algorithm and time complexity can be expressed as
following recurrence relation. T(n) = 2T(n/2) + O(n)
Q] Define term Null list?
--> List reference can be null in a special-cased zero value for reference types.
Q] Applications of linked list ?
--> Application of Linked List
1.Implementing Stacks.
2.Queues using Linked List.
3.Implementation of Graphs.
4.Implementing Hash Tables.
5.Portray a Polynomial with a Linked List.
6.Large-Number-Arithmetic.
7.Linked allocation of files.
8.Memory Management with Linked List.
--> Linked List is a linear data structure, in which the elements are not stored at
contiguous memory locations. The elements in a linked list are linked using
pointers. It is implemented on the heap memory rather than the stack memory.
Q] Write node structure of doubly linked list?
--> Representation of Doubly Linked List
1.For node one: next stores the address of two and prev stores null (there is no
node before it)
2.For node two: next stores the address of three and prev stores the address of one.
3.For node three: next stores null (there is no node after it) and prev stores the
address of two .
Q] What is Top of the stack ?
--> The "top" element of the stack is the element that was last pushed and will be
the first to be popped.
Q] Define recursion ?
--> Recursion in the data structure can be defined as a method through which
problems are broken down into smaller sub-problems to find a solution. This is
done by replicating the function on a smaller scale, making it call itself and then
combining them together to solve problems.
Q] What is circular quene?
--> A Circular Queue is an extended version of a normal queue where the last
element of the queue is connected to the first element of the queue forming a
circle. The operations are performed based on FIFO (First In First Out) principle.
Q] Describe the term ADT ?
--> Abstract data type (ADT) is a mathematical model for data types, defined by its behavior from the
point of view of a user of the data, specifically in terms of possible values, possible operations on data of
this type, and the behavior of these operations.ADTs provide a way to encapsulate data and operations
into a single unit, making it easier to manage and modify the data structure.ADTs allow users to work
with data structures without having to know the implementation details, which can simplify programming
and reduce errors.ADTs can protect the integrity of data by controlling access and preventing
unauthorized modifications.

Q] What is the best case and worst case efficiency quick sort ?
--> Best case occurs generally when the list is in completely random manner.
Worst case occurs when the array is already sorted either in ascending or
descending order.
Q] What is divide and conquer stratergy?
--> Divide-and-conquer solves a large problem by recursively breaking it down
into smaller subproblems until they can be solved directly. Divide-and-conquer
works in three steps: divide, conquer, and combine. It is more efficient than brute
force approaches. It is prone to stack overflow error due to the use of recursion.
Q] Define Stack overflow?
--> Stack overflow is a type of buffer overflow error that occurs when a computer program tries
to use more memory space in the call stack than has been allocated to that stack.

Q] Define stack underflow ?

--> Stack underflow happens when we try to pop (remove) an item from the stack, when nothing
is actually there to remove.

Q] Write a program to search an element using linear search algorithm.

--> #include <stdio.h>

// Function to perform linear search

int linearSearch(int arr[], int n, int key) {
for (int i = 0; i < n; i++) {
if (arr[i] == key) {
return i; // Return the index if the element is found
}
}
return -1; // Return -1 if the element is not found
}

int main() {
int n, key;
 // Input the size of the array
printf("Enter the size of the array: ");
scanf("%d", &n);

int arr[n];

// Input the elements of the array

printf("Enter the elements of the array:\n");
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}

// Input the element to be searched

printf("Enter the element to be searched: ");
scanf("%d", &key);

// Perform linear search

int position = linearSearch

Q] Write a C function to reverse a string using stack ?

--> #include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Structure to represent a stack

struct Stack {
int top;
unsigned capacity;
char* array;
};

// Function to create a stack with given capacity

struct Stack* createStack(unsigned capacity) {
struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
stack->top = -1;
stack->capacity = capacity;
stack->array = (char*)malloc(stack->capacity * sizeof(char));
return stack;
}

// Function to check if the stack is empty

int isEmpty(struct Stack* stack) {
return stack->top == -1;
}

// Function to push an element onto the stack

void push(struct Stack* stack, char item) {
stack->array[++stack->top] = item;
}

// Function to pop an element from the stack

char pop(struct Stack* stack) {
if (isEmpty(stack))
return '\0';
return stack->array[stack->top--];
}

// Function to reverse a string using a stack

void reverseString(char* str) {
int length = strlen(str);
struct Stack* stack = createStack(length);

// Push each character onto the stack

for (int i = 0; i < lengt

Q] Write a C function to delete a node from singly circular linked list at any ?
--> #include <stdio.h>
#include <stdlib.h>

// Node structure for a singly circular linked list

struct Node {
int data;
struct Node* next;
};

// Function to insert a node at the end of the singly circular linked list
struct Node* insertEnd(struct Node* last, int data) {
 if (last == NULL) {
// If the list is empty, create a new node
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = newNode; // Point to itself since it's the only node
return newNode;
} else {
// If the list is not empty, create a new node
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = last->next; // Make the new node point to the first node
last->next = newNode; // Make the last node point to the new node
return newNode;
}
}

// Function to delete a node from a given position in the singly circular linked
list
struct Node* deleteNode(struct Node* last, int position) {
if (last == NULL) {
printf("List is empty. Cannot delete from an empty list.\n");
return NULL;
}

struct Node* current = last->next;

struct Node* previous = NULL;
 // Traverse to the node at the specified position
for (int i = 1; i < position; i++) {
previous = current;
current = current->next;

// Check if the position is valid

if (current == last->next) {
printf("Invalid position. Cannot delete from position %d.\n",
position);
return last;
}
}

// If the node to be deleted is the only node in the list

if (current == last->next && current->next == last->n

Q] Sort the following elements using bubble sort algorithm.

89 29 39 79 59 49 69 19
• --> Pass 1:
• Compare adjacent elements and swap if they are in the wrong order.
• Repeat until the end of the list is reached.
• After pass 1: 29 39 79 59 49 69 19 89
• Pass 2:
• Repeat the process, excluding the last element (which is already in its correct position).
• After pass 2: 29 39 59 49 69 19 79 89
• Pass 3:
• Continue the process, excluding the last two elements.
• After pass 3: 29 39 49 59 19 69 79 89
• Pass 4:
• Continue the process, excluding the last three elements.
• After pass 4: 29 39 49 19 59 69 79 89
 • Pass 5:
• Continue the process, excluding the last four elements.
• After pass 5: 29 39 19 49 59 69 79 89
• Pass 6:
• Continue the process, excluding the last five elements.
• After pass 6: 29 19 39 49 59 69 79 89
• Pass 7:
• Continue the process, excluding the last six elements.
• After pass 7: 19 29 39 49 59 69 79 89
• The sorted list using the bubble sort algorithm is: 19 29 39 49 59 69 79 89

Q] Convert the following infix expression into postfix expression.

P*Q+R/S–T
--> Expression: P * Q + R / S - T

Stack and Output: (Empty at the beginning)

Scan "P":

Operand, so add it to the output.

Output: P

Scan "*":

Since the stack is empty or doesn't have an operator of higher precedence,

push "*" onto the stack.
Stack: *

Scan "Q":

Operand, so add it to the output.

Output: P Q

Scan "+":

Pop "*" from the stack (higher precedence than "+") and add it to the output.
Push "+" onto the stack.
Stack: +

Output: P Q *

Scan "R":

Operand, so add it to the output.

Output: P Q * R

Scan "/":

Pop "+" from the stack (same precedence as "/") and add it to the output.
Push "/" onto the stack.
Stack: /

Output: P Q * R +

Scan "S":

Operand, so add it to the output.

Output: P Q * R + S
Scan "-":

Pop "/" from the stack (lower precedence than "-") and add it to the output.
Push "-" onto the stack.
Stack: -

Output: P Q * R + S /

Scan "T":

Operand, so add it to the output.

Output: P Q * R + S / T

Final Result: P Q * R + S / T -

So, the postfix expression for "P * Q + R / S - T" is "P Q * R + S / T -".

Q] Define Deque. List types of Deque and explain any two operations
performed on Deque.
--> Deque, the data can be inserted and deleted from both front and rear ends.
Unlike queue, deque in data structure doesn't follow the FIFO rule (First in first
out). There are two types of deque in data structure Input restricted queue and
Output restricted queue.

Q]Define
1] Data structure?
--> A data structure is a specialized format for organizing, processing, retrieving
and storing data.
2] Omega notation?
--> Omega notation represents the lower bound of the running time of an
algorithm.Thus, it provides the best case complexity of an algorithm. Omega gives
the lower bound of a function Ω(g(n)) = { f(n): there exist positive constants c and
n0 such that 0 ≤ cg(n) ≤ f(n) for all n ≥ n0 }
3] Time complexity?
--> Time complexity is a type of computational complexity that describes the time
required to execute an algorithm. The time complexity of an algorithm is the
amount of time it takes for each statement to complete. As a result, it is highly
dependent on the size of the processed data.
4] Big Oh?
--> Big O Notation is a tool used to describe the time complexity of algorithms. It
calculates the time taken to run an algorithm as the input grows. In other words, it
calculates the worst-case time complexity of an algorithm.
5] Theta notation?
--> Theta notation encloses the function from above and below. Since it represents
the upper and the lower bound of the running time of an algorithm.
6] Space complexity ?
--> Space complexity refers to the total amount of memory space used by an
algorithm/program, including the space of input values for execution.
Q] Write a short note on priority queue?
--> Priority queue in a data structure is an extension of a linear queue that
possesses the following properties: Every element has a certain priority assigned to
it. Every element of this queue must be comparable. It will delete the element with
higher priority before the element with lower priority.

Q] What is polish notation ?

--> Polish Notation in the data structure is a method of expressing mathematical, logical, and
algebraic equations universally. This notation is used by the compiler to evaluate mathematical
equations based on their order of operations.(ex:3+5)

Q] Convert the following infix expresion to postfix expression

(A-B/C)*(D/E-F)
--> Step 1:
Read the expression from left to right.
Initialize an empty stack for operators and an empty list for the output.
Expression: (A-B/C)*(D/E-F)
Stack: []
Output: []

Step 2:
Process each symbol in the expression.
Push operands directly to the output.
Push operators onto the stack based on their precedence and associativity.
Symbol: ( (Open parenthesis has the highest precedence)
Stack: [ ( ]
Output: []

Step 3:
Process the next symbol.
Symbol: A
Stack: [ ( ]
Output: [ A ]

Step 4:
Process the next symbol.
Symbol: -
Stack: [ ( ]
Output: [ A ]

Step 5:
Process the next symbol.
Symbol: B
Stack: [ ( ]
Output: [ A, B ]

Step 6:
Process the next symbol.
Symbol: /
Stack: [ (, / ]
Output: [ A, B ]

Step 7:
Process the next symbol.
Symbol: C
Stack: [ (, / ]
Output: [ A, B, C ]

Step 8:
Process the next symbol.
Symbol: )
Stack: [ ( ]
Output: [ A, B, C, / ]

Step 9:
Process the next symbol.
Symbol: *
Stack: [ (, * ]
Output: [ A, B, C, / ]

Step 10:
Process the next symbol.
Symbol: (
Stack: [ (, * ]
Output: [ A, B, C, / ]

Step 11:
Process the next symbol.
Symbol: D
Stack: [ (, * ]
Output: [ A, B, C, /, D ]

Step 12:
Process the next symbol.
Symbol: /
Stack: [ (, *, / ]
Output: [ A, B, C, /, D ]
Step 13:
Process the next symbol.
Symbol: E
Stack: [ (, *, / ]
Output: [ A, B, C, /, D, E ]

Step 14:
Process the next symbol.
Symbol: -
Stack: [ (, *, /, - ]
Output: [ A, B, C, /, D, E ]
Step 15:
Process the next symbol.
Symbol: F
Stack: [ (, *, /, - ]
Output: [ A, B, C, /, D, E, F ]

Step 16:
Process the next symbol.
Symbol: )
Stack: [ (, *, / ]
Output: [ A, B, C, /, D, E, F, - ]

Step 17:
Process the next symbol.
Symbol: )
Stack: [ (, * ]
Output: [ A, B, C, /, D, E, F, -, / ]

Step 18:
Process the next symbol.
Symbol: (No more symbols)
Stack: [ ( ]
Output: [ A, B, C, /, D, E, F, -, /, * ]

Step 19:
Pop any remaining operators from the stack and append to the output.
Stack: []
Output: [ A, B, C, /, D, E, F, -, /, *, - ]
So, the postfix expression is "AB-C/DE/F-*".

Q] Mention all types of sorting ?

--> 1.Quick sort.
2.Bubble Sort.
3.Merge sort.
4.Insertion Sort.
5.Radix Sort.
6.Selection Sort.
7.Heap sort.
8.Bucket Sort.
Q] List out the asymptotic notation ?
--> big O, big Theta (Θ), and big Omega (Ω).
Q] Explain array based or static based implementation of stack ?
--> In an array-based implementation, the push operation is implemented by
incrementing the index of the top element and storing the new element at that
index. The pop operation is implemented by decrementing the index of the top
element and returning the value stored at that index.
Q] Difference between stack and queue ?
-->

Stacks Queues

A queue is a data structure that stores a

A stack is a data structure that stores a
collection of elements, with operations to
collection of elements, with operations to
enqueue (add) elements at the back of the
push (add) and pop (remove) elements from
queue, and dequeue (remove) elements from
the top of the stack.
the front of the queue.

Stacks are based on the LIFO principle, i.e., Queues are based on the FIFO principle, i.e.,
the element inserted at the last, is the first the element inserted at the first, is the first
element to come out of the list. element to come out of the list.

Stacks are often used for tasks that require Queues are often used for tasks that involve
backtracking, such as parsing expressions or processing elements in a specific order, such
implementing undo functionality. as handling requests or scheduling tasks.

Q] Write note on Backtracking ?

--> Backtracking is an algorithmic technique where the goal is to get all solutions
to a problem using the brute force approach. It consists of building a set of all the
solutions incrementally. Since a problem would have constraints, the solutions that
fail to satisfy them will be removed.
Q] Sort the following numbers(Merge Sort):
8,22,7,9,31,5,13
--> #include <stdio.h>
// Function to merge two subarrays of arr[]
void merge(int arr[], int left, int middle, int right) {
int i, j, k;
int n1 = middle - left + 1;
int n2 = right - middle;

// Create temporary arrays

int L[n1], R[n2];

// Copy data to temporary arrays L[] and R[]

for (i = 0; i < n1; i++)
L[i] = arr[left + i];
for (j = 0; j < n2; j++)
R[j] = arr[middle + 1 + j];

// Merge the temporary arrays back into arr[left..right]

i = 0; // Initial index of first subarray
j = 0; // Initial index of second subarray
k = left; // Initial index of merged subarray

while (i < n1 && j < n2) {

if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
 j++;
}
k++;
}

// Copy the remaining elements of L[], if there are any

while (i < n1) {
arr[k] = L[i];
i++;
k++;
}

// Copy the remaining elements of R[], if there are any

while (j < n2) {
arr[k] = R[j];
j++;
k++

in ascending order,using bubble sort.

Q] List the datatypes in C?

-->

Types Description

Primitive data types are the most basic data

Primitive Data Types types that are used for representing simple
values such as integers, float, characters, etc.
 The user-defined data types are defined by
User Defined Data Types the user himself
Ex: struct,union,enum.

The data types that are derived from the

primitive or built-in datatypes are referred to
Derived Types
as Derived Data Types.
Ex:array,refernces,pointer.

Q] Null Pointer ?
--> The Null Pointer is the pointer that does not point to any location but NULL.
Syntax :-
type pointer_name = NULL;
type pointer_name = 0;
Q] External pointer ?
--> External pointer is a pointer that points to the very first node in the linked list,
it enables us to access the entire linked list.
Q] Write a C function to insert a node in circular doubly linked lists ?
--> #include <stdio.h>
#include <stdlib.h>

// Node structure for a circular doubly linked list

struct Node {
int data;
struct Node* next;
struct Node* prev;
};

// Function to insert a node at the end of a circular doubly linked list

struct Node* insertEnd(struct Node* last, int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;

if (last == NULL) {
// If the list is empty, make the new node point to itself
newNode->next = newNode;
newNode->prev = newNode;
return newNode;
} else {
// Insert the new node at the end of the list
newNode->next = last->next;
last->next->prev = newNode;
newNode->prev = last;
last->next = newNode;
return last;
}
}

// Function to display the circular doubly linked list

void displayList(struct Node* last) {
if (last == NULL) {
printf("List is empty.\n");
return;
}
 struct Node* temp = last->next;

do {
printf("%d <-> ", temp->data);
temp = temp->next;
} while (temp != last->next);

printf("(head)\n");
}

int main() {
struct Node* la

Q] Write a algorithm for tranversing a linked list and also give its function?
• --> Start from the head of the linked list.
• While the current node is not NULL:
• Perform the desired operation on the data of the current node.
• Move to the next node by updating the current node to the next node.
• End.

Q] Write a C function to reverse singly linked list ?

--> #include <stdio.h>
#include <stdlib.h>

// Node structure for a singly linked list

struct Node {
int data;
struct Node* next;
};

// Function to reverse a singly linked list

struct Node* reverseLinkedList(struct Node* head) {
struct Node *prev = NULL, *current = head, *nextNode = NULL;

while (current != NULL) {

// Save the next node
nextNode = current->next;

// Reverse the link

current->next = prev;

// Move to the next nodes

prev = current;
current = nextNode;
}

// Update the head of the reversed list

head = prev;

return head;
}

// Function to create a new node with the given data

struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
 if (newNode != NULL) {
newNode->data = data;
newNode->next = NULL;
}
return newNode;
}

// Function to display the elements of a linked list

void displayList(struct Node* head) {
struct Node* current = head;

while (current != NULL) {

printf("%d ", current->data);
current = current->next;
}

printf("\n

Q] Give an algorithm to convert an infinix to postfix ?

• --> Initialize an empty stack to hold operators.
• Initialize an empty string to store the postfix expression.
• Scan the infix expression from left to right.
• If the scanned character is an operand, append it to the postfix expression.
• If the scanned character is an open parenthesis '(', push it onto the stack.
• If the scanned character is a closing parenthesis ')':
• Pop operators from the stack and append them to the postfix expression until an open
parenthesis '(' is encountered. Pop and discard the open parenthesis.
• If the scanned character is an operator:
• While the stack is not empty and the precedence of the current operator is less than or
equal to the precedence of the operator at the top of the stack, pop the operator from the
stack and append it to the postfix expression.
 • Push the current operator onto the stack.
• Pop any remaining operators from the stack and append them to the postfix expression.
• End.

Q]What is TOP of stack ?

--> The "top" element of the stack is the element that was last pushed and will be
the first to be popped. The "bottom" element of the stack is the one that, when
removed, will leave the stack empty.
Q] Give the purpose of PUSH operation?
--> A stack is an abstract data type that serves as a collection of elements with two
main operations: Push, which adds an element to the collection, and. Pop, which
removes the most recently added element.
Q] What is recursive function ?
--> Recursion is a process in which the function calls itself indirectly or directly in
order to solve the problem. The function that performs the process of recursion is
called a recursive function.

Q] What is internal sorting and give examples ?

--> Sorting algorithms that use main memory exclusively during the sort are called
internal sorting algorithms. This kind of algorithm assumes high-speed random
access to all memory. Some of the common algorithms that use this sorting feature
are : Bubble Sort, Insertion Sort., and Quick Sort.
Q] What is time complexity of bubble sort ?
--> The bubble sort algorithm's average/worst time complexity is O(n²), as we have
to pass through the array as many times as there are pairs in a provided array.
Q] List the operations on array data structures ?
--> Sorting
Searching
Array
Deletion
Insertion
Traversal operation
Algorithm
Dynamic programming
Insertion array operations.
Q] Sort the following sequence using quick sort algorithm.
35,45,42,57,26
--> #include <stdio.h>

// Function to partition the array and return the pivot index

int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = low - 1;

for (int j = low; j < high; j++) {

if (arr[j] <= pivot) {
i++;
// Swap arr[i] and arr[j]
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}

// Swap arr[i+1] and arr[high] to place the pivot in the correct position
 int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;

return i + 1;
}

// Function to implement quicksort

void quicksort(int arr[], int low, int high) {
if (low < high) {
// Find the pivot index
int pivotIndex = partition(arr, low, high);

// Recursively sort the subarrays before and after the pivot

quicksort(arr, low, pivotIndex - 1);
quicksort(arr, pivotIndex + 1, high);
}
}

// Function to print an array

void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main() {
int arr[] = {35, 45, 42, 57, 26};
int arrSize = sizeof(arr) /

Q] Sort the following number using bubble sort method.

108,3,97,65,71,23,57,93,100
--> #include <stdio.h>

// Function to perform bubble sort

void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
// If the element is greater than the next element, swap them
if (arr[j] > arr[j + 1]) {
// Swap arr[j] and arr[j + 1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

// Function to print an array

void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
 printf("%d ", arr[i]);
}
printf("\n");
}

int main() {
int arr[] = {108, 3, 97, 65, 71, 23, 57, 93, 100};
int arrSize = sizeof(arr) / sizeof(arr[0]);

printf("Original array: ");

printArray(arr, arrSize);

// Perform bubble sort

bubbleSort(arr, arrSize);

printf("Sorted array: ");

printArray(arr, arrSize);

return 0;
}

Q] Write a short note on Array as an ADT ?

--> The array is a basic abstract data type that holds an ordered collection of items
accessible by an integer index. These items can be anything from primitive types
such as integers to more complex types like instances of classes. Since it's an ADT,
it doesn't specify an implementation, but is almost always implemented by an array
(data structure) or dynamic array.
Q] Define:
1] Sorting:
• Bubble Sort:
• Compares adjacent elements and swaps them if they are in the wrong order.
• Repeats this process until the entire array is sorted.
• Simple but less efficient compared to other algorithms for large datasets.
• Selection Sort:
• Divides the array into a sorted and an unsorted region.
• Finds the minimum element in the unsorted region and swaps it with the first
unsorted element.
• Repeats this process until the entire array is sorted.
• Insertion Sort:
• Builds the sorted array one element at a time.
• Takes each element from the unsorted region and places it in its correct position in
the sorted region.
• Efficient for small datasets or nearly sorted data.
• Merge Sort:
• Divides the array into two halves, sorts each half, and then merges them.
• Uses a divide-and-conquer approach.
• Guarantees O(n log n) time complexity, making it efficient for large datasets.
• Quick Sort:
• Chooses a pivot element and partitions the array into two subarrays.
• Elements smaller than the pivot go to the left, and elements greater go to the right.
• Recursively applies this process to each subarray.

2] Searching:
• Linear Search:
• Simple search method that sequentially checks each element in a collection until a
match is found.
• Works well for small datasets or unordered lists.
• Time complexity is O(n) in the worst case.
• Binary Search:
• Applicable to sorted arrays or lists.
• Divides the dataset in half by comparing the target value with the middle element.
• Repeats this process until the element is found or the search space is empty.
• Time complexity is O(log n) in the worst case.