Skip to content

Complete Precourse-2 #1876

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
PrakarshKamal wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Complete Precourse-2 #1876

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 16 additions & 0 deletions Exercise_1.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,8 +1,24 @@
// Time Complexity: O(log n)
// Space Complexity: O(1)

class BinarySearch {
// Returns index of x if it is present in arr[l.. r], else return -1
int binarySearch(int arr[], int l, int r, int x)
{
//Write your code here
while (l <= r) {
int mid = (l+r) / 2;
if (arr[mid] == x) {
return mid;
}
else if (arr[mid] < x) {
l = mid + 1;
}
else {
r = mid - 1;
}
}
return -1;
}

// Driver method to test above
Expand Down
30 changes: 24 additions & 6 deletions Exercise_2.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,3 +1,6 @@
// Time Complexity: O(n log n)
// Space Complexity: O(n) for recursive stack

class QuickSort
{
/* This function takes last element as pivot,
Expand All @@ -7,21 +10,36 @@ class QuickSort
pivot and all greater elements to right
of pivot */
void swap(int arr[],int i,int j){
//Your code here

int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}

int partition(int arr[], int low, int high)
{
//Write code here for Partition and Swap
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, j);
}
}
swap(arr, i+1, high);
return i+1;
}
/* The main function that implements QuickSort()
arr[] --> Array to be sorted,
low --> Starting index,
high --> Ending index */
void sort(int arr[], int low, int high)
{
// Recursively sort elements before
// partition and after partition
if (low < high) {
int pivot = partition(arr, low, high);
sort(arr, low, pivot-1);
sort(arr, pivot+1, high);
}
}

/* A utility function to print array of size n */
Expand Down
17 changes: 15 additions & 2 deletions Exercise_3.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,3 +1,6 @@
// Time Complexity: O(n)
// Space Complexity: O(1)

class LinkedList
{
Node head; // head of linked list
Expand All @@ -18,8 +21,18 @@ class Node
//Complete this function
void printMiddle()
{
//Write your code here
//Implement using Fast and slow pointers
if (head == null) {
System.out.println("The list is empty");
return;
}

Node slow = head;
Node fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
System.out.println("The middle element is " + slow.data);
}

public void push(int new_data)
Expand Down
49 changes: 45 additions & 4 deletions Exercise_4.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,19 +1,60 @@
// Time Complexity: O(n log n)
// Space Complexity: O(n)

class MergeSort
{
// Merges two subarrays of arr[].
// First subarray is arr[l..m]
// Second subarray is arr[m+1..r]
void merge(int arr[], int l, int m, int r)
{
//Your code here
{
int len1 = m - l + 1;
int len2 = r - m;
int[] left = new int[len1];
int[] right = new int[len2];

for (int i = 0; i < len1; i++) {
left[i] = arr[l+i];
}
for (int j = 0; j < len2; j++) {
right[j] = arr[m+1+j];
}
int i = 0; // index of left array
int j = 0; // index of right array
int k = l; // index of merged array

while(i < len1 && j < len2) {
if (left[i] <= right[j]) {
arr[k] = left[i];
i++;
} else {
arr[k] = right[j];
j++;
}
k++;
}
while (i < len1) {
arr[k] = left[i];
i++;
k++;
}
while (j < len2) {
arr[k] = right[j];
j++;
k++;
}
}

// Main function that sorts arr[l..r] using
// merge()
void sort(int arr[], int l, int r)
{
//Write your code here
//Call mergeSort from here
if (l < r) {
int mid = (l + r) / 2;
sort(arr, l, mid);
sort(arr, mid+1, r);
merge(arr, l, mid, r);
}
}

/* A utility function to print array of size n */
Expand Down
36 changes: 35 additions & 1 deletion Exercise_5.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,20 +1,54 @@
import java.util.*;
// Time Complexity: O(n log n)
// Space Complexity: O(n)

class IterativeQuickSort {
void swap(int arr[], int i, int j)
{
//Try swapping without extra variable
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}

/* This function is same in both iterative and
recursive*/
int partition(int arr[], int l, int h)
{
//Compare elements and swap.
int pivot = arr[h];
int i = l - 1;
for (int j = l; j < h; j++) {
if (arr[j] <= pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i+1, h);
return i+1;
}

// Sorts arr[l..h] using iterative QuickSort
void QuickSort(int arr[], int l, int h)
{
//Try using Stack Data Structure to remove recursion.
Stack<Integer> stack = new Stack<>();
stack.push(l);
stack.push(h);

while (!stack.isEmpty()) {
h = stack.pop();
l = stack.pop();
int pivot = partition(arr, l, h);

if (pivot-1 > l) {
stack.push(l);
stack.push(pivot-1);
}
if (pivot+1 < h) {
stack.push(pivot+1);
stack.push(h);
}
}
}

// A utility function to print contents of arr
Expand Down