Objective: – Given a Binary Search Tree, Do the Depth First Search/Traversal .
Appraoch:
Example:
Objective: Given a array of unsorted numbers, check if all the numbers in the array are consecutive numbers.
Examples:
int [] arrA = {21,24,22,26,23,25}; - True
(All the integers are consecutive from 21 to 26)
int [] arrB = {11,10,12,14,13}; - True
(All the integers are consecutive from 10 to 14)
int [] arrC = {11,10,14,13}; - False
(Integers are not consecutive, 12 is missing)
Approach:
Naive Approach: Sorting . Time Complexity – O(nlogn).
Better Approach: Time Complexity – O(n).
Objective: Given two sorted arrays, Find intersection point between them.
Examples:
int[] a = { 1, 2, 3, 6, 8, 10 };
int[] b = { 4, 5, 6, 11, 15, 20 };
Output: Intersection point is : 6
Approach:
Naive Approach: Use 2 loops and compare each elements in both array and as soon as you find the intersection point, return it. Time Complexity – O(n2).
Better Approach: Time Complexity – O(n)
Objective: Given a binary tree, Convert it into its Mirror Tree
Mirror Tree: Mirror Tree of a binary tree is where left and right child of every node of given binary tree is interexchanged.
Input: A binary tree.
Example:
Approach:
Objective: Given a binary tree, Print All the Nodes that don’t have siblings.
Note: sibling node is the node which has the same parent, so you need to print the nodes who is a single child of his parent.
Input: A binary tree.
Example:
Approach:
Objective: Given Two binary Search Trees, Check if both are identical.
Input: Two binary Search Trees
Approach:
Objective: Given three sorted(ascending order) arrays of integers, find out all the common elements in them.
Input: Three sorted arrays.
Output: All the common elements.
Examples :
Array A = {1,2,3,4,5,6,7,8,9,10};
Array B = {1,3,5,6,7,8,12};
Array C = {2,3,4,5,8,9};
Common Elements are 3,5,8
Objective: Given a sorted array of positive integers, find out the smallest integer which cannot be represented as the sum of any subset of the array
Input: A Sorted Array
Output: The smallest number which cannot be represented as the sum of any subset of the given array
Examples :
Array {1,1,3,4,6,7,9} smallest Number : 32
Array {1,1,1,1,1} smallest Number : 6
Array {2,3,6,7} smallest Number : 1
Array {1,2,6,7,9} smallest Number : 4
Approach:
Objective: Given a Binary tree, Find the size of the tree.
Note : Size of the tree is number of nodes in the tree
Input: A Binary Tree.
Output: Size of the tree.
Example :
Approach :
Objective: Given a binary tree, find the height of it
Input: A Binary Tree
Output: Height of a binary tree
Example:
Approach:
Binary Tree : A data structure in which we have nodes containing data and two references to other nodes, one on the left and one on the right.
Binary Tree consist of Nodes
class Node{
int data;
Node left;
Node right;
public Node(int data){
this.data = data;
left = null;
right = null;
}
}
This post is the extension of our earlier post Reverse a linked list. Here We have provided the better recursive solution in which we start reversing the list from the end.
Objective: Reverse the given linked list.
Input: A Linked List
Output: Reversed Linked List
Example:
Original List :->10->8->6->4->2 Reversed List :->2->4->6->8->10
Approach:
Objective: Write a program to Delete a Node in the Middle of a linked list, Given only access to that Node
Example:
Original List : ->1->2->8->3->7->0->4 After Deleting the mid node (say 7) : ->1->2->8->3->0->4
Input: A Linked List and access to the node which needs to be deleted
Output: Linked list with deleted node
Approach:
Objective: Given a linked list and integer ‘n’, write an algorithm to find the nth node from the end in the Linked List.
Example:
Original List : ->1->2->8->3->7->0->4 Output : 3rd Element from the end is : 7
Input: An unsorted linked list and integer k
Output: The kth to Last Element of a Singly Linked List
Approach:
Objective: Write a program to remove the duplicates from an unsorted linked list
Example:
Input Linked List : 1->2->2->4->3->3->2 Output : 1->2->4->3
Input: An unsorted linked list
Output: Linked list with no duplicates.
Approach: