listElements) {
+ minHeap = new ArrayList<>();
for (HeapElement heapElement : listElements) {
if (heapElement != null) insertElement(heapElement);
else System.out.println("Null element. Not added to heap");
}
if (minHeap.size() == 0) System.out.println("No element has been added, empty heap.");
}
-
+
// Get the element at a given index. The key for the list is equal to index value - 1
public HeapElement getElement(int elementIndex) {
- if ((elementIndex <= 0) && (elementIndex > minHeap.size())) throw new IndexOutOfBoundsException("Index out of heap range");
+ if ((elementIndex <= 0) || (elementIndex > minHeap.size()))
+ throw new IndexOutOfBoundsException("Index out of heap range");
return minHeap.get(elementIndex - 1);
}
-
+
// Get the key of the element at a given index
private double getElementKey(int elementIndex) {
return minHeap.get(elementIndex - 1).getKey();
}
-
+
// Swaps two elements in the heap
private void swap(int index1, int index2) {
HeapElement temporaryElement = minHeap.get(index1 - 1);
minHeap.set(index1 - 1, minHeap.get(index2 - 1));
minHeap.set(index2 - 1, temporaryElement);
}
-
- // Toggle an element up to its right place as long as its key is lower than its parent's
+
+ // Toggle an element up to its right place as long as its key is lower than its parent's
private void toggleUp(int elementIndex) {
double key = minHeap.get(elementIndex - 1).getKey();
- while (getElementKey((int) Math.floor(elementIndex/2)) > key) {
- swap(elementIndex, (int) Math.floor(elementIndex/2));
- elementIndex = (int) Math.floor(elementIndex/2);
+ while (getElementKey((int) Math.floor(elementIndex / 2)) > key) {
+ swap(elementIndex, (int) Math.floor(elementIndex / 2));
+ elementIndex = (int) Math.floor(elementIndex / 2);
}
}
-
+
// Toggle an element down to its right place as long as its key is higher
- // than any of its children's
+ // than any of its children's
private void toggleDown(int elementIndex) {
double key = minHeap.get(elementIndex - 1).getKey();
- boolean wrongOrder = (key > getElementKey(elementIndex*2)) || (key > getElementKey(Math.min(elementIndex*2, minHeap.size())));
- while ((2*elementIndex <= minHeap.size()) && wrongOrder) {
+ boolean wrongOrder = (key > getElementKey(elementIndex * 2)) || (key > getElementKey(Math.min(elementIndex * 2, minHeap.size())));
+ while ((2 * elementIndex <= minHeap.size()) && wrongOrder) {
// Check whether it shall swap the element with its left child or its right one if any.
- if ((2*elementIndex < minHeap.size()) && (getElementKey(elementIndex*2 + 1) < getElementKey(elementIndex*2))) {
- swap(elementIndex, 2*elementIndex + 1);
- elementIndex = 2*elementIndex + 1;
- }
- else {
- swap(elementIndex, 2*elementIndex);
- elementIndex = 2*elementIndex;
+ if ((2 * elementIndex < minHeap.size()) && (getElementKey(elementIndex * 2 + 1) < getElementKey(elementIndex * 2))) {
+ swap(elementIndex, 2 * elementIndex + 1);
+ elementIndex = 2 * elementIndex + 1;
+ } else {
+ swap(elementIndex, 2 * elementIndex);
+ elementIndex = 2 * elementIndex;
}
- wrongOrder = (key > getElementKey(elementIndex*2)) || (key > getElementKey(Math.min(elementIndex*2, minHeap.size())));
-
+ wrongOrder = (key > getElementKey(elementIndex * 2)) || (key > getElementKey(Math.min(elementIndex * 2, minHeap.size())));
+
}
}
@@ -87,23 +84,25 @@ public void insertElement(HeapElement element) {
@Override
public void deleteElement(int elementIndex) {
- if (minHeap.isEmpty())
- try {
- throw new EmptyHeapException("Attempt to delete an element from an empty heap");
- } catch (EmptyHeapException e) {
- e.printStackTrace();
- }
- if ((elementIndex > minHeap.size()) && (elementIndex <= 0)) throw new IndexOutOfBoundsException("Index out of heap range");
+ if (minHeap.isEmpty())
+ try {
+ throw new EmptyHeapException("Attempt to delete an element from an empty heap");
+ } catch (EmptyHeapException e) {
+ e.printStackTrace();
+ }
+ if ((elementIndex > minHeap.size()) || (elementIndex <= 0))
+ throw new IndexOutOfBoundsException("Index out of heap range");
// The last element in heap replaces the one to be deleted
minHeap.set(elementIndex - 1, getElement(minHeap.size()));
minHeap.remove(minHeap.size());
// Shall the new element be moved up...
- if (getElementKey(elementIndex) < getElementKey((int) Math.floor(elementIndex/2))) toggleUp(elementIndex);
- // ... or down ?
- else if (((2*elementIndex <= minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex*2))) ||
- ((2*elementIndex < minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex*2)))) toggleDown(elementIndex);
+ if (getElementKey(elementIndex) < getElementKey((int) Math.floor(elementIndex / 2))) toggleUp(elementIndex);
+ // ... or down ?
+ else if (((2 * elementIndex <= minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex * 2))) ||
+ ((2 * elementIndex < minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex * 2))))
+ toggleDown(elementIndex);
}
-
+
@Override
public HeapElement getElement() throws EmptyHeapException {
try {
@@ -112,4 +111,4 @@ public HeapElement getElement() throws EmptyHeapException {
throw new EmptyHeapException("Heap is empty. Error retrieving element");
}
}
-}
+}
\ No newline at end of file
diff --git a/DataStructures/Heaps/MinPriorityQueue.java b/DataStructures/Heaps/MinPriorityQueue.java
new file mode 100644
index 000000000000..52e475abf4be
--- /dev/null
+++ b/DataStructures/Heaps/MinPriorityQueue.java
@@ -0,0 +1,133 @@
+package DataStructures.Heaps;
+
+/**
+ * Minimum Priority Queue
+ * It is a part of heap data structure
+ * A heap is a specific tree based data structure
+ * in which all the nodes of tree are in a specific order.
+ * that is the children are arranged in some
+ * respect of their parents, can either be greater
+ * or less than the parent. This makes it a min priority queue
+ * or max priority queue.
+ *
+ *
+ * Functions: insert, delete, peek, isEmpty, print, heapSort, sink
+ */
+public class MinPriorityQueue {
+ private int[] heap;
+ private int capacity;
+ private int size;
+
+ // calss the constructor and initializes the capacity
+ MinPriorityQueue(int c) {
+ this.capacity = c;
+ this.size = 0;
+ this.heap = new int[c + 1];
+ }
+
+ // inserts the key at the end and rearranges it
+ // so that the binary heap is in appropriate order
+ public void insert(int key) {
+ if (this.isFull())
+ return;
+ this.heap[this.size + 1] = key;
+ int k = this.size + 1;
+ while (k > 1) {
+ if (this.heap[k] < this.heap[k / 2]) {
+ int temp = this.heap[k];
+ this.heap[k] = this.heap[k / 2];
+ this.heap[k / 2] = temp;
+ }
+ k = k / 2;
+ }
+ this.size++;
+ }
+
+ // returns the highest priority value
+ public int peek() {
+ return this.heap[1];
+ }
+
+ // returns boolean value whether the heap is empty or not
+ public boolean isEmpty() {
+ if (0 == this.size)
+ return true;
+ return false;
+ }
+
+ // returns boolean value whether the heap is full or not
+ public boolean isFull() {
+ if (this.size == this.capacity)
+ return true;
+ return false;
+ }
+
+ // prints the heap
+ public void print() {
+ for (int i = 1; i <= this.capacity; i++)
+ System.out.print(this.heap[i] + " ");
+ System.out.println();
+ }
+
+ // heap sorting can be done by performing
+ // delete function to the number of times of the size of the heap
+ // it returns reverse sort because it is a min priority queue
+ public void heapSort() {
+ for (int i = 1; i < this.capacity; i++)
+ this.delete();
+ }
+
+ // this function reorders the heap after every delete function
+ private void sink() {
+ int k = 1;
+ while (2 * k <= this.size || 2 * k + 1 <= this.size) {
+ int minIndex;
+ if (this.heap[2 * k] >= this.heap[k]) {
+ if (2 * k + 1 <= this.size && this.heap[2 * k + 1] >= this.heap[k]) {
+ break;
+ } else if (2 * k + 1 > this.size) {
+ break;
+ }
+ }
+ if (2 * k + 1 > this.size) {
+ minIndex = this.heap[2 * k] < this.heap[k] ? 2 * k : k;
+ } else {
+ if (this.heap[k] > this.heap[2 * k] || this.heap[k] > this.heap[2 * k + 1]) {
+ minIndex = this.heap[2 * k] < this.heap[2 * k + 1] ? 2 * k : 2 * k + 1;
+ } else {
+ minIndex = k;
+ }
+ }
+ int temp = this.heap[k];
+ this.heap[k] = this.heap[minIndex];
+ this.heap[minIndex] = temp;
+ k = minIndex;
+ }
+ }
+
+ // deletes the highest priority value from the heap
+ public int delete() {
+ int min = this.heap[1];
+ this.heap[1] = this.heap[this.size];
+ this.heap[this.size] = min;
+ this.size--;
+ this.sink();
+ return min;
+ }
+
+ public static void main(String[] args) {
+ // testing
+ MinPriorityQueue q = new MinPriorityQueue(8);
+ q.insert(5);
+ q.insert(2);
+ q.insert(4);
+ q.insert(1);
+ q.insert(7);
+ q.insert(6);
+ q.insert(3);
+ q.insert(8);
+ q.print(); // [ 1, 2, 3, 5, 7, 6, 4, 8 ]
+ q.heapSort();
+ q.print(); // [ 8, 7, 6, 5, 4, 3, 2, 1 ]
+ }
+}
\ No newline at end of file
diff --git a/DataStructures/Lists/CircleLinkedList.java b/DataStructures/Lists/CircleLinkedList.java
index 1f9a49e1ae90..8863b7349ca2 100644
--- a/DataStructures/Lists/CircleLinkedList.java
+++ b/DataStructures/Lists/CircleLinkedList.java
@@ -1,54 +1,65 @@
-public class CircleLinkedList{
- private static class Node{
- Node next;
- E value;
- private Node(E value, Node next){
- this.value = value;
- this.next = next;
- }
- }
- //For better O.O design this should be private allows for better black box design
- private int size;
- //this will point to dummy node;
- private Node head;
- //constructer for class.. here we will make a dummy node for circly linked list implementation with reduced error catching as our list will never be empty;
- public CircleLinkedList(){
- //creation of the dummy node
- head = new Node(null,head);
- size = 0;
- }
- // getter for the size... needed because size is private.
- public int getSize(){ return size;}
- // for the sake of simplistiy this class will only contain the append function or addLast other add functions can be implemented however this is the basses of them all really.
- public void append(E value){
- if(value == null){
- // we do not want to add null elements to the list.
- throw new NullPointerException("Cannot add null element to the list");
- }
- //head.next points to the last element;
- head.next = new Node(value,head);
- size++;}
- public E remove(int pos){
- if(pos>size || pos< 0){
- //catching errors
- throw new IndexOutOfBoundsException("position cannot be greater than size or negative");
- }
- Node iterator = head.next;
- //we need to keep track of the element before the element we want to remove we can see why bellow.
- Node before = head;
- for(int i = 1; i<=pos; i++){
+package DataStructures.Lists;
+
+public class CircleLinkedList {
+ private static class Node {
+ Node next;
+ E value;
+
+ private Node(E value, Node next) {
+ this.value = value;
+ this.next = next;
+ }
+ }
+
+ //For better O.O design this should be private allows for better black box design
+ private int size;
+ //this will point to dummy node;
+ private Node head;
+
+ //constructer for class.. here we will make a dummy node for circly linked list implementation with reduced error catching as our list will never be empty;
+ public CircleLinkedList() {
+ //creation of the dummy node
+ head = new Node(null, head);
+ size = 0;
+ }
+
+ // getter for the size... needed because size is private.
+ public int getSize() {
+ return size;
+ }
+
+ // for the sake of simplistiy this class will only contain the append function or addLast other add functions can be implemented however this is the basses of them all really.
+ public void append(E value) {
+ if (value == null) {
+ // we do not want to add null elements to the list.
+ throw new NullPointerException("Cannot add null element to the list");
+ }
+ //head.next points to the last element;
+ head.next = new Node(value, head);
+ size++;
+ }
+
+ public E remove(int pos) {
+ if (pos > size || pos < 0) {
+ //catching errors
+ throw new IndexOutOfBoundsException("position cannot be greater than size or negative");
+ }
+ Node iterator = head.next;
+ //we need to keep track of the element before the element we want to remove we can see why bellow.
+ Node before = head;
+ for (int i = 1; i <= pos; i++) {
iterator = iterator.next;
- before = before.next;
- }
- E saved = iterator.value;
- // assigning the next referance to the the element following the element we want to remove... the last element will be assigned to the head.
- before.next = iterator.next;
- // scrubbing
- iterator.next = null;
- iterator.value = null;
- return saved;
-
- }
-
- }
+ before = before.next;
+ }
+ E saved = iterator.value;
+ // assigning the next reference to the the element following the element we want to remove... the last element will be assigned to the head.
+ before.next = iterator.next;
+ // scrubbing
+ iterator.next = null;
+ iterator.value = null;
+ return saved;
+
+ }
+
+}
diff --git a/DataStructures/Lists/CursorLinkedList.java b/DataStructures/Lists/CursorLinkedList.java
new file mode 100644
index 000000000000..6e1caefc620b
--- /dev/null
+++ b/DataStructures/Lists/CursorLinkedList.java
@@ -0,0 +1,219 @@
+package DataStructures.Lists;
+
+import java.util.Objects;
+
+public class CursorLinkedList {
+
+ private static class Node {
+
+ T element;
+ int next;
+
+ Node(T element, int next) {
+ this.element = element;
+ this.next = next;
+ }
+
+ boolean isEmpty() {
+ return element == null;
+ }
+ }
+
+
+ private final int os;
+ private int head;
+ private final Node[] cursorSpace;
+ private int count;
+ private final static int CURSOR_SPACE_SIZE = 100;
+
+
+ {
+ // init at loading time
+ cursorSpace = new Node[CURSOR_SPACE_SIZE];
+ for (int i = 0; i < CURSOR_SPACE_SIZE; i++) {
+ cursorSpace[i] = new Node<>(null, i + 1);
+ }
+ cursorSpace[CURSOR_SPACE_SIZE - 1].next = 0;
+ }
+
+
+ public CursorLinkedList() {
+ os = 0;
+ count = 0;
+ head = -1;
+ }
+
+ public void printList() {
+
+ if (head != -1) {
+
+
+ int start = head;
+ while (start != -1) {
+
+ T element = cursorSpace[start].element;
+ System.out.println(element.toString());
+ start = cursorSpace[start].next;
+ }
+ }
+
+ }
+
+
+ /**
+ * @return the logical index of the element within the list , not the actual
+ * index of the [cursorSpace] array
+ */
+ public int indexOf(T element) {
+
+
+ Objects.requireNonNull(element);
+ Node iterator = cursorSpace[head];
+ for (int i = 0; i < count; i++) {
+ if (iterator.element.equals(element)) {
+ return i;
+ }
+ iterator = cursorSpace[iterator.next];
+ }
+
+
+ return -1;
+ }
+
+
+ /**
+ * @param position , the logical index of the element , not the actual one
+ * within the [cursorSpace] array .
+ * this method should be used to get the index give by indexOf() method.
+ * @return
+ */
+
+ public T get(int position) {
+
+ if (position >= 0 && position < count) {
+
+ int start = head;
+ int counter = 0;
+ while (start != -1) {
+
+ T element = cursorSpace[start].element;
+ if (counter == position) {
+ return element;
+ }
+
+ start = cursorSpace[start].next;
+ counter++;
+ }
+
+ }
+
+ return null;
+ }
+
+
+ public void removeByIndex(int index) {
+
+ if (index >= 0 && index < count) {
+
+ T element = get(index);
+ remove(element);
+ }
+
+ }
+
+ public void remove(T element) {
+
+
+ Objects.requireNonNull(element);
+
+ // case element is in the head
+ T temp_element = cursorSpace[head].element;
+ int temp_next = cursorSpace[head].next;
+ if (temp_element.equals(element)) {
+ free(head);
+ head = temp_next;
+ } else { // otherwise cases
+
+ int prev_index = head;
+ int current_index = cursorSpace[prev_index].next;
+
+ while (current_index != -1) {
+
+ T current_element = cursorSpace[current_index].element;
+ if (current_element.equals(element)) {
+ cursorSpace[prev_index].next = cursorSpace[current_index].next;
+ free(current_index);
+ break;
+ }
+
+ prev_index = current_index;
+ current_index = cursorSpace[prev_index].next;
+ }
+
+ }
+
+
+ count--;
+
+ }
+
+ private void free(int index) {
+
+ Node os_node = cursorSpace[os];
+ int os_next = os_node.next;
+ cursorSpace[os].next = index;
+ cursorSpace[index].element = null;
+ cursorSpace[index].next = os_next;
+
+ }
+
+
+ public void append(T element) {
+
+ Objects.requireNonNull(element);
+ int availableIndex = alloc();
+ cursorSpace[availableIndex].element = element;
+
+ if (head == -1) {
+ head = availableIndex;
+ }
+
+ int iterator = head;
+ while (cursorSpace[iterator].next != -1) {
+ iterator = cursorSpace[iterator].next;
+ }
+
+ cursorSpace[iterator].next = availableIndex;
+ cursorSpace[availableIndex].next = -1;
+
+
+ count++;
+ }
+
+ /**
+ * @return the index of the next available node
+ */
+ private int alloc() {
+
+
+ //1- get the index at which the os is pointing
+ int availableNodeIndex = cursorSpace[os].next;
+
+ if (availableNodeIndex == 0) {
+ throw new OutOfMemoryError();
+ }
+
+ //2- make the os point to the next of the @var{availableNodeIndex}
+ int availableNext = cursorSpace[availableNodeIndex].next;
+ cursorSpace[os].next = availableNext;
+
+ // this to indicate an end of the list , helpful at testing since any err
+ // would throw an outOfBoundException
+ cursorSpace[availableNodeIndex].next = -1;
+
+ return availableNodeIndex;
+
+ }
+
+
+}
diff --git a/DataStructures/Lists/DoublyLinkedList.java b/DataStructures/Lists/DoublyLinkedList.java
index c3229d9c336d..677487e1d2b0 100644
--- a/DataStructures/Lists/DoublyLinkedList.java
+++ b/DataStructures/Lists/DoublyLinkedList.java
@@ -1,214 +1,248 @@
+package DataStructures.Lists;
+
/**
* This class implements a DoublyLinkedList. This is done using the classes
* LinkedList and Link.
- *
- * A linked list is simplar to an array, it holds values. However,
- * links in a linked list do not have indees. With a linked list
+ *
+ * A linked list is similar to an array, it holds values. However,
+ * links in a linked list do not have indexes. With a linked list
* you do not need to predetermine it's size as it grows and shrinks
* as it is edited. This is an example of a double ended, doubly
* linked list. Each link references the next link and the previous
* one.
- *
- * @author Unknown
*
+ * @author Unknown
*/
-class DoublyLinkedList{
- /** Head refers to the front of the list */
- private Link head;
- /** Tail refers to the back of the list */
- private Link tail;
-
- /**
- * Constructor
- */
- public DoublyLinkedList(){
- head = null;
- tail = null;
- }
-
- /**
- * Insert an element at the head
- *
- * @param x Element to be inserted
- */
- public void insertHead(int x){
- Link newLink = new Link(x); //Create a new link with a value attached to it
- if(isEmpty()) //Set the first element added to be the tail
- tail = newLink;
- else
- head.previous = newLink; // newLink <-- currenthead(head)
- newLink.next = head; // newLink <--> currenthead(head)
- head = newLink; // newLink(head) <--> oldhead
- }
-
- /**
- * Insert an element at the tail
- *
- * @param x Element to be inserted
- */
- public void insertTail(int x){
- Link newLink = new Link(x);
- newLink.next = null; // currentTail(tail) newlink -->
- tail.next = newLink; // currentTail(tail) --> newLink -->
- newLink.previous = tail; // currentTail(tail) <--> newLink -->
- tail = newLink; // oldTail <--> newLink(tail) -->
- }
-
- /**
- * Delete the element at the head
- *
- * @return The new head
- */
- public Link deleteHead(){
- Link temp = head;
- head = head.next; // oldHead <--> 2ndElement(head)
- head.previous = null; // oldHead --> 2ndElement(head) nothing pointing at old head so will be removed
- if(head == null)
- tail = null;
- return temp;
- }
-
- /**
- * Delete the element at the tail
- *
- * @return The new tail
- */
- public Link deleteTail(){
- Link temp = tail;
- tail = tail.previous; // 2ndLast(tail) <--> oldTail --> null
- tail.next = null; // 2ndLast(tail) --> null
- return temp;
- }
-
- /**
- * Delete the element from somewhere in the list
- *
- * @param x element to be deleted
- * @return Link deleted
- */
- public Link delete(int x){
- Link current = head;
-
- while(current.value != x) //Find the position to delete
- current = current.next;
-
- if(current == head)
- deleteHead();
-
- else if(current == tail)
- deleteTail();
-
- else{ //Before: 1 <--> 2(current) <--> 3
- current.previous.next = current.next; // 1 --> 3
- current.next.previous = current.previous; // 1 <--> 3
- }
- return current;
- }
-
- /**
- * Inserts element and reorders
- *
- * @param x Element to be added
- */
- public void insertOrdered(int x){
- Link newLink = new Link(x);
- Link current = head;
- while(current != null && x > current.value) //Find the position to insert
- current = current.next;
-
- if(current == head)
- insertHead(x);
-
- else if(current == null)
- insertTail(x);
-
- else{ //Before: 1 <--> 2(current) <--> 3
- newLink.previous = current.previous; // 1 <-- newLink
- current.previous.next = newLink; // 1 <--> newLink
- newLink.next = current; // 1 <--> newLink --> 2(current) <--> 3
- current.previous = newLink; // 1 <--> newLink <--> 2(current) <--> 3
- }
- }
-
- /**
- * Returns true if list is empty
- *
- * @return true if list is empty
- */
- public boolean isEmpty(){
- return(head == null);
- }
-
- /**
- * Prints contents of the list
- */
- public void display(){ //Prints contents of the list
- Link current = head;
- while(current!=null){
- current.displayLink();
- current = current.next;
- }
- System.out.println();
- }
+public class DoublyLinkedList {
+ /**
+ * Head refers to the front of the list
+ */
+ private Link head;
+ /**
+ * Tail refers to the back of the list
+ */
+ private Link tail;
+
+ /**
+ * Default Constructor
+ */
+ public DoublyLinkedList() {
+ head = null;
+ tail = null;
+ }
+
+ /**
+ * Constructs a list containing the elements of the array
+ *
+ * @param array the array whose elements are to be placed into this list
+ * @throws NullPointerException if the specified collection is null
+ */
+ public DoublyLinkedList(int[] array) {
+ if (array == null) throw new NullPointerException();
+ for (int i : array) {
+ insertTail(i);
+ }
+ }
+
+ /**
+ * Insert an element at the head
+ *
+ * @param x Element to be inserted
+ */
+ public void insertHead(int x) {
+ Link newLink = new Link(x); // Create a new link with a value attached to it
+ if (isEmpty()) // Set the first element added to be the tail
+ tail = newLink;
+ else
+ head.previous = newLink; // newLink <-- currenthead(head)
+ newLink.next = head; // newLink <--> currenthead(head)
+ head = newLink; // newLink(head) <--> oldhead
+ }
+
+ /**
+ * Insert an element at the tail
+ *
+ * @param x Element to be inserted
+ */
+ public void insertTail(int x) {
+ Link newLink = new Link(x);
+ newLink.next = null; // currentTail(tail) newlink -->
+ if (isEmpty()) { // Check if there are no elements in list then it adds first element
+ tail = newLink;
+ head = tail;
+ } else {
+ tail.next = newLink; // currentTail(tail) --> newLink -->
+ newLink.previous = tail; // currentTail(tail) <--> newLink -->
+ tail = newLink; // oldTail <--> newLink(tail) -->
+ }
+ }
+
+ /**
+ * Delete the element at the head
+ *
+ * @return The new head
+ */
+ public Link deleteHead() {
+ Link temp = head;
+ head = head.next; // oldHead <--> 2ndElement(head)
+ head.previous = null; // oldHead --> 2ndElement(head) nothing pointing at old head so will be removed
+ if (head == null)
+ tail = null;
+ return temp;
+ }
+
+ /**
+ * Delete the element at the tail
+ *
+ * @return The new tail
+ */
+ public Link deleteTail() {
+ Link temp = tail;
+ tail = tail.previous; // 2ndLast(tail) <--> oldTail --> null
+ tail.next = null; // 2ndLast(tail) --> null
+ if (tail == null) {
+ head = null;
+ }
+ return temp;
+ }
+
+ /**
+ * Delete the element from somewhere in the list
+ *
+ * @param x element to be deleted
+ * @return Link deleted
+ */
+ public void delete(int x) {
+ Link current = head;
+
+ while (current.value != x) {// Find the position to delete
+ if (current != tail) {
+ current = current.next;
+ } else {// If we reach the tail and the element is still not found
+ throw new RuntimeException("The element to be deleted does not exist!");
+ }
+ }
+
+ if (current == head)
+ deleteHead();
+
+ else if (current == tail)
+ deleteTail();
+
+ else { // Before: 1 <--> 2(current) <--> 3
+ current.previous.next = current.next; // 1 --> 3
+ current.next.previous = current.previous; // 1 <--> 3
+ }
+ }
+
+ /**
+ * Inserts element and reorders
+ *
+ * @param x Element to be added
+ */
+ public void insertOrdered(int x) {
+ Link newLink = new Link(x);
+ Link current = head;
+ while (current != null && x > current.value) // Find the position to insert
+ current = current.next;
+
+ if (current == head)
+ insertHead(x);
+
+ else if (current == null)
+ insertTail(x);
+
+ else { // Before: 1 <--> 2(current) <--> 3
+ newLink.previous = current.previous; // 1 <-- newLink
+ current.previous.next = newLink; // 1 <--> newLink
+ newLink.next = current; // 1 <--> newLink --> 2(current) <--> 3
+ current.previous = newLink; // 1 <--> newLink <--> 2(current) <--> 3
+ }
+ }
+
+ /**
+ * Returns true if list is empty
+ *
+ * @return true if list is empty
+ */
+ public boolean isEmpty() {
+ return (head == null);
+ }
+
+ /**
+ * Prints contents of the list
+ */
+ public void display() { // Prints contents of the list
+ Link current = head;
+ while (current != null) {
+ current.displayLink();
+ current = current.next;
+ }
+ System.out.println();
+ }
}
/**
* This class is used to implement the nodes of the
* linked list.
- *
- * @author Unknown
*
+ * @author Unknown
*/
-class Link{
- /** Value of node */
- public int value;
- /** This points to the link in front of the new link */
- public Link next;
- /** This points to the link behind the new link */
- public Link previous;
-
- /**
- * Constructor
- *
- * @param value Value of node
- */
- public Link(int value){
- this.value = value;
- }
-
- /**
- * Displays the node
- */
- public void displayLink(){
- System.out.print(value+" ");
- }
-
- /**
- * Main Method
- *
- * @param args Command line arguments
- */
- public static void main(String args[]){
- DoublyLinkedList myList = new DoublyLinkedList();
-
- myList.insertHead(13);
- myList.insertHead(7);
- myList.insertHead(10);
- myList.display(); // <-- 10(head) <--> 7 <--> 13(tail) -->
-
- myList.insertTail(11);
- myList.display(); // <-- 10(head) <--> 7 <--> 13 <--> 11(tail) -->
-
- myList.deleteTail();
- myList.display(); // <-- 10(head) <--> 7 <--> 13(tail) -->
-
- myList.delete(7);
- myList.display(); // <-- 10(head) <--> 13(tail) -->
-
- myList.insertOrdered(23);
- myList.insertOrdered(67);
- myList.insertOrdered(3);
- myList.display(); // <-- 3(head) <--> 10 <--> 13 <--> 23 <--> 67(tail) -->
- }
-}
\ No newline at end of file
+class Link {
+ /**
+ * Value of node
+ */
+ public int value;
+ /**
+ * This points to the link in front of the new link
+ */
+ public Link next;
+ /**
+ * This points to the link behind the new link
+ */
+ public Link previous;
+
+ /**
+ * Constructor
+ *
+ * @param value Value of node
+ */
+ public Link(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Displays the node
+ */
+ public void displayLink() {
+ System.out.print(value + " ");
+ }
+
+ /**
+ * Main Method
+ *
+ * @param args Command line arguments
+ */
+ public static void main(String args[]) {
+ DoublyLinkedList myList = new DoublyLinkedList();
+ myList.insertHead(13);
+ myList.insertHead(7);
+ myList.insertHead(10);
+ myList.display(); // <-- 10(head) <--> 7 <--> 13(tail) -->
+
+ myList.insertTail(11);
+ myList.display(); // <-- 10(head) <--> 7 <--> 13 <--> 11(tail) -->
+
+ myList.deleteTail();
+ myList.display(); // <-- 10(head) <--> 7 <--> 13(tail) -->
+
+ myList.delete(7);
+ myList.display(); // <-- 10(head) <--> 13(tail) -->
+
+ myList.insertOrdered(23);
+ myList.insertOrdered(67);
+ myList.insertOrdered(3);
+ myList.display(); // <-- 3(head) <--> 10 <--> 13 <--> 23 <--> 67(tail) -->
+ }
+}
diff --git a/DataStructures/Lists/Merge_K_SortedLinkedlist.java b/DataStructures/Lists/Merge_K_SortedLinkedlist.java
new file mode 100644
index 000000000000..bdee79f8f5f7
--- /dev/null
+++ b/DataStructures/Lists/Merge_K_SortedLinkedlist.java
@@ -0,0 +1,56 @@
+package DataStructures.Lists;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+/**
+ * @author Arun Pandey (https://github.com/pandeyarun709)
+ */
+public class Merge_K_SortedLinkedlist {
+
+ /**
+ * This function merge K sorted LinkedList
+ *
+ * @param a array of LinkedList
+ * @param N size of array
+ * @return node
+ */
+ Node mergeKList(Node[] a, int N) {
+ // Min Heap
+ PriorityQueue min = new PriorityQueue<>(Comparator.comparingInt(x -> x.data));
+
+ // adding head of all linkedList in min heap
+ min.addAll(Arrays.asList(a).subList(0, N));
+
+ // Make new head among smallest heads in K linkedList
+ Node head = min.poll();
+ min.add(head.next);
+ Node curr = head;
+
+ // merging LinkedList
+ while (!min.isEmpty()) {
+
+ Node temp = min.poll();
+ curr.next = temp;
+ curr = temp;
+
+ // Add Node in min Heap only if temp.next is not null
+ if (temp.next != null) {
+ min.add(temp.next);
+ }
+ }
+
+ return head;
+ }
+
+ private class Node {
+ private int data;
+ private Node next;
+
+ public Node(int d) {
+ this.data = d;
+ next = null;
+ }
+ }
+}
diff --git a/DataStructures/Lists/SinglyLinkedList.java b/DataStructures/Lists/SinglyLinkedList.java
index 32747cf2830f..356d8e2206cb 100644
--- a/DataStructures/Lists/SinglyLinkedList.java
+++ b/DataStructures/Lists/SinglyLinkedList.java
@@ -1,151 +1,178 @@
+package DataStructures.Lists;
+
/**
* This class implements a SinglyLinked List. This is done
* using SinglyLinkedList class and a LinkForLinkedList Class.
- *
- * A linked list is implar to an array, it hold values.
+ *
+ * A linked list is similar to an array, it hold values.
* However, links in a linked list do not have indexes. With
* a linked list you do not need to predetermine it's size as
- * it gorws and shrinks as it is edited. This is an example of
+ * it grows and shrinks as it is edited. This is an example of
* a singly linked list. Elements can only be added/removed
* at the head/front of the list.
- *
- * @author Unknown
- *
*/
-class SinglyLinkedList{
- /**Head refered to the front of the list */
- private Node head;
-
- /**
- * Constructor of SinglyLinkedList
- */
- public SinglyLinkedList(){
- head = null;
- }
-
- /**
- * This method inserts an element at the head
- *
- * @param x Element to be added
- */
- public void insertHead(int x){
- Node newNode = new Node(x); //Create a new link with a value attached to it
- newNode.next = head; //Set the new link to point to the current head
- head = newNode; //Now set the new link to be the head
- }
-
-
- /**
+public class SinglyLinkedList {
+ /**
+ * Head refer to the front of the list
+ */
+ private Node head;
+
+ /**
+ * This method inserts an element at the head
+ *
+ * @param x Element to be added
+ */
+ public void insertHead(int x) {
+ Node newNode = new Node(x);
+ newNode.next = head;
+ head = newNode;
+ }
+
+ /**
* Inserts a new node at a specified position
- * @param head head node of the linked list
+ *
* @param data data to be stored in a new node
* @param position position at which a new node is to be inserted
- * @return reference of the head of the linked list
*/
- Node InsertNth(Node head, int data, int position) {
-
- Node newNode = new Node();
- newNode.data = data;
-
- if (position == 0) {
- newNode.next = head;
- return newNode;
+ public void insertNth(int data, int position) {
+ if (position < 0 || position > getSize()) {
+ throw new RuntimeException("position less than zero or position more than the count of list");
+ } else if (position == 0)
+ insertHead(data);
+ else {
+ Node cur = head;
+ Node node = new Node(data);
+ for (int i = 1; i < position; ++i) {
+ cur = cur.next;
+ }
+ node.next = cur.next;
+ cur.next = node;
}
+ }
- Node current = head;
+ /**
+ * This method deletes an element at the head
+ *
+ * @return The element deleted
+ */
+ public void deleteHead() {
+ if (isEmpty()) {
+ throw new RuntimeException("The list is empty!");
+ }
+
+ head = head.next;
+ }
+
+ /**
+ * This method deletes an element at Nth position
+ */
+ public void deleteNth(int position) {
+ if (position < 0 || position >= getSize()) {
+ throw new RuntimeException("position less than zero or position more than the count of list");
+ } else if (position == 0)
+ deleteHead();
+ else {
+ Node cur = head;
+ for (int i = 1; i < position; ++i) {
+ cur = cur.next;
+ }
+ cur.next = cur.next.next;
+ }
+ }
- while (--position > 0) {
+ /**
+ * Checks if the list is empty
+ *
+ * @return true is list is empty
+ */
+ public boolean isEmpty() {
+ return getSize() == 0;
+ }
+
+ /**
+ * Prints contents of the list
+ */
+ public void display() {
+ Node current = head;
+ while (current != null) {
+ System.out.print(current.value + " ");
current = current.next;
}
-
- newNode.next = current.next;
- current.next = newNode;
- return head;
+ System.out.println();
+ }
+
+ /**
+ * Returns the size of the linked list
+ */
+ public int getSize() {
+ if (head == null)
+ return 0;
+ else {
+ Node current = head;
+ int size = 1;
+ while (current.next != null) {
+ current = current.next;
+ size++;
+ }
+ return size;
+ }
+ }
+
+ /**
+ * Main method
+ *
+ * @param args Command line arguments
+ */
+ public static void main(String args[]) {
+ SinglyLinkedList myList = new SinglyLinkedList();
+
+ assert myList.isEmpty();
+
+ myList.insertHead(5);
+ myList.insertHead(7);
+ myList.insertHead(10);
+
+ myList.display(); // 10 -> 7 -> 5
+
+ myList.deleteHead();
+
+ myList.display(); // 7 -> 5
+
+ myList.insertNth(11, 2);
+
+ myList.display(); // 7 -> 5 -> 11
+
+ myList.deleteNth(1);
+
+ myList.display(); // 7-> 11
+
}
-
- /**
- * This method deletes an element at the head
- *
- * @return The element deleted
- */
- public Node deleteHead(){
- Node temp = head;
- head = head.next; //Make the second element in the list the new head, the Java garbage collector will later remove the old head
- return temp;
- }
-
- /**
- * Checks if the list is empty
- *
- * @return true is list is empty
- */
- public boolean isEmpty(){
- return(head == null);
- }
-
- /**
- * Prints contents of the list
- */
- public void display(){
- Node current = head;
- while(current!=null){
- System.out.print(current.getValue()+" ");
- current = current.next;
- }
- System.out.println();
- }
-
- /**
- * Main method
- *
- * @param args Command line arguments
- */
- public static void main(String args[]){
- SinglyLinkedList myList = new SinglyLinkedList();
-
- System.out.println(myList.isEmpty()); //Will print true
-
- myList.insertHead(5);
- myList.insertHead(7);
- myList.insertHead(10);
-
- myList.display(); // 10(head) --> 7 --> 5
-
- myList.deleteHead();
-
- myList.display(); // 7(head) --> 5
- }
}
/**
* This class is the nodes of the SinglyLinked List.
- * They consist of a vlue and a pointer to the node
+ * They consist of a value and a pointer to the node
* after them.
- *
- * @author Unknown
- *
*/
-class Node{
- /** The value of the node */
- public int value;
- /** Point to the next node */
- public Node next; //This is what the link will point to
-
- /**
- * Constructor
- *
- * @param valuein Value to be put in the node
- */
- public Node(int valuein){
- value = valuein;
- }
-
- /**
- * Returns value of the node
- */
- public int getValue(){
- return value;
- }
+class Node {
+ /**
+ * The value of the node
+ */
+ int value;
+
+ /**
+ * Point to the next node
+ */
+ Node next;
+ /**
+ * Constructor
+ *
+ * @param value Value to be put in the node
+ */
+ Node(int value) {
+ this.value = value;
+ this.next = null;
+ }
}
diff --git a/DataStructures/Matrix/Matrix.java b/DataStructures/Matrix/Matrix.java
deleted file mode 100644
index 6b055362ce69..000000000000
--- a/DataStructures/Matrix/Matrix.java
+++ /dev/null
@@ -1,259 +0,0 @@
-/**
-* Matrix data-type.
-*
-* @author Kyler Smith, 2017
-*/
-
-
-public class Matrix {
-
- public static void main(String[] args) {
-
- int[][] data1 = new int[0][0];
- int[][] data2 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
- int[][] data3 = {{1, 4, 7}, {2, 5, 8}, {3, 6, 9}};
-
- Matrix m1 = new Matrix(data1);
- Matrix m2 = new Matrix(data2);
- Matrix m3 = new Matrix(data3);
-
- System.out.println("m1 --> Rows: " + m1.getRows() + " Columns: " + m1.getColumns());
- System.out.println("m2 --> Rows: " + m2.getRows() + " Columns: " + m2.getColumns());
- System.out.println("m3 --> Rows: " + m3.getRows() + " Columns: " + m3.getColumns());
-
- //check for reference issues
- System.out.println("m2 -->\n" + m2);
- data2[1][1] = 101;
- System.out.println("m2 -->\n" + m2);
-
- //test equals
- System.out.println("m2==null: " + m2.equals(null)); //false
- System.out.println("m3==\"MATRIX\": " + m2.equals("MATRIX")); //false
- System.out.println("m2==m1: " + m2.equals(m1)); //false
- System.out.println("m2==m2: " + m2.equals(m2)); //true
- System.out.println("m2==m3: " + m2.equals(m3)); //false
-
- //test operations (valid)
- System.out.println("2 * m2:\n" + m2.scale(2));
- System.out.println("m2 / 2:\n" + m2.divide(2));
- System.out.println("m2 + m3:\n" + m2.plus(m3));
- System.out.println("m2 - m3:\n" + m2.minus(m3));
- System.out.println("m2 * m3: \n"+m2.multiply(m3));
- }
-
-
- /**
- * Data needs to be a deep copy as not to change the original state.
- */
- private int[][] data;
-
- /**
- * Constructor for the matrix takes in a 2D array
- *
- * @param pData
- */
- public Matrix(int[][] pData) {
-
- /** Make a deep copy of the data */
- if(pData.length != 0) {
- int[][] newData = new int[pData.length][pData[0].length];
-
- for(int i = 0; i < pData.length; i++)
- for(int j = 0; j < pData[0].length; j++)
- newData[i][j] = pData[i][j];
-
- this.data = newData;
- } else {
- this.data = null;
- }
- }
-
- /**
- * Returns the element specified by the given location
- *
- * @param x : x cooridinate
- * @param y : y cooridinate
- * @return int : value at location
- */
- public int getElement(int x, int y) {
- return data[x][y];
- }
-
- /**
- * Returns the number of rows in the Matrix
- *
- * @return rows
- */
- public int getRows() {
- if(this.data == null)
- return 0;
-
- return data.length;
- }
-
- /**
- * Returns the number of rows in the Matrix
- *
- * @return columns
- */
- public int getColumns() {
- if(this.data == null)
- return 0;
- return data[0].length;
- }
-
- /**
- * Returns this matrix scaled by a factor. That is, computes sA where s is a
- * constant and A is a matrix (this object).
- *
- * @param scalar : value to scale by
- * @return A new matrix scaled by the scalar value
- */
- public Matrix scale(int scalar) {
-
- int[][] newData = new int[this.data.length][this.data[0].length];
-
- for (int i = 0; i < this.getRows(); ++i)
- for(int j = 0; j < this.getColumns(); ++j)
- newData[i][j] = this.data[i][j] * scalar;
-
- return new Matrix(newData);
- }
-
- /**
- * Returns this matrix divided by a factor. That is, computes sA where s is a
- * constant and A is a matrix (this object).
- *
- * @param scalar : value to divide by
- * @return A new matrix scaled by the scalar value
- */
- public Matrix divide(int scalar) {
-
- int[][] newData = new int[this.data.length][this.data[0].length];
-
- for (int i = 0; i < this.getRows(); ++i)
- for(int j = 0; j < this.getColumns(); ++j)
- newData[i][j] = this.data[i][j] / scalar;
-
- return new Matrix(newData);
- }
-
- /**
- * Adds this matrix to another matrix.
- *
- * @param other : Matrix to be added
- * @return addend
- */
- public Matrix plus(Matrix other) throws RuntimeException {
-
- int[][] newData = new int[this.data.length][this.data[0].length];
-
- if(this.getRows() != other.getRows() || this.getColumns() != other.getColumns())
- throw new RuntimeException("Not the same size matrix.");
-
- for (int i = 0; i < this.getRows(); ++i)
- for(int j = 0; j < this.getColumns(); ++j)
- newData[i][j] = this.data[i][j] + other.getElement(i, j);
-
- return new Matrix(newData);
- }
-
- /**
- * Subtracts this matrix from another matrix.
- *
- * @param other : Matrix to be subtracted
- * @return difference
- */
- public Matrix minus(Matrix other) throws RuntimeException {
-
- int[][] newData = new int[this.data.length][this.data[0].length];
-
- if(this.getRows() != other.getRows() || this.getColumns() != other.getColumns())
- throw new RuntimeException("Not the same size matrix.");
-
- for (int i = 0; i < this.getRows(); ++i)
- for(int j = 0; j < this.getColumns(); ++j)
- newData[i][j] = this.data[i][j] - other.getElement(i, j);
-
- return new Matrix(newData);
- }
-
- /**
- * Multiplies this matrix with another matrix.
- *
- * @param other : Matrix to be multiplied with
- * @return product
- */
- public Matrix multiply(Matrix other) throws RuntimeException {
-
- int[][] newData = new int[this.data.length][other.getColumns()];
-
- if(this.getColumns() !=other.getRows())
- throw new RuntimeException("The two matrices cannot be multiplied.");
- int sum;
- for (int i = 0; i < this.getRows(); ++i)
- for(int j = 0; j < other.getColumns(); ++j){
- sum = 0;
- for(int k=0;k
+ * A GenericArrayListQueue data structure functions the same as any specific-typed queue.
+ * The GenericArrayListQueue holds elemets of types to-be-specified at runtime.
+ * The elements that are added first are the first to be removed (FIFO)
+ * New elements are added to the back/rear of the queue.
+ *
+ */
public class GenericArrayListQueue {
+ /**
+ * The generic ArrayList for the queue
+ * T is the generic element
+ */
ArrayList _queue = new ArrayList();
+ /**
+ * Checks if the queue has elements (not empty)
+ *
+ * @return True if the queue has elements. False otherwise.
+ */
private boolean hasElements() {
return !_queue.isEmpty();
}
+ /**
+ * Checks what's at the front of the queue
+ *
+ * @return If queue is not empty, element at the front of the queue. Otherwise, null
+ */
public T peek() {
T result = null;
if(this.hasElements()) { result = _queue.get(0); }
return result;
}
+ /**
+ * Inserts an element of type T to the queue.
+ *
+ * @param element of type T to be added
+ * @return True if the element was added successfully
+ */
public boolean add(T element) {
return _queue.add(element);
}
+ /**
+ * Retrieve what's at the front of the queue
+ *
+ * @return If queue is not empty, element retrieved. Otherwise, null
+ */
public T poll() {
T result = null;
if(this.hasElements()) { result = _queue.remove(0); }
return result;
}
+ /**
+ * Main method
+ *
+ * @param args Command line arguments
+ */
public static void main(String[] args) {
GenericArrayListQueue queue = new GenericArrayListQueue();
System.out.println("Running...");
diff --git a/DataStructures/Queues/PriorityQueues.java b/DataStructures/Queues/PriorityQueues.java
index acb6b552537e..bbefa1f6949e 100644
--- a/DataStructures/Queues/PriorityQueues.java
+++ b/DataStructures/Queues/PriorityQueues.java
@@ -1,123 +1,129 @@
+package DataStructures.Queues;
+
/**
* This class implements a PriorityQueue.
- *
+ *
* A priority queue adds elements into positions based on their priority.
* So the most important elements are placed at the front/on the top.
* In this example I give numbers that are bigger, a higher priority.
* Queues in theory have no fixed size but when using an array
* implementation it does.
- *
- * @author Unknown
- *
*/
-class PriorityQueue{
- /** The max size of the queue */
- private int maxSize;
- /** The array for the queue */
- private int[] queueArray;
- /** How many items are in the queue */
- private int nItems;
+class PriorityQueue {
+ /**
+ * The max size of the queue
+ */
+ private int maxSize;
+ /**
+ * The array for the queue
+ */
+ private int[] queueArray;
+ /**
+ * How many items are in the queue
+ */
+ private int nItems;
- /**
- * Constructor
- *
- * @param size Size of the queue
- */
- public PriorityQueue(int size){
- maxSize = size;
- queueArray = new int[size];
- nItems = 0;
- }
+ /**
+ * Constructor
+ *
+ * @param size Size of the queue
+ */
+ public PriorityQueue(int size) {
+ maxSize = size;
+ queueArray = new int[size];
+ nItems = 0;
+ }
- /**
- * Inserts an element in it's appropriate place
- *
- * @param value Value to be inserted
- */
- public void insert(int value){
- if(nItems == 0){
- queueArray[0] = value;
- }
- else{
- int j = nItems;
- while(j > 0 && queueArray[j-1] > value){
- queueArray[j] = queueArray[j-1]; //Shifts every element up to make room for insertion
- j--;
- }
- queueArray[j] = value; //Once the correct position is found the value is inserted
- }
- nItems++;
- }
+ /**
+ * Inserts an element in it's appropriate place
+ *
+ * @param value Value to be inserted
+ */
+ public void insert(int value) {
+ if (isFull()) {
+ throw new RuntimeException("Queue is full");
+ }
+ if (nItems == 0) {
+ queueArray[0] = value;
+ } else {
+ int j = nItems;
+ while (j > 0 && queueArray[j - 1] > value) {
+ queueArray[j] = queueArray[j - 1]; // Shifts every element up to make room for insertion
+ j--;
+ }
+ queueArray[j] = value; // Once the correct position is found the value is inserted
+ }
+ nItems++;
+ }
- /**
- * Remove the element from the front of the queue
- *
- * @return The element removed
- */
- public int remove(){
- return queueArray[--nItems];
- }
+ /**
+ * Remove the element from the front of the queue
+ *
+ * @return The element removed
+ */
+ public int remove() {
+ return queueArray[--nItems];
+ }
- /**
- * Checks what's at the front of the queue
- *
- * @return element at the front of the queue
- */
- public int peek(){
- return queueArray[nItems-1];
- }
+ /**
+ * Checks what's at the front of the queue
+ *
+ * @return element at the front of the queue
+ */
+ public int peek() {
+ return queueArray[nItems - 1];
+ }
- /**
- * Returns true if the queue is empty
- *
- * @return true if the queue is empty
- */
- public boolean isEmpty(){
- return(nItems == 0);
- }
+ /**
+ * Returns true if the queue is empty
+ *
+ * @return true if the queue is empty
+ */
+ public boolean isEmpty() {
+ return (nItems == 0);
+ }
- /**
- * Returns true if the queue is full
- *
- * @return true if the queue is full
- */
- public boolean isFull(){
- return(nItems == maxSize);
- }
+ /**
+ * Returns true if the queue is full
+ *
+ * @return true if the queue is full
+ */
+ public boolean isFull() {
+ return (nItems == maxSize);
+ }
- /**
- * Returns the number of elements in the queue
- *
- * @return number of elements in the queue
- */
- public int getSize(){
- return nItems;
- }
+ /**
+ * Returns the number of elements in the queue
+ *
+ * @return number of elements in the queue
+ */
+ public int getSize() {
+ return nItems;
+ }
}
/**
* This class implements the PriorityQueue class above.
- *
- * @author Unknown
*
+ * @author Unknown
*/
-public class PriorityQueues{
- /**
- * Main method
- *
- * @param args Command Line Arguments
- */
- public static void main(String args[]){
- PriorityQueue myQueue = new PriorityQueue(4);
- myQueue.insert(10);
- myQueue.insert(2);
- myQueue.insert(5);
- myQueue.insert(3);
- //[2, 3, 5, 10] Here higher numbers have higher priority, so they are on the top
+public class PriorityQueues {
+ /**
+ * Main method
+ *
+ * @param args Command Line Arguments
+ */
+ public static void main(String[] args) {
+ PriorityQueue myQueue = new PriorityQueue(4);
+ myQueue.insert(10);
+ myQueue.insert(2);
+ myQueue.insert(5);
+ myQueue.insert(3);
+ // [2, 3, 5, 10] Here higher numbers have higher priority, so they are on the top
- for(int i = 3; i>=0; i--)
- System.out.print(myQueue.remove() + " "); //will print the queue in reverse order [10, 5, 3, 2]
+ for (int i = 3; i >= 0; i--)
+ System.out.print(myQueue.remove() + " "); // will print the queue in reverse order [10, 5, 3, 2]
- //As you can see, a Priority Queue can be used as a sorting algotithm
- }
-}
\ No newline at end of file
+ // As you can see, a Priority Queue can be used as a sorting algotithm
+ }
+}
diff --git a/DataStructures/Queues/Queues.java b/DataStructures/Queues/Queues.java
index 84638cb24751..046964bcb114 100644
--- a/DataStructures/Queues/Queues.java
+++ b/DataStructures/Queues/Queues.java
@@ -1,148 +1,158 @@
+package DataStructures.Queues;
+
/**
* This implements Queues by using the class Queue.
- *
+ *
* A queue data structure functions the same as a real world queue.
* The elements that are added first are the first to be removed.
* New elements are added to the back/rear of the queue.
- *
- * @author Unknown
*
+ * @author Unknown
*/
-class Queue{
- /** Max size of the queue */
- private int maxSize;
- /** The array representing the queue */
- private int[] queueArray;
- /** Front of the queue */
- private int front;
- /** Rear of the queue */
- private int rear;
- /** How many items are in the queue */
- private int nItems;
-
- /**
- * Constructor
- *
- * @param size Size of the new queue
- */
- public Queue(int size){
- maxSize = size;
- queueArray = new int[size];
- front = 0;
- rear = -1;
- nItems = 0;
- }
-
- /**
- * Inserts an element at the rear of the queue
- *
- * @param x element to be added
- * @return True if the element was added successfully
- */
- public boolean insert(int x){
- if(isFull())
- return false;
- if(rear == maxSize-1) //If the back of the queue is the end of the array wrap around to the front
- rear = -1;
- rear++;
- queueArray[rear] = x;
- nItems++;
- return true;
- }
-
- /**
- * Remove an element from the front of the queue
- *
- * @return the new front of the queue
- */
- public int remove(){ //Remove an element from the front of the queue
- if(isEmpty()){
- System.out.println("Queue is empty");
- return -1;
- }
- int temp = queueArray[front];
- front++;
- if(front == maxSize) //Dealing with wrap-around again
- front = 0;
- nItems--;
- return temp;
- }
-
- /**
- * Checks what's at the front of the queue
- *
- * @return element at the front of the queue
- */
- public int peekFront(){
- return queueArray[front];
- }
-
- /**
- * Checks what's at the rear of the queue
- *
- * @return element at the rear of the queue
- */
- public int peekRear(){
- return queueArray[rear];
- }
-
- /**
- * Returns true if the queue is empty
- *
- * @return true if the queue is empty
- */
- public boolean isEmpty(){
- return(nItems == 0);
- }
-
- /**
- * Returns true if the queue is full
- *
- * @return true if the queue is full
- */
- public boolean isFull(){
- return(nItems == maxSize);
- }
-
- /**
- * Returns the number of elements in the queue
- *
- * @return number of elements in the queue
- */
- public int getSize(){
- return nItems;
- }
+class Queue {
+ /**
+ * Max size of the queue
+ */
+ private int maxSize;
+ /**
+ * The array representing the queue
+ */
+ private int[] queueArray;
+ /**
+ * Front of the queue
+ */
+ private int front;
+ /**
+ * Rear of the queue
+ */
+ private int rear;
+ /**
+ * How many items are in the queue
+ */
+ private int nItems;
+
+ /**
+ * Constructor
+ *
+ * @param size Size of the new queue
+ */
+ public Queue(int size) {
+ maxSize = size;
+ queueArray = new int[size];
+ front = 0;
+ rear = -1;
+ nItems = 0;
+ }
+
+ /**
+ * Inserts an element at the rear of the queue
+ *
+ * @param x element to be added
+ * @return True if the element was added successfully
+ */
+ public boolean insert(int x) {
+ if (isFull())
+ return false;
+ if (rear == maxSize - 1) // If the back of the queue is the end of the array wrap around to the front
+ rear = -1;
+ rear++;
+ queueArray[rear] = x;
+ nItems++;
+ return true;
+ }
+
+ /**
+ * Remove an element from the front of the queue
+ *
+ * @return the new front of the queue
+ */
+ public int remove() { // Remove an element from the front of the queue
+ if (isEmpty()) {
+ System.out.println("Queue is empty");
+ return -1;
+ }
+ int temp = queueArray[front];
+ front++;
+ if (front == maxSize) //Dealing with wrap-around again
+ front = 0;
+ nItems--;
+ return temp;
+ }
+
+ /**
+ * Checks what's at the front of the queue
+ *
+ * @return element at the front of the queue
+ */
+ public int peekFront() {
+ return queueArray[front];
+ }
+
+ /**
+ * Checks what's at the rear of the queue
+ *
+ * @return element at the rear of the queue
+ */
+ public int peekRear() {
+ return queueArray[rear];
+ }
+
+ /**
+ * Returns true if the queue is empty
+ *
+ * @return true if the queue is empty
+ */
+ public boolean isEmpty() {
+ return (nItems == 0);
+ }
+
+ /**
+ * Returns true if the queue is full
+ *
+ * @return true if the queue is full
+ */
+ public boolean isFull() {
+ return (nItems == maxSize);
+ }
+
+ /**
+ * Returns the number of elements in the queue
+ *
+ * @return number of elements in the queue
+ */
+ public int getSize() {
+ return nItems;
+ }
}
/**
* This class is the example for the Queue class
- *
- * @author Unknown
*
+ * @author Unknown
*/
-public class Queues{
- /**
- * Main method
- *
- * @param args Command line arguments
- */
- public static void main(String args[]){
- Queue myQueue = new Queue(4);
- myQueue.insert(10);
- myQueue.insert(2);
- myQueue.insert(5);
- myQueue.insert(3);
- //[10(front), 2, 5, 3(rear)]
-
- System.out.println(myQueue.isFull()); //Will print true
-
- myQueue.remove(); //Will make 2 the new front, making 10 no longer part of the queue
- //[10, 2(front), 5, 3(rear)]
-
- myQueue.insert(7); //Insert 7 at the rear which will be index 0 because of wrap around
- // [7(rear), 2(front), 5, 3]
-
- System.out.println(myQueue.peekFront()); //Will print 2
- System.out.println(myQueue.peekRear()); //Will print 7
- }
-}
\ No newline at end of file
+public class Queues {
+ /**
+ * Main method
+ *
+ * @param args Command line arguments
+ */
+ public static void main(String args[]) {
+ Queue myQueue = new Queue(4);
+ myQueue.insert(10);
+ myQueue.insert(2);
+ myQueue.insert(5);
+ myQueue.insert(3);
+ // [10(front), 2, 5, 3(rear)]
+
+ System.out.println(myQueue.isFull()); // Will print true
+
+ myQueue.remove(); // Will make 2 the new front, making 10 no longer part of the queue
+ // [10, 2(front), 5, 3(rear)]
+
+ myQueue.insert(7); // Insert 7 at the rear which will be index 0 because of wrap around
+ // [7(rear), 2(front), 5, 3]
+
+ System.out.println(myQueue.peekFront()); // Will print 2
+ System.out.println(myQueue.peekRear()); // Will print 7
+ }
+}
diff --git a/DataStructures/Stacks/StackArray.java b/DataStructures/Stacks/StackArray.java
new file mode 100644
index 000000000000..cc8596293c4b
--- /dev/null
+++ b/DataStructures/Stacks/StackArray.java
@@ -0,0 +1,151 @@
+/**
+ * This class implements a Stack using a regular array.
+ *
+ * A stack is exactly what it sounds like. An element gets added to the top of
+ * the stack and only the element on the top may be removed. This is an example
+ * of an array implementation of a Stack. So an element can only be added/removed
+ * from the end of the array. In theory stack have no fixed size, but with an
+ * array implementation it does.
+ *
+ * @author Unknown
+ */
+public class StackArray {
+
+ /**
+ * Main method
+ *
+ * @param args Command line arguments
+ */
+ public static void main(String[] args) {
+ // Declare a stack of maximum size 4
+ StackArray myStackArray = new StackArray(4);
+
+ // Populate the stack
+ myStackArray.push(5);
+ myStackArray.push(8);
+ myStackArray.push(2);
+ myStackArray.push(9);
+
+ System.out.println("*********************Stack Array Implementation*********************");
+ System.out.println(myStackArray.isEmpty()); // will print false
+ System.out.println(myStackArray.isFull()); // will print true
+ System.out.println(myStackArray.peek()); // will print 9
+ System.out.println(myStackArray.pop()); // will print 9
+ System.out.println(myStackArray.peek()); // will print 2
+ }
+
+ /**
+ * The max size of the Stack
+ */
+ private int maxSize;
+
+ /**
+ * The array representation of the Stack
+ */
+ private int[] stackArray;
+
+ /**
+ * The top of the stack
+ */
+ private int top;
+
+ /**
+ * Constructor
+ *
+ * @param size Size of the Stack
+ */
+ public StackArray(int size) {
+ maxSize = size;
+ stackArray = new int[maxSize];
+ top = -1;
+ }
+
+ /**
+ * Adds an element to the top of the stack
+ *
+ * @param value The element added
+ */
+ public void push(int value) {
+ if (!isFull()) { // Checks for a full stack
+ top++;
+ stackArray[top] = value;
+ } else {
+ resize(maxSize * 2);
+ push(value); // don't forget push after resizing
+ }
+ }
+
+ /**
+ * Removes the top element of the stack and returns the value you've removed
+ *
+ * @return value popped off the Stack
+ */
+ public int pop() {
+ if (!isEmpty()) { // Checks for an empty stack
+ return stackArray[top--];
+ }
+
+ if (top < maxSize / 4) {
+ resize(maxSize / 2);
+ return pop();// don't forget pop after resizing
+ } else {
+ System.out.println("The stack is already empty");
+ return -1;
+ }
+ }
+
+ /**
+ * Returns the element at the top of the stack
+ *
+ * @return element at the top of the stack
+ */
+ public int peek() {
+ if (!isEmpty()) { // Checks for an empty stack
+ return stackArray[top];
+ } else {
+ System.out.println("The stack is empty, cant peek");
+ return -1;
+ }
+ }
+
+ private void resize(int newSize) {
+ int[] transferArray = new int[newSize];
+
+ for (int i = 0; i < stackArray.length; i++) {
+ transferArray[i] = stackArray[i];
+ }
+ // This reference change might be nice in here
+ stackArray = transferArray;
+ maxSize = newSize;
+ }
+
+ /**
+ * Returns true if the stack is empty
+ *
+ * @return true if the stack is empty
+ */
+ public boolean isEmpty() {
+ return (top == -1);
+ }
+
+ /**
+ * Returns true if the stack is full
+ *
+ * @return true if the stack is full
+ */
+ public boolean isFull() {
+ return (top + 1 == maxSize);
+ }
+
+ /**
+ * Deletes everything in the Stack
+ *
+ * Doesn't delete elements in the array
+ * but if you call push method after calling
+ * makeEmpty it will overwrite previous
+ * values
+ */
+ public void makeEmpty() { // Doesn't delete elements in the array but if you call
+ top = -1; // push method after calling makeEmpty it will overwrite previous values
+ }
+}
diff --git a/DataStructures/Stacks/StackArrayList.java b/DataStructures/Stacks/StackArrayList.java
new file mode 100644
index 000000000000..afc804440403
--- /dev/null
+++ b/DataStructures/Stacks/StackArrayList.java
@@ -0,0 +1,95 @@
+import java.util.ArrayList;
+
+/**
+ * This class implements a Stack using an ArrayList.
+ *
+ * A stack is exactly what it sounds like. An element gets added to the top of
+ * the stack and only the element on the top may be removed.
+ *
+ * This is an ArrayList Implementation of a stack, where size is not
+ * a problem we can extend the stack as much as we want.
+ *
+ * @author Unknown
+ */
+public class StackArrayList {
+
+ /**
+ * Main method
+ *
+ * @param args Command line arguments
+ */
+ public static void main(String[] args) {
+
+ StackArrayList myStackArrayList = new StackArrayList();
+
+ myStackArrayList.push(5);
+ myStackArrayList.push(8);
+ myStackArrayList.push(2);
+ myStackArrayList.push(9);
+
+ System.out.println("*********************Stack List Implementation*********************");
+ System.out.println(myStackArrayList.isEmpty()); // will print false
+ System.out.println(myStackArrayList.peek()); // will print 9
+ System.out.println(myStackArrayList.pop()); // will print 9
+ System.out.println(myStackArrayList.peek()); // will print 2
+ System.out.println(myStackArrayList.pop()); // will print 2
+ }
+
+ /**
+ * ArrayList representation of the stack
+ */
+ private ArrayList stackList;
+
+ /**
+ * Constructor
+ */
+ public StackArrayList() {
+ stackList = new ArrayList<>();
+ }
+
+ /**
+ * Adds value to the end of list which
+ * is the top for stack
+ *
+ * @param value value to be added
+ */
+ public void push(int value) {
+ stackList.add(value);
+ }
+
+ /**
+ * Pops last element of list which is indeed
+ * the top for Stack
+ *
+ * @return Element popped
+ */
+ public int pop() {
+
+ if (!isEmpty()) { // checks for an empty Stack
+ int popValue = stackList.get(stackList.size() - 1);
+ stackList.remove(stackList.size() - 1); // removes the poped element from the list
+ return popValue;
+ }
+
+ System.out.print("The stack is already empty!");
+ return -1;
+ }
+
+ /**
+ * Checks for empty Stack
+ *
+ * @return true if stack is empty
+ */
+ public boolean isEmpty() {
+ return stackList.isEmpty();
+ }
+
+ /**
+ * Top element of stack
+ *
+ * @return top element of stack
+ */
+ public int peek() {
+ return stackList.get(stackList.size() - 1);
+ }
+}
diff --git a/DataStructures/Stacks/StackOfLinkedList.java b/DataStructures/Stacks/StackOfLinkedList.java
index 35052457fe1c..093442112df5 100644
--- a/DataStructures/Stacks/StackOfLinkedList.java
+++ b/DataStructures/Stacks/StackOfLinkedList.java
@@ -1,7 +1,7 @@
+package DataStructures.Stacks;
+
/**
- *
* @author Varun Upadhyay (https://github.com/varunu28)
- *
*/
// An implementation of a Stack using a Linked List
@@ -25,9 +25,7 @@ public static void main(String[] args) {
stack.pop();
System.out.println("Top element of stack currently is: " + stack.peek());
-
}
-
}
// A node class
@@ -44,66 +42,71 @@ public Node(int data) {
/**
* A class which implements a stack using a linked list
- *
+ *
* Contains all the stack methods : push, pop, printStack, isEmpty
**/
class LinkedListStack {
Node head = null;
- int size = 0;
public void push(int x) {
Node n = new Node(x);
- if (getSize() == 0) {
+ if (head == null) {
head = n;
- }
- else {
+ } else {
Node temp = head;
n.next = temp;
head = n;
}
- size++;
}
public void pop() {
- if (getSize() == 0) {
+ if (head == null) {
System.out.println("Empty stack. Nothing to pop");
}
Node temp = head;
head = head.next;
- size--;
-
System.out.println("Popped element is: " + temp.data);
}
public int peek() {
- if (getSize() == 0) {
- return -1;
- }
-
- return head.data;
+ if (head == null) {
+ return -1;
+ }
+ return head.data;
}
public void printStack() {
-
Node temp = head;
System.out.println("Stack is printed as below: ");
while (temp != null) {
- System.out.println(temp.data + " ");
+ if (temp.next == null) {
+ System.out.print(temp.data);
+ } else {
+ System.out.print(temp.data + " -> ");
+ }
temp = temp.next;
}
System.out.println();
-
}
public boolean isEmpty() {
- return getSize() == 0;
+ return head == null;
}
public int getSize() {
- return size;
+ if (head == null)
+ return 0;
+ else {
+ int size = 1;
+ Node temp = head;
+ while (temp.next != null) {
+ temp = temp.next;
+ size++;
+ }
+ return size;
+ }
}
-
}
diff --git a/DataStructures/Stacks/Stacks.java b/DataStructures/Stacks/Stacks.java
deleted file mode 100644
index 2861ef5c17e8..000000000000
--- a/DataStructures/Stacks/Stacks.java
+++ /dev/null
@@ -1,240 +0,0 @@
-import java.util.ArrayList;
-
-/**
- * This class implements a Stack using two different implementations.
- * Stack is used with a regular array and Stack2 uses an ArrayList.
- *
- * A stack is exactly what it sounds like. An element gets added to the top of
- * the stack and only the element on the top may be removed. This is an example
- * of an array implementation of a Stack. So an element can only be added/removed
- * from the end of the array. In theory stack have no fixed size, but with an
- * array implementation it does.
- *
- * @author Unknown
- *
- */
-class Stack{
- /** The max size of the Stack */
- private int maxSize;
- /** The array representation of the Stack */
- private int[] stackArray;
- /** The top of the stack */
- private int top;
-
- /**
- * Constructor
- *
- * @param size Size of the Stack
- */
- public Stack(int size){
- maxSize = size;
- stackArray = new int[maxSize];
- top = -1;
- }
-
- /**
- * Adds an element to the top of the stack
- *
- * @param value The element added
- */
- public void push(int value){
- if(!isFull()){ //Checks for a full stack
- top++;
- stackArray[top] = value;
- }else{
- resize(maxSize*2);
- push(value);// don't forget push after resizing
- }
- }
-
- /**
- * Removes the top element of the stack and returns the value you've removed
- *
- * @return value popped off the Stack
- */
- public int pop(){
- if(!isEmpty()){ //Checks for an empty stack
- return stackArray[top--];
- }
-
- if(top < maxSize/4){
- resize(maxSize/2);
- return pop();// don't forget pop after resizing
- }
- else{
- System.out.println("The stack is already empty");
- return -1;
- }
- }
-
- /**
- * Returns the element at the top of the stack
- *
- * @return element at the top of the stack
- */
- public int peek(){
- if(!isEmpty()){ //Checks for an empty stack
- return stackArray[top];
- }else{
- System.out.println("The stack is empty, cant peek");
- return -1;
- }
- }
-
- private void resize(int newSize){
- //private int[] transferArray = new int[newSize]; we can't put modifires here !
- int[] transferArray = new int[newSize];
-
- //for(int i = 0; i < stackArray.length(); i++){ the length isn't a method .
- for(int i = 0; i < stackArray.length; i++){
- transferArray[i] = stackArray[i];
- stackArray = transferArray;
- }
- maxSize = newSize;
- }
-
- /**
- * Returns true if the stack is empty
- *
- * @return true if the stack is empty
- */
- public boolean isEmpty(){
- return(top == -1);
- }
-
- /**
- * Returns true if the stack is full
- *
- * @return true if the stack is full
- */
- public boolean isFull(){
- return(top+1 == maxSize);
- }
-
- /**
- * Deletes everything in the Stack
- *
- * Doesn't delete elements in the array
- * but if you call push method after calling
- * makeEmpty it will overwrite previous
- * values
- */
- public void makeEmpty(){ //Doesn't delete elements in the array but if you call
- top = -1; //push method after calling makeEmpty it will overwrite previous values
- }
-}
-
-/**
- * This is an ArrayList Implementation of stack, Where size is not
- * a problem we can extend the stack as much as we want.
- *
- * @author Unknown
- *
- */
-class Stack2{
- /** ArrayList representation of the stack */
- ArrayList stackList;
-
- /**
- * Constructor
- */
- Stack2(){
- stackList=new ArrayList<>();
- }
-
- /**
- * Adds value to the end of list which
- * is the top for stack
- *
- * @param value value to be added
- */
- void push(int value){
- stackList.add(value);
- }
-
- /**
- * Pops last element of list which is indeed
- * the top for Stack
- *
- * @return Element popped
- */
- int pop(){
-
- if(!isEmpty()){ // checks for an empty Stack
-
- int popValue=stackList.get(stackList.size()-1);
- stackList.remove(stackList.size()-1); //removes the poped element from the list
- return popValue;
- }
- else{
- System.out.print("The stack is already empty ");
- return -1;
- }
-
- }
-
- /**
- * Checks for empty Stack
- *
- * @return true if stack is empty
- */
- boolean isEmpty(){
- if(stackList.isEmpty())
- return true;
-
- else return false;
-
- }
-
- /**
- * Top element of stack
- *
- * @return top element of stack
- */
- int peek(){
- return stackList.get(stackList.size()-1);
- }
- }
-
-/**
- * This class implements the Stack and Stack2 created above
- *
- * @author Unknown
- *
- */
-public class Stacks{
- /**
- * Main method
- *
- * @param args Command line arguments
- */
- public static void main(String args[]){
- Stack myStack = new Stack(4); //Declare a stack of maximum size 4
- //Populate the stack
- myStack.push(5);
- myStack.push(8);
- myStack.push(2);
- myStack.push(9);
-
- System.out.println("*********************Stack Array Implementation*********************");
- System.out.println(myStack.isEmpty()); //will print false
- System.out.println(myStack.isFull()); //will print true
- System.out.println(myStack.peek()); //will print 9
- System.out.println(myStack.pop()); //will print 9
- System.out.println(myStack.peek()); // will print 2
-
- Stack2 myStack2 = new Stack2(); //Declare a stack of maximum size 4
- //Populate the stack
- myStack2.push(5);
- myStack2.push(8);
- myStack2.push(2);
- myStack2.push(9);
-
- System.out.println("*********************Stack List Implementation*********************");
- System.out.println(myStack2.isEmpty()); //will print false
- System.out.println(myStack2.peek()); //will print 9
- System.out.println(myStack2.pop()); //will print 9
- System.out.println(myStack2.peek()); // will print 2
- System.out.println(myStack2.pop()); //will print 2
- }
-}
diff --git a/DataStructures/Trees/AVLTree.java b/DataStructures/Trees/AVLTree.java
index 4bcf402dc0b7..b496be6961fa 100644
--- a/DataStructures/Trees/AVLTree.java
+++ b/DataStructures/Trees/AVLTree.java
@@ -1,19 +1,21 @@
+package DataStructures.Trees;
+
public class AVLTree {
-
+
private Node root;
-
+
private class Node {
private int key;
private int balance;
private int height;
private Node left, right, parent;
-
+
Node(int k, Node p) {
key = k;
parent = p;
}
}
-
+
public boolean insert(int key) {
if (root == null)
root = new Node(key, null);
@@ -23,12 +25,12 @@ public boolean insert(int key) {
while (true) {
if (n.key == key)
return false;
-
+
parent = n;
-
+
boolean goLeft = n.key > key;
n = goLeft ? n.left : n.right;
-
+
if (n == null) {
if (goLeft) {
parent.left = new Node(key, parent);
@@ -42,38 +44,38 @@ public boolean insert(int key) {
}
return true;
}
-
- private void delete(Node node){
- if(node.left == null && node.right == null){
- if(node.parent == null) root = null;
- else{
+
+ private void delete(Node node) {
+ if (node.left == null && node.right == null) {
+ if (node.parent == null) root = null;
+ else {
Node parent = node.parent;
- if(parent.left == node){
+ if (parent.left == node) {
parent.left = null;
- }else parent.right = null;
+ } else parent.right = null;
rebalance(parent);
}
return;
}
- if(node.left!=null){
+ if (node.left != null) {
Node child = node.left;
- while (child.right!=null) child = child.right;
+ while (child.right != null) child = child.right;
node.key = child.key;
delete(child);
- }else{
+ } else {
Node child = node.right;
- while (child.left!=null) child = child.left;
+ while (child.left != null) child = child.left;
node.key = child.key;
delete(child);
}
}
-
+
public void delete(int delKey) {
if (root == null)
return;
Node node = root;
Node child = root;
-
+
while (child != null) {
node = child;
child = delKey >= node.key ? node.right : node.left;
@@ -83,43 +85,43 @@ public void delete(int delKey) {
}
}
}
-
+
private void rebalance(Node n) {
setBalance(n);
-
+
if (n.balance == -2) {
if (height(n.left.left) >= height(n.left.right))
n = rotateRight(n);
else
n = rotateLeftThenRight(n);
-
+
} else if (n.balance == 2) {
if (height(n.right.right) >= height(n.right.left))
n = rotateLeft(n);
else
n = rotateRightThenLeft(n);
}
-
+
if (n.parent != null) {
rebalance(n.parent);
} else {
root = n;
}
}
-
+
private Node rotateLeft(Node a) {
-
+
Node b = a.right;
b.parent = a.parent;
-
+
a.right = b.left;
-
+
if (a.right != null)
a.right.parent = a;
-
+
b.left = a;
a.parent = b;
-
+
if (b.parent != null) {
if (b.parent.right == a) {
b.parent.right = b;
@@ -127,25 +129,25 @@ private Node rotateLeft(Node a) {
b.parent.left = b;
}
}
-
+
setBalance(a, b);
-
+
return b;
}
-
+
private Node rotateRight(Node a) {
-
+
Node b = a.left;
b.parent = a.parent;
-
+
a.left = b.right;
-
+
if (a.left != null)
a.left.parent = a;
-
+
b.right = a;
a.parent = b;
-
+
if (b.parent != null) {
if (b.parent.right == a) {
b.parent.right = b;
@@ -153,38 +155,39 @@ private Node rotateRight(Node a) {
b.parent.left = b;
}
}
-
+
setBalance(a, b);
-
+
return b;
}
-
+
private Node rotateLeftThenRight(Node n) {
n.left = rotateLeft(n.left);
return rotateRight(n);
}
-
+
private Node rotateRightThenLeft(Node n) {
n.right = rotateRight(n.right);
return rotateLeft(n);
}
-
+
private int height(Node n) {
if (n == null)
return -1;
return n.height;
}
-
+
private void setBalance(Node... nodes) {
- for (Node n : nodes)
+ for (Node n : nodes) {
reheight(n);
n.balance = height(n.right) - height(n.left);
+ }
}
-
+
public void printBalance() {
printBalance(root);
}
-
+
private void printBalance(Node n) {
if (n != null) {
printBalance(n.left);
@@ -192,20 +195,20 @@ private void printBalance(Node n) {
printBalance(n.right);
}
}
-
- private void reheight(Node node){
- if(node!=null){
- node.height=1 + Math.max(height(node.left), height(node.right));
+
+ private void reheight(Node node) {
+ if (node != null) {
+ node.height = 1 + Math.max(height(node.left), height(node.right));
}
}
-
+
public static void main(String[] args) {
AVLTree tree = new AVLTree();
-
+
System.out.println("Inserting values 1 to 10");
for (int i = 1; i < 10; i++)
tree.insert(i);
-
+
System.out.print("Printing balance: ");
tree.printBalance();
}
diff --git a/DataStructures/Trees/BinaryTree.java b/DataStructures/Trees/BinaryTree.java
index a20d24eebc35..75d3af18e56b 100644
--- a/DataStructures/Trees/BinaryTree.java
+++ b/DataStructures/Trees/BinaryTree.java
@@ -1,268 +1,275 @@
+package DataStructures.Trees;
+
/**
-* This entire class is used to build a Binary Tree data structure.
-* There is the Node Class and the Tree Class, both explained below.
-*
-* @author Unknown
-*
-*/
+ * This entire class is used to build a Binary Tree data structure.
+ * There is the Node Class and the Tree Class, both explained below.
+ */
/**
-* This class implements the nodes that will go on the Binary Tree.
-* They consist of the data in them, the node to the left, the node
-* to the right, and the parent from which they came from.
-*
-* @author Unknown
-*
-*/
-class Node{
- /** Data for the node */
- public int data;
- /** The Node to the left of this one */
- public Node left;
- /** The Node to the right of this one */
- public Node right;
- /** The parent of this node */
- public Node parent;
+ * A binary tree is a data structure in which an element
+ * has two successors(children). The left child is usually
+ * smaller than the parent, and the right child is usually
+ * bigger.
+ *
+ * @author Unknown
+ *
+ */
+public class BinaryTree {
- /**
- * Constructor of Node
- *
- * @param value Value to put in the node
- */
- public Node(int value){
- data = value;
- left = null;
- right = null;
- parent = null;
- }
-}
+ /**
+ * This class implements the nodes that will go on the Binary Tree.
+ * They consist of the data in them, the node to the left, the node
+ * to the right, and the parent from which they came from.
+ *
+ * @author Unknown
+ *
+ */
+ class Node {
+ /** Data for the node */
+ public int data;
+ /** The Node to the left of this one */
+ public Node left;
+ /** The Node to the right of this one */
+ public Node right;
+ /** The parent of this node */
+ public Node parent;
+ /**
+ * Constructor of Node
+ *
+ * @param value Value to put in the node
+ */
+ public Node(int value) {
+ data = value;
+ left = null;
+ right = null;
+ parent = null;
+ }
+ }
-/**
-* A binary tree is a data structure in which an element
-* has two successors(children). The left child is usually
-* smaller than the parent, and the right child is usually
-* bigger.
-*
-* @author Unknown
-*
-*/
-class Tree{
- /** The root of the Binary Tree */
- private Node root;
- /**
- * Constructor
- */
- public Tree(){
- root = null;
- }
+ /** The root of the Binary Tree */
+ private Node root;
- /**
- * Method to find a Node with a certain value
- *
- * @param key Value being looked for
- * @return The node if it finds it, otherwise returns the parent
- */
- public Node find(int key) {
- Node current = root;
- while (current != null) {
- if(key < current.data) {
- current = current.left;
- } else if(key > current.data) {
- current = current.right;
- } else { // If you find the value return it
- return current;
- }
- }
- return null;
- }
+ /**
+ * Constructor
+ */
+ public BinaryTree() {
+ root = null;
+ }
- /**
- * Inserts certain value into the Binary Tree
- *
- * @param value Value to be inserted
- */
- public void put(int value){
- Node newNode = new Node(value);
- if(root == null)
- root = newNode;
- else{
- //This will return the soon to be parent of the value you're inserting
- Node parent = find(value);
+ /**
+ * Method to find a Node with a certain value
+ *
+ * @param key Value being looked for
+ * @return The node if it finds it, otherwise returns the parent
+ */
+ public Node find(int key) {
+ Node current = root;
+ while (current != null) {
+ if (key < current.data) {
+ if (current.left == null)
+ return current; //The key isn't exist, returns the parent
+ current = current.left;
+ } else if (key > current.data) {
+ if (current.right == null)
+ return current;
+ current = current.right;
+ } else { // If you find the value return it
+ return current;
+ }
+ }
+ return null;
+ }
- //This if/else assigns the new node to be either the left or right child of the parent
- if(value < parent.data){
- parent.left = newNode;
- parent.left.parent = parent;
- return;
- }
- else{
- parent.right = newNode;
- parent.right.parent = parent;
- return;
- }
- }
- }
+ /**
+ * Inserts certain value into the Binary Tree
+ *
+ * @param value Value to be inserted
+ */
+ public void put(int value) {
+ Node newNode = new Node(value);
+ if (root == null)
+ root = newNode;
+ else {
+ //This will return the soon to be parent of the value you're inserting
+ Node parent = find(value);
- /**
- * Deletes a given value from the Binary Tree
- *
- * @param value Value to be deleted
- * @return If the value was deleted
- */
- public boolean remove(int value){
- //temp is the node to be deleted
- Node temp = find(value);
+ //This if/else assigns the new node to be either the left or right child of the parent
+ if (value < parent.data) {
+ parent.left = newNode;
+ parent.left.parent = parent;
+ return;
+ } else {
+ parent.right = newNode;
+ parent.right.parent = parent;
+ return;
+ }
+ }
+ }
- //If the value doesn't exist
- if(temp.data != value)
- return false;
+ /**
+ * Deletes a given value from the Binary Tree
+ *
+ * @param value Value to be deleted
+ * @return If the value was deleted
+ */
+ public boolean remove(int value) {
+ //temp is the node to be deleted
+ Node temp = find(value);
- //No children
- if(temp.right == null && temp.left == null){
- if(temp == root)
- root = null;
+ //If the value doesn't exist
+ if (temp.data != value)
+ return false;
- //This if/else assigns the new node to be either the left or right child of the parent
- else if(temp.parent.data < temp.data)
- temp.parent.right = null;
- else
- temp.parent.left = null;
- return true;
- }
+ //No children
+ if (temp.right == null && temp.left == null) {
+ if (temp == root)
+ root = null;
- //Two children
- else if(temp.left != null && temp.right != null){
- Node successor = findSuccessor(temp);
+ //This if/else assigns the new node to be either the left or right child of the parent
+ else if (temp.parent.data < temp.data)
+ temp.parent.right = null;
+ else
+ temp.parent.left = null;
+ return true;
+ }
- //The left tree of temp is made the left tree of the successor
- successor.left = temp.left;
- successor.left.parent = successor;
+ //Two children
+ else if (temp.left != null && temp.right != null) {
+ Node successor = findSuccessor(temp);
- //If the successor has a right child, the child's grandparent is it's new parent
- if(successor.right != null && successor.parent != temp){
- successor.right.parent = successor.parent;
- successor.parent.left = successor.right;
- successor.right = temp.right;
- successor.right.parent = successor;
- }
- if(temp == root){
- successor.parent = null;
- root = successor;
- return true;
- }
+ //The left tree of temp is made the left tree of the successor
+ successor.left = temp.left;
+ successor.left.parent = successor;
- //If you're not deleting the root
- else{
- successor.parent = temp.parent;
+ //If the successor has a right child, the child's grandparent is it's new parent
+ if (successor.right != null && successor.parent != temp) {
+ successor.right.parent = successor.parent;
+ successor.parent.left = successor.right;
+ successor.right = temp.right;
+ successor.right.parent = successor;
+ }
+ if (temp == root) {
+ successor.parent = null;
+ root = successor;
+ return true;
+ }
- //This if/else assigns the new node to be either the left or right child of the parent
- if(temp.parent.data < temp.data)
- temp.parent.right = successor;
- else
- temp.parent.left = successor;
- return true;
- }
- }
- //One child
- else{
- //If it has a right child
- if(temp.right != null){
- if(temp == root){
- root = temp.right; return true;}
+ //If you're not deleting the root
+ else {
+ successor.parent = temp.parent;
- temp.right.parent = temp.parent;
+ //This if/else assigns the new node to be either the left or right child of the parent
+ if (temp.parent.data < temp.data)
+ temp.parent.right = successor;
+ else
+ temp.parent.left = successor;
+ return true;
+ }
+ }
+ //One child
+ else {
+ //If it has a right child
+ if (temp.right != null) {
+ if (temp == root) {
+ root = temp.right;
+ return true;
+ }
- //Assigns temp to left or right child
- if(temp.data < temp.parent.data)
- temp.parent.left = temp.right;
- else
- temp.parent.right = temp.right;
- return true;
- }
- //If it has a left child
- else{
- if(temp == root){
- root = temp.left; return true;}
+ temp.right.parent = temp.parent;
- temp.left.parent = temp.parent;
+ //Assigns temp to left or right child
+ if (temp.data < temp.parent.data)
+ temp.parent.left = temp.right;
+ else
+ temp.parent.right = temp.right;
+ return true;
+ }
+ //If it has a left child
+ else {
+ if (temp == root) {
+ root = temp.left;
+ return true;
+ }
- //Assigns temp to left or right side
- if(temp.data < temp.parent.data)
- temp.parent.left = temp.left;
- else
- temp.parent.right = temp.left;
- return true;
- }
- }
- }
+ temp.left.parent = temp.parent;
- /**
- * This method finds the Successor to the Node given.
- * Move right once and go left down the tree as far as you can
- *
- * @param n Node that you want to find the Successor of
- * @return The Successor of the node
- */
- public Node findSuccessor(Node n){
- if(n.right == null)
- return n;
- Node current = n.right;
- Node parent = n.right;
- while(current != null){
- parent = current;
- current = current.left;
- }
- return parent;
- }
+ //Assigns temp to left or right side
+ if (temp.data < temp.parent.data)
+ temp.parent.left = temp.left;
+ else
+ temp.parent.right = temp.left;
+ return true;
+ }
+ }
+ }
- /**
- * Returns the root of the Binary Tree
- *
- * @return the root of the Binary Tree
- */
- public Node getRoot(){
- return root;
- }
+ /**
+ * This method finds the Successor to the Node given.
+ * Move right once and go left down the tree as far as you can
+ *
+ * @param n Node that you want to find the Successor of
+ * @return The Successor of the node
+ */
+ public Node findSuccessor(Node n) {
+ if (n.right == null)
+ return n;
+ Node current = n.right;
+ Node parent = n.right;
+ while (current != null) {
+ parent = current;
+ current = current.left;
+ }
+ return parent;
+ }
- /**
- * Prints leftChild - root - rightChild
- *
- * @param localRoot The local root of the binary tree
- */
- public void inOrder(Node localRoot){
- if(localRoot != null){
- inOrder(localRoot.left);
- System.out.print(localRoot.data + " ");
- inOrder(localRoot.right);
- }
- }
+ /**
+ * Returns the root of the Binary Tree
+ *
+ * @return the root of the Binary Tree
+ */
+ public Node getRoot() {
+ return root;
+ }
- /**
- * Prints root - leftChild - rightChild
- *
- * @param localRoot The local root of the binary tree
- */
- public void preOrder(Node localRoot){
- if(localRoot != null){
- System.out.print(localRoot.data + " ");
- preOrder(localRoot.left);
- preOrder(localRoot.right);
- }
- }
+ /**
+ * Prints leftChild - root - rightChild
+ *
+ * @param localRoot The local root of the binary tree
+ */
+ public void inOrder(Node localRoot) {
+ if (localRoot != null) {
+ inOrder(localRoot.left);
+ System.out.print(localRoot.data + " ");
+ inOrder(localRoot.right);
+ }
+ }
- /**
- * Prints rightChild - leftChild - root
- *
- * @param localRoot The local root of the binary tree
- */
- public void postOrder(Node localRoot){
- if(localRoot != null){
- postOrder(localRoot.left);
- postOrder(localRoot.right);
- System.out.print(localRoot.data + " ");
- }
- }
- }
+ /**
+ * Prints root - leftChild - rightChild
+ *
+ * @param localRoot The local root of the binary tree
+ */
+ public void preOrder(Node localRoot) {
+ if (localRoot != null) {
+ System.out.print(localRoot.data + " ");
+ preOrder(localRoot.left);
+ preOrder(localRoot.right);
+ }
+ }
+
+ /**
+ * Prints rightChild - leftChild - root
+ *
+ * @param localRoot The local root of the binary tree
+ */
+ public void postOrder(Node localRoot) {
+ if (localRoot != null) {
+ postOrder(localRoot.left);
+ postOrder(localRoot.right);
+ System.out.print(localRoot.data + " ");
+ }
+ }
+}
diff --git a/DataStructures/Trees/FindHeightOfTree.java b/DataStructures/Trees/FindHeightOfTree.java
deleted file mode 100644
index 675b1e8b57cb..000000000000
--- a/DataStructures/Trees/FindHeightOfTree.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/**
- *
- * @author Varun Upadhyay (https://github.com/varunu28)
- *
- */
-import java.util.LinkedList;
-
-public class FindHeightOfTree {
-
- // Driver Program
- public static void main(String[] args) {
- Node tree = new Node(5);
- tree.insert(3);
- tree.insert(7);
- tree.insert(1);
- tree.insert(-1);
- tree.insert(29);
- tree.insert(93);
- tree.insert(6);
- tree.insert(0);
- tree.insert(-5);
- tree.insert(-6);
- tree.insert(-8);
- tree.insert(-1);
-
- // A level order representation of the tree
- tree.printLevelOrder();
- System.out.println();
-
- System.out.println("Height of the tree is: " + tree.findHeight());
- }
-}
-
-/**
- * The Node class which initializes a Node of a tree
- * printLevelOrder: ROOT -> ROOT's CHILDREN -> ROOT's CHILDREN's CHILDREN -> etc
- * findHeight: Returns the height of the tree i.e. the number of links between root and farthest leaf
- */
-class Node {
- Node left, right;
- int data;
-
- public Node(int data) {
- this.data = data;
- }
-
- public void insert (int value) {
- if (value < data) {
- if (left == null) {
- left = new Node(value);
- }
- else {
- left.insert(value);
- }
- }
- else {
- if (right == null) {
- right = new Node(value);
- }
- else {
- right.insert(value);
- }
- }
- }
-
- public void printLevelOrder() {
- LinkedList queue = new LinkedList<>();
- queue.add(this);
- while(!queue.isEmpty()) {
- Node n = queue.poll();
- System.out.print(n.data + " ");
- if (n.left != null) {
- queue.add(n.left);
- }
- if (n.right != null) {
- queue.add(n.right);
- }
- }
- }
-
- public int findHeight() {
- return findHeight(this);
- }
-
- private int findHeight(Node root) {
- if (root.left == null && root.right == null) {
- return 0;
- }
- else if (root.left != null && root.right != null) {
- return 1 + Math.max(findHeight(root.left), findHeight(root.right));
- }
- else if (root.left == null && root.right != null) {
- return 1 + findHeight(root.right);
- }
- else {
- return 1 + findHeight(root.left);
- }
- }
-}
-
diff --git a/DataStructures/Trees/GenericTree.Java b/DataStructures/Trees/GenericTree.Java
deleted file mode 100644
index 16ab5fb53b1e..000000000000
--- a/DataStructures/Trees/GenericTree.Java
+++ /dev/null
@@ -1,226 +0,0 @@
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.Scanner;
-
-public class treeclass {
- private class Node {
- int data;
- ArrayList child = new ArrayList<>();
- }
-
- private Node root;
- private int size;
-
- /*
- A generic tree is a tree which can have as many children as it can be
- It might be possible that every node present is directly connected to
- root node.
-
- In this code
- Every function has two copies: one function is helper function which can be called from
- main and from that function a private function is called which will do the actual work.
- I have done this, while calling from main one have to give minimum parameters.
-
- */
- public treeclass() { //Constructor
- Scanner scn = new Scanner(System.in);
- root = create_treeG(null, 0, scn);
- }
-
- private Node create_treeG(Node node, int childindx, Scanner scn) {
- // display
- if (node == null) {
- System.out.println("Enter root's data");
- } else {
- System.out.println("Enter data of parent of index " + node.data + " " + childindx);
- }
- // input
- node = new Node();
- node.data = scn.nextInt();
- System.out.println("number of children");
- int number = scn.nextInt();
- for (int i = 0; i < number; i++) {
- Node childd = create_treeG(node, i, scn);
- size++;
- node.child.add(childd);
- }
- return node;
- }
-
- /*
- Function to display the generic tree
- */
- public void display() { //Helper function
- display_1(root);
- return;
- }
-
- private void display_1(Node parent) {
- System.out.print(parent.data + "=>");
- for (int i = 0; i < parent.child.size(); i++) {
- System.out.print(parent.child.get(i).data + " ");
- }
- System.out.println(".");
- for (int i = 0; i < parent.child.size(); i++) {
- display_1(parent.child.get(i));
- }
- return;
- }
-
- /*
- One call store the size directly but if you are asked compute size this function to calcuate
- size goes as follows
- */
-
- public int size2call() {
- return size2(root);
- }
-
- public int size2(Node roott) {
- int sz = 0;
- for (int i = 0; i < roott.child.size(); i++) {
- sz += size2(roott.child.get(i));
- }
- return sz + 1;
- }
-
- /*
- Function to compute maximum value in the generic tree
- */
- public int maxcall() {
- int maxi = root.data;
- return max(root, maxi);
- }
-
- private int max(Node roott, int maxi) {
- if (maxi < roott.data)
- maxi = roott.data;
- for (int i = 0; i < roott.child.size(); i++) {
- maxi = max(roott.child.get(i), maxi);
- }
-
- return maxi;
- }
-
- /*
- Function to compute HEIGHT of the generic tree
- */
-
- public int heightcall() {
- return height(root) - 1;
- }
-
- private int height(Node node) {
- int h = 0;
- for (int i = 0; i < node.child.size(); i++) {
- int k = height(node.child.get(i));
- if (k > h)
- h = k;
- }
- return h + 1;
- }
-
- /*
- Function to find whether a number is present in the generic tree or not
- */
-
- public boolean findcall(int info) {
- return find(root, info);
- }
-
- private boolean find(Node node, int info) {
- if (node.data == info)
- return true;
- for (int i = 0; i < node.child.size(); i++) {
- if (find(node.child.get(i), info))
- return true;
- }
- return false;
- }
-
- /*
- Function to calculate depth of generic tree
- */
- public void depthcaller(int dep) {
- depth(root, dep);
- }
-
- public void depth(Node node, int dep) {
- if (dep == 0) {
- System.out.println(node.data);
- return;
- }
- for (int i = 0; i < node.child.size(); i++)
- depth(node.child.get(i), dep - 1);
- return;
- }
-
- /*
- Function to print generic tree in pre-order
- */
- public void preordercall() {
- preorder(root);
- System.out.println(".");
- }
-
- private void preorder(Node node) {
- System.out.print(node.data + " ");
- for (int i = 0; i < node.child.size(); i++)
- preorder(node.child.get(i));
- }
-
- /*
- Function to print generic tree in post-order
- */
- public void postordercall() {
- postorder(root);
- System.out.println(".");
- }
-
- private void postorder(Node node) {
- for (int i = 0; i < node.child.size(); i++)
- postorder(node.child.get(i));
- System.out.print(node.data + " ");
- }
-
- /*
- Function to print generic tree in level-order
- */
-
- public void levelorder() {
- LinkedList q = new LinkedList<>();
- q.addLast(root);
- while (!q.isEmpty()) {
- int k = q.getFirst().data;
- System.out.print(k + " ");
-
- for (int i = 0; i < q.getFirst().child.size(); i++) {
- q.addLast(q.getFirst().child.get(i));
- }
- q.removeFirst();
- }
- System.out.println(".");
- }
-
- /*
- Function to remove all leaves of generic tree
- */
- public void removeleavescall() {
- removeleaves(root);
- }
-
- private void removeleaves(Node node) {
- ArrayList arr = new ArrayList<>();
- for (int i = 0; i < node.child.size(); i++) {
- if (node.child.get(i).child.size() == 0) {
- arr.add(i);
- // node.child.remove(i);
- // i--;
- } else
- removeleaves(node.child.get(i));
- }
- for (int i = arr.size() - 1; i >= 0; i--) {
- node.child.remove(arr.get(i) + 0);
- }
- }
-
diff --git a/DataStructures/Trees/GenericTree.java b/DataStructures/Trees/GenericTree.java
new file mode 100644
index 000000000000..107a072cf965
--- /dev/null
+++ b/DataStructures/Trees/GenericTree.java
@@ -0,0 +1,234 @@
+package DataStructures.Trees;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Scanner;
+
+/**
+ * A generic tree is a tree which can have as many children as it can be
+ * It might be possible that every node present is directly connected to
+ * root node.
+ *
+ * In this code
+ * Every function has two copies: one function is helper function which can be called from
+ * main and from that function a private function is called which will do the actual work.
+ * I have done this, while calling from main one have to give minimum parameters.
+ */
+public class GenericTree {
+ private class Node {
+ int data;
+ ArrayList child = new ArrayList<>();
+ }
+
+ private Node root;
+ private int size;
+
+ public GenericTree() { //Constructor
+ Scanner scn = new Scanner(System.in);
+ root = create_treeG(null, 0, scn);
+ }
+
+ private Node create_treeG(Node node, int childindx, Scanner scn) {
+ // display
+ if (node == null) {
+ System.out.println("Enter root's data");
+ } else {
+ System.out.println("Enter data of parent of index " + node.data + " " + childindx);
+ }
+ // input
+ node = new Node();
+ node.data = scn.nextInt();
+ System.out.println("number of children");
+ int number = scn.nextInt();
+ for (int i = 0; i < number; i++) {
+ Node child = create_treeG(node, i, scn);
+ size++;
+ node.child.add(child);
+ }
+ return node;
+ }
+
+ /**
+ * Function to display the generic tree
+ */
+ public void display() { //Helper function
+ display_1(root);
+ }
+
+ private void display_1(Node parent) {
+ System.out.print(parent.data + "=>");
+ for (int i = 0; i < parent.child.size(); i++) {
+ System.out.print(parent.child.get(i).data + " ");
+ }
+ System.out.println(".");
+ for (int i = 0; i < parent.child.size(); i++) {
+ display_1(parent.child.get(i));
+ }
+ }
+
+ /**
+ * One call store the size directly but if you are asked compute size this function to calculate
+ * size goes as follows
+ *
+ * @return size
+ */
+ public int size2call() {
+ return size2(root);
+ }
+
+ public int size2(Node roott) {
+ int sz = 0;
+ for (int i = 0; i < roott.child.size(); i++) {
+ sz += size2(roott.child.get(i));
+ }
+ return sz + 1;
+ }
+
+ /**
+ * Function to compute maximum value in the generic tree
+ *
+ * @return maximum value
+ */
+ public int maxcall() {
+ int maxi = root.data;
+ return max(root, maxi);
+ }
+
+ private int max(Node roott, int maxi) {
+ if (maxi < roott.data)
+ maxi = roott.data;
+ for (int i = 0; i < roott.child.size(); i++) {
+ maxi = max(roott.child.get(i), maxi);
+ }
+
+ return maxi;
+ }
+
+ /**
+ * Function to compute HEIGHT of the generic tree
+ *
+ * @return height
+ */
+ public int heightcall() {
+ return height(root) - 1;
+ }
+
+ private int height(Node node) {
+ int h = 0;
+ for (int i = 0; i < node.child.size(); i++) {
+ int k = height(node.child.get(i));
+ if (k > h)
+ h = k;
+ }
+ return h + 1;
+ }
+
+ /**
+ * Function to find whether a number is present in the generic tree or not
+ *
+ * @param info number
+ * @return present or not
+ */
+ public boolean findcall(int info) {
+ return find(root, info);
+ }
+
+ private boolean find(Node node, int info) {
+ if (node.data == info)
+ return true;
+ for (int i = 0; i < node.child.size(); i++) {
+ if (find(node.child.get(i), info))
+ return true;
+ }
+ return false;
+ }
+
+
+ /**
+ * Function to calculate depth of generic tree
+ *
+ * @param dep depth
+ */
+ public void depthcaller(int dep) {
+ depth(root, dep);
+ }
+
+ public void depth(Node node, int dep) {
+ if (dep == 0) {
+ System.out.println(node.data);
+ return;
+ }
+ for (int i = 0; i < node.child.size(); i++)
+ depth(node.child.get(i), dep - 1);
+ return;
+ }
+
+ /**
+ * Function to print generic tree in pre-order
+ */
+ public void preordercall() {
+ preorder(root);
+ System.out.println(".");
+ }
+
+ private void preorder(Node node) {
+ System.out.print(node.data + " ");
+ for (int i = 0; i < node.child.size(); i++)
+ preorder(node.child.get(i));
+ }
+
+ /**
+ * Function to print generic tree in post-order
+ */
+ public void postordercall() {
+ postorder(root);
+ System.out.println(".");
+ }
+
+ private void postorder(Node node) {
+ for (int i = 0; i < node.child.size(); i++)
+ postorder(node.child.get(i));
+ System.out.print(node.data + " ");
+ }
+
+ /**
+ * Function to print generic tree in level-order
+ */
+ public void levelorder() {
+ LinkedList q = new LinkedList<>();
+ q.addLast(root);
+ while (!q.isEmpty()) {
+ int k = q.getFirst().data;
+ System.out.print(k + " ");
+
+ for (int i = 0; i < q.getFirst().child.size(); i++) {
+ q.addLast(q.getFirst().child.get(i));
+ }
+ q.removeFirst();
+ }
+ System.out.println(".");
+ }
+
+ /**
+ * Function to remove all leaves of generic tree
+ */
+ public void removeleavescall() {
+ removeleaves(root);
+ }
+
+ private void removeleaves(Node node) {
+ ArrayList arr = new ArrayList<>();
+ for (int i = 0; i < node.child.size(); i++) {
+ if (node.child.get(i).child.size() == 0) {
+ arr.add(i);
+ // node.child.remove(i);
+ // i--;
+ } else
+ removeleaves(node.child.get(i));
+ }
+ for (int i = arr.size() - 1; i >= 0; i--) {
+ node.child.remove(arr.get(i) + 0);
+ }
+ }
+
+}
diff --git a/DataStructures/Trees/LevelOrderTraversal.java b/DataStructures/Trees/LevelOrderTraversal.java
index 8cb304f18c8f..bcf172495d13 100644
--- a/DataStructures/Trees/LevelOrderTraversal.java
+++ b/DataStructures/Trees/LevelOrderTraversal.java
@@ -1,78 +1,55 @@
-class Node
-{
- int data;
- Node left, right;
- public Node(int item)
- {
- data = item;
- left = right = null;
+package DataStructures.Trees;
+
+public class LevelOrderTraversal {
+
+ class Node {
+ int data;
+ Node left, right;
+
+ public Node(int item) {
+ data = item;
+ left = right = null;
+ }
}
-}
-
-public class LevelOrderTraversal
-{
+
// Root of the Binary Tree
Node root;
-
- public LevelOrderTraversal()
- {
+
+ public LevelOrderTraversal() {
root = null;
}
-
+
/* function to print level order traversal of tree*/
- void printLevelOrder()
- {
+ void printLevelOrder() {
int h = height(root);
int i;
- for (i=1; i<=h; i++)
+ for (i = 1; i <= h; i++)
printGivenLevel(root, i);
}
-
+
/* Compute the "height" of a tree -- the number of
nodes along the longest path from the root node
down to the farthest leaf node.*/
- int height(Node root)
- {
+ int height(Node root) {
if (root == null)
- return 0;
- else
- {
- /* compute height of each subtree */
- int lheight = height(root.left);
- int rheight = height(root.right);
-
- /* use the larger one */
- if (lheight > rheight)
- return(lheight+1);
- else return(rheight+1);
+ return 0;
+ else {
+ /**
+ * Return the height of larger subtree
+ */
+ return Math.max(height(root.left), height(root.right)) + 1;
}
}
-
+
/* Print nodes at the given level */
- void printGivenLevel (Node root ,int level)
- {
+ void printGivenLevel(Node root, int level) {
if (root == null)
return;
if (level == 1)
System.out.print(root.data + " ");
- else if (level > 1)
- {
- printGivenLevel(root.left, level-1);
- printGivenLevel(root.right, level-1);
+ else if (level > 1) {
+ printGivenLevel(root.left, level - 1);
+ printGivenLevel(root.right, level - 1);
}
}
-
- /* Driver program to test above functions */
- public static void main(String args[])
- {
- LevelOrderTraversal tree = new LevelOrderTraversal();
- tree.root= new Node(1);
- tree.root.left= new Node(2);
- tree.root.right= new Node(3);
- tree.root.left.left= new Node(4);
- tree.root.left.right= new Node(5);
-
- System.out.println("Level order traversal of binary tree is ");
- tree.printLevelOrder();
- }
-}
\ No newline at end of file
+}
diff --git a/DataStructures/Trees/LevelOrderTraversalQueue.java b/DataStructures/Trees/LevelOrderTraversalQueue.java
index ce7ad74542cf..d43d62d68f5f 100644
--- a/DataStructures/Trees/LevelOrderTraversalQueue.java
+++ b/DataStructures/Trees/LevelOrderTraversalQueue.java
@@ -1,62 +1,48 @@
+package DataStructures.Trees;
+
import java.util.Queue;
import java.util.LinkedList;
-
-/* Class to represent Tree node */
-class Node {
- int data;
- Node left, right;
-
- public Node(int item) {
- data = item;
- left = null;
- right = null;
- }
-}
-
+
+
/* Class to print Level Order Traversal */
public class LevelOrderTraversalQueue {
-
+
+ /* Class to represent Tree node */
+ class Node {
+ int data;
+ Node left, right;
+
+ public Node(int item) {
+ data = item;
+ left = null;
+ right = null;
+ }
+ }
+
Node root;
-
+
/* Given a binary tree. Print its nodes in level order
using array for implementing queue */
- void printLevelOrder()
- {
+ void printLevelOrder() {
Queue queue = new LinkedList();
queue.add(root);
- while (!queue.isEmpty())
- {
+ while (!queue.isEmpty()) {
/* poll() removes the present head.
For more information on poll() visit
http://www.tutorialspoint.com/java/util/linkedlist_poll.htm */
Node tempNode = queue.poll();
System.out.print(tempNode.data + " ");
-
+
/*Enqueue left child */
if (tempNode.left != null) {
queue.add(tempNode.left);
}
-
+
/*Enqueue right child */
if (tempNode.right != null) {
queue.add(tempNode.right);
}
}
}
-
- public static void main(String args[])
- {
- /* creating a binary tree and entering
- the nodes */
- LevelOrderTraversalQueue tree_level = new LevelOrderTraversalQueue();
- tree_level.root = new Node(1);
- tree_level.root.left = new Node(2);
- tree_level.root.right = new Node(3);
- tree_level.root.left.left = new Node(4);
- tree_level.root.left.right = new Node(5);
-
- System.out.println("Level order traversal of binary tree is - ");
- tree_level.printLevelOrder();
- }
}
\ No newline at end of file
diff --git a/DataStructures/Trees/PrintTopViewofTree.java b/DataStructures/Trees/PrintTopViewofTree.java
index 27016ee2eee4..58f611305c51 100644
--- a/DataStructures/Trees/PrintTopViewofTree.java
+++ b/DataStructures/Trees/PrintTopViewofTree.java
@@ -1,87 +1,88 @@
-// Java program to print top view of Binary tree
-import java.util.*;
-
+package DataStructures.Trees;// Java program to print top view of Binary tree
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Queue;
+
// Class for a tree node
-class TreeNode
-{
+class TreeNode {
// Members
int key;
TreeNode left, right;
-
+
// Constructor
- public TreeNode(int key)
- {
+ public TreeNode(int key) {
this.key = key;
left = right = null;
}
}
-
+
// A class to represent a queue item. The queue is used to do Level
// order traversal. Every Queue item contains node and horizontal
// distance of node from root
-class QItem
-{
- TreeNode node;
- int hd;
- public QItem(TreeNode n, int h)
- {
+class QItem {
+ TreeNode node;
+ int hd;
+
+ public QItem(TreeNode n, int h) {
node = n;
hd = h;
- }
+ }
}
-
+
// Class for a Binary Tree
-class Tree
-{
+class Tree {
TreeNode root;
-
+
// Constructors
- public Tree() { root = null; }
- public Tree(TreeNode n) { root = n; }
-
+ public Tree() {
+ root = null;
+ }
+
+ public Tree(TreeNode n) {
+ root = n;
+ }
+
// This method prints nodes in top view of binary tree
- public void printTopView()
- {
+ public void printTopView() {
// base case
- if (root == null) { return; }
-
+ if (root == null) {
+ return;
+ }
+
// Creates an empty hashset
HashSet set = new HashSet<>();
-
+
// Create a queue and add root to it
Queue Q = new LinkedList();
Q.add(new QItem(root, 0)); // Horizontal distance of root is 0
-
+
// Standard BFS or level order traversal loop
- while (!Q.isEmpty())
- {
+ while (!Q.isEmpty()) {
// Remove the front item and get its details
QItem qi = Q.remove();
int hd = qi.hd;
TreeNode n = qi.node;
-
+
// If this is the first node at its horizontal distance,
// then this node is in top view
- if (!set.contains(hd))
- {
+ if (!set.contains(hd)) {
set.add(hd);
System.out.print(n.key + " ");
}
-
+
// Enqueue left and right children of current node
if (n.left != null)
- Q.add(new QItem(n.left, hd-1));
+ Q.add(new QItem(n.left, hd - 1));
if (n.right != null)
- Q.add(new QItem(n.right, hd+1));
+ Q.add(new QItem(n.right, hd + 1));
}
}
}
-
+
// Driver class to test above methods
-public class PrintTopViewofTree
-{
- public static void main(String[] args)
- {
+public class PrintTopViewofTree {
+ public static void main(String[] args) {
/* Create following Binary Tree
1
/ \
diff --git a/DataStructures/Trees/RedBlackBST.java b/DataStructures/Trees/RedBlackBST.java
index 08a8fb072e2d..97a88e9a43de 100644
--- a/DataStructures/Trees/RedBlackBST.java
+++ b/DataStructures/Trees/RedBlackBST.java
@@ -1,330 +1,333 @@
+package DataStructures.Trees;
+
+import java.util.Scanner;
+
/**
- *
* @author jack870131
*/
public class RedBlackBST {
- private final int R = 0;
- private final int B = 1;
+ private final int R = 0;
+ private final int B = 1;
- private class Node {
+ private class Node {
- int key = -1, color = B;
- Node left = nil, right = nil, p = nil;
+ int key = -1, color = B;
+ Node left = nil, right = nil, p = nil;
- Node(int key) {
- this.key = key;
- }
- }
+ Node(int key) {
+ this.key = key;
+ }
+ }
- private final Node nil = new Node(-1);
- private Node root = nil;
+ private final Node nil = new Node(-1);
+ private Node root = nil;
- public void printTree(Node node) {
- if (node == nil) {
- return;
- }
- printTree(node.left);
- System.out.print(((node.color == R) ? " R " : " B ") + "Key: " + node.key + " Parent: " + node.p.key + "\n");
- printTree(node.right);
- }
+ public void printTree(Node node) {
+ if (node == nil) {
+ return;
+ }
+ printTree(node.left);
+ System.out.print(((node.color == R) ? " R " : " B ") + "Key: " + node.key + " Parent: " + node.p.key + "\n");
+ printTree(node.right);
+ }
- public void printTreepre(Node node) {
- if (node == nil) {
- return;
- }
- System.out.print(((node.color == R) ? " R " : " B ") + "Key: " + node.key + " Parent: " + node.p.key + "\n");
- printTree(node.left);
- printTree(node.right);
- }
+ public void printTreepre(Node node) {
+ if (node == nil) {
+ return;
+ }
+ System.out.print(((node.color == R) ? " R " : " B ") + "Key: " + node.key + " Parent: " + node.p.key + "\n");
+ printTree(node.left);
+ printTree(node.right);
+ }
- private Node findNode(Node findNode, Node node) {
- if (root == nil) {
- return null;
- }
- if (findNode.key < node.key) {
- if (node.left != nil) {
- return findNode(findNode, node.left);
- }
- } else if (findNode.key > node.key) {
- if (node.right != nil) {
- return findNode(findNode, node.right);
- }
- } else if (findNode.key == node.key) {
- return node;
- }
- return null;
- }
+ private Node findNode(Node findNode, Node node) {
+ if (root == nil) {
+ return null;
+ }
+ if (findNode.key < node.key) {
+ if (node.left != nil) {
+ return findNode(findNode, node.left);
+ }
+ } else if (findNode.key > node.key) {
+ if (node.right != nil) {
+ return findNode(findNode, node.right);
+ }
+ } else if (findNode.key == node.key) {
+ return node;
+ }
+ return null;
+ }
- private void insert(Node node) {
- Node temp = root;
- if (root == nil) {
- root = node;
- node.color = B;
- node.p = nil;
- } else {
- node.color = R;
- while (true) {
- if (node.key < temp.key) {
- if (temp.left == nil) {
- temp.left = node;
- node.p = temp;
- break;
- } else {
- temp = temp.left;
- }
- } else if (node.key >= temp.key) {
- if (temp.right == nil) {
- temp.right = node;
- node.p = temp;
- break;
- } else {
- temp = temp.right;
- }
- }
- }
- fixTree(node);
- }
- }
+ private void insert(Node node) {
+ Node temp = root;
+ if (root == nil) {
+ root = node;
+ node.color = B;
+ node.p = nil;
+ } else {
+ node.color = R;
+ while (true) {
+ if (node.key < temp.key) {
+ if (temp.left == nil) {
+ temp.left = node;
+ node.p = temp;
+ break;
+ } else {
+ temp = temp.left;
+ }
+ } else if (node.key >= temp.key) {
+ if (temp.right == nil) {
+ temp.right = node;
+ node.p = temp;
+ break;
+ } else {
+ temp = temp.right;
+ }
+ }
+ }
+ fixTree(node);
+ }
+ }
- private void fixTree(Node node) {
- while (node.p.color == R) {
- Node y = nil;
- if (node.p == node.p.p.left) {
- y = node.p.p.right;
+ private void fixTree(Node node) {
+ while (node.p.color == R) {
+ Node y = nil;
+ if (node.p == node.p.p.left) {
+ y = node.p.p.right;
- if (y != nil && y.color == R) {
- node.p.color = B;
- y.color = B;
- node.p.p.color = R;
- node = node.p.p;
- continue;
- }
- if (node == node.p.right) {
- node = node.p;
- rotateLeft(node);
- }
- node.p.color = B;
- node.p.p.color = R;
- rotateRight(node.p.p);
- } else {
- y = node.p.p.left;
- if (y != nil && y.color == R) {
- node.p.color = B;
- y.color = B;
- node.p.p.color = R;
- node = node.p.p;
- continue;
- }
- if (node == node.p.left) {
- node = node.p;
- rotateRight(node);
- }
- node.p.color = B;
- node.p.p.color = R;
- rotateLeft(node.p.p);
- }
- }
- root.color = B;
- }
+ if (y != nil && y.color == R) {
+ node.p.color = B;
+ y.color = B;
+ node.p.p.color = R;
+ node = node.p.p;
+ continue;
+ }
+ if (node == node.p.right) {
+ node = node.p;
+ rotateLeft(node);
+ }
+ node.p.color = B;
+ node.p.p.color = R;
+ rotateRight(node.p.p);
+ } else {
+ y = node.p.p.left;
+ if (y != nil && y.color == R) {
+ node.p.color = B;
+ y.color = B;
+ node.p.p.color = R;
+ node = node.p.p;
+ continue;
+ }
+ if (node == node.p.left) {
+ node = node.p;
+ rotateRight(node);
+ }
+ node.p.color = B;
+ node.p.p.color = R;
+ rotateLeft(node.p.p);
+ }
+ }
+ root.color = B;
+ }
- void rotateLeft(Node node) {
- if (node.p != nil) {
- if (node == node.p.left) {
- node.p.left = node.right;
- } else {
- node.p.right = node.right;
- }
- node.right.p = node.p;
- node.p = node.right;
- if (node.right.left != nil) {
- node.right.left.p = node;
- }
- node.right = node.right.left;
- node.p.left = node;
- } else {
- Node right = root.right;
- root.right = right.left;
- right.left.p = root;
- root.p = right;
- right.left = root;
- right.p = nil;
- root = right;
- }
- }
+ void rotateLeft(Node node) {
+ if (node.p != nil) {
+ if (node == node.p.left) {
+ node.p.left = node.right;
+ } else {
+ node.p.right = node.right;
+ }
+ node.right.p = node.p;
+ node.p = node.right;
+ if (node.right.left != nil) {
+ node.right.left.p = node;
+ }
+ node.right = node.right.left;
+ node.p.left = node;
+ } else {
+ Node right = root.right;
+ root.right = right.left;
+ right.left.p = root;
+ root.p = right;
+ right.left = root;
+ right.p = nil;
+ root = right;
+ }
+ }
- void rotateRight(Node node) {
- if (node.p != nil) {
- if (node == node.p.left) {
- node.p.left = node.left;
- } else {
- node.p.right = node.left;
- }
+ void rotateRight(Node node) {
+ if (node.p != nil) {
+ if (node == node.p.left) {
+ node.p.left = node.left;
+ } else {
+ node.p.right = node.left;
+ }
- node.left.p = node.p;
- node.p = node.left;
- if (node.left.right != nil) {
- node.left.right.p = node;
- }
- node.left = node.left.right;
- node.p.right = node;
- } else {
- Node left = root.left;
- root.left = root.left.right;
- left.right.p = root;
- root.p = left;
- left.right = root;
- left.p = nil;
- root = left;
- }
- }
+ node.left.p = node.p;
+ node.p = node.left;
+ if (node.left.right != nil) {
+ node.left.right.p = node;
+ }
+ node.left = node.left.right;
+ node.p.right = node;
+ } else {
+ Node left = root.left;
+ root.left = root.left.right;
+ left.right.p = root;
+ root.p = left;
+ left.right = root;
+ left.p = nil;
+ root = left;
+ }
+ }
- void transplant(Node target, Node with) {
- if (target.p == nil) {
- root = with;
- } else if (target == target.p.left) {
- target.p.left = with;
- } else
- target.p.right = with;
- with.p = target.p;
- }
+ void transplant(Node target, Node with) {
+ if (target.p == nil) {
+ root = with;
+ } else if (target == target.p.left) {
+ target.p.left = with;
+ } else
+ target.p.right = with;
+ with.p = target.p;
+ }
- Node treeMinimum(Node subTreeRoot) {
- while (subTreeRoot.left != nil) {
- subTreeRoot = subTreeRoot.left;
- }
- return subTreeRoot;
- }
+ Node treeMinimum(Node subTreeRoot) {
+ while (subTreeRoot.left != nil) {
+ subTreeRoot = subTreeRoot.left;
+ }
+ return subTreeRoot;
+ }
- boolean delete(Node z) {
- if ((z = findNode(z, root)) == null)
- return false;
- Node x;
- Node y = z;
- int yorigcolor = y.color;
+ boolean delete(Node z) {
+ if ((z = findNode(z, root)) == null)
+ return false;
+ Node x;
+ Node y = z;
+ int yorigcolor = y.color;
- if (z.left == nil) {
- x = z.right;
- transplant(z, z.right);
- } else if (z.right == nil) {
- x = z.left;
- transplant(z, z.left);
- } else {
- y = treeMinimum(z.right);
- yorigcolor = y.color;
- x = y.right;
- if (y.p == z)
- x.p = y;
- else {
- transplant(y, y.right);
- y.right = z.right;
- y.right.p = y;
- }
- transplant(z, y);
- y.left = z.left;
- y.left.p = y;
- y.color = z.color;
- }
- if (yorigcolor == B)
- deleteFixup(x);
- return true;
- }
+ if (z.left == nil) {
+ x = z.right;
+ transplant(z, z.right);
+ } else if (z.right == nil) {
+ x = z.left;
+ transplant(z, z.left);
+ } else {
+ y = treeMinimum(z.right);
+ yorigcolor = y.color;
+ x = y.right;
+ if (y.p == z)
+ x.p = y;
+ else {
+ transplant(y, y.right);
+ y.right = z.right;
+ y.right.p = y;
+ }
+ transplant(z, y);
+ y.left = z.left;
+ y.left.p = y;
+ y.color = z.color;
+ }
+ if (yorigcolor == B)
+ deleteFixup(x);
+ return true;
+ }
- void deleteFixup(Node x) {
- while (x != root && x.color == B) {
- if (x == x.p.left) {
- Node w = x.p.right;
- if (w.color == R) {
- w.color = B;
- x.p.color = R;
- rotateLeft(x.p);
- w = x.p.right;
- }
- if (w.left.color == B && w.right.color == B) {
- w.color = R;
- x = x.p;
- continue;
- } else if (w.right.color == B) {
- w.left.color = B;
- w.color = R;
- rotateRight(w);
- w = x.p.right;
- }
- if (w.right.color == R) {
- w.color = x.p.color;
- x.p.color = B;
- w.right.color = B;
- rotateLeft(x.p);
- x = root;
- }
- } else {
- Node w = x.p.left;
- if (w.color == R) {
- w.color = B;
- x.p.color = R;
- rotateRight(x.p);
- w = x.p.left;
- }
- if (w.right.color == B && w.left.color == B) {
- w.color = R;
- x = x.p;
- continue;
- } else if (w.left.color == B) {
- w.right.color = B;
- w.color = R;
- rotateLeft(w);
- w = x.p.left;
- }
- if (w.left.color == R) {
- w.color = x.p.color;
- x.p.color = B;
- w.left.color = B;
- rotateRight(x.p);
- x = root;
- }
- }
- }
- x.color = B;
- }
+ void deleteFixup(Node x) {
+ while (x != root && x.color == B) {
+ if (x == x.p.left) {
+ Node w = x.p.right;
+ if (w.color == R) {
+ w.color = B;
+ x.p.color = R;
+ rotateLeft(x.p);
+ w = x.p.right;
+ }
+ if (w.left.color == B && w.right.color == B) {
+ w.color = R;
+ x = x.p;
+ continue;
+ } else if (w.right.color == B) {
+ w.left.color = B;
+ w.color = R;
+ rotateRight(w);
+ w = x.p.right;
+ }
+ if (w.right.color == R) {
+ w.color = x.p.color;
+ x.p.color = B;
+ w.right.color = B;
+ rotateLeft(x.p);
+ x = root;
+ }
+ } else {
+ Node w = x.p.left;
+ if (w.color == R) {
+ w.color = B;
+ x.p.color = R;
+ rotateRight(x.p);
+ w = x.p.left;
+ }
+ if (w.right.color == B && w.left.color == B) {
+ w.color = R;
+ x = x.p;
+ continue;
+ } else if (w.left.color == B) {
+ w.right.color = B;
+ w.color = R;
+ rotateLeft(w);
+ w = x.p.left;
+ }
+ if (w.left.color == R) {
+ w.color = x.p.color;
+ x.p.color = B;
+ w.left.color = B;
+ rotateRight(x.p);
+ x = root;
+ }
+ }
+ }
+ x.color = B;
+ }
- public void insertDemo() {
- Scanner scan = new Scanner(System.in);
- while (true) {
- System.out.println("Add items");
+ public void insertDemo() {
+ Scanner scan = new Scanner(System.in);
+ while (true) {
+ System.out.println("Add items");
- int item;
- Node node;
+ int item;
+ Node node;
- item = scan.nextInt();
- while (item != -999) {
- node = new Node(item);
- insert(node);
- item = scan.nextInt();
- }
- printTree(root);
- System.out.println("Pre order");
- printTreepre(root);
- break;
- }
- }
+ item = scan.nextInt();
+ while (item != -999) {
+ node = new Node(item);
+ insert(node);
+ item = scan.nextInt();
+ }
+ printTree(root);
+ System.out.println("Pre order");
+ printTreepre(root);
+ break;
+ }
+ }
- public void deleteDemo() {
- Scanner scan = new Scanner(System.in);
- System.out.println("Delete items");
- int item;
- Node node;
- item = scan.nextInt();
- node = new Node(item);
- System.out.print("Deleting item " + item);
- if (delete(node)) {
- System.out.print(": deleted!");
- } else {
- System.out.print(": does not exist!");
- }
+ public void deleteDemo() {
+ Scanner scan = new Scanner(System.in);
+ System.out.println("Delete items");
+ int item;
+ Node node;
+ item = scan.nextInt();
+ node = new Node(item);
+ System.out.print("Deleting item " + item);
+ if (delete(node)) {
+ System.out.print(": deleted!");
+ } else {
+ System.out.print(": does not exist!");
+ }
- System.out.println();
- printTree(root);
- System.out.println("Pre order");
- printTreepre(root);
- }
+ System.out.println();
+ printTree(root);
+ System.out.println("Pre order");
+ printTreepre(root);
+ }
}
\ No newline at end of file
diff --git a/DataStructures/Trees/TreeTraversal.java b/DataStructures/Trees/TreeTraversal.java
index 60a2cd4914e9..1c5f8a43715b 100644
--- a/DataStructures/Trees/TreeTraversal.java
+++ b/DataStructures/Trees/TreeTraversal.java
@@ -1,10 +1,10 @@
+package DataStructures.Trees;
+
import java.util.LinkedList;
/**
-*
-* @author Varun Upadhyay (https://github.com/varunu28)
-*
-*/
+ * @author Varun Upadhyay (https://github.com/varunu28)
+ */
// Driver Program
@@ -38,13 +38,13 @@ public static void main(String[] args) {
}
/**
-* The Node class which initializes a Node of a tree
-* Consists of all 4 traversal methods: printInOrder, printPostOrder， printPreOrder & printLevelOrder
-* printInOrder: LEFT -> ROOT -> RIGHT
-* printPreOrder: ROOT -> LEFT -> RIGHT
-* printPostOrder: LEFT -> RIGHT -> ROOT
-* printLevelOrder: Prints by level (starting at root), from left to right.
-*/
+ * The Node class which initializes a Node of a tree
+ * Consists of all 4 traversal methods: printInOrder, printPostOrder， printPreOrder & printLevelOrder
+ * printInOrder: LEFT -> ROOT -> RIGHT
+ * printPreOrder: ROOT -> LEFT -> RIGHT
+ * printPostOrder: LEFT -> RIGHT -> ROOT
+ * printLevelOrder: Prints by level (starting at root), from left to right.
+ */
class Node {
Node left, right;
int data;
@@ -53,20 +53,17 @@ public Node(int data) {
this.data = data;
}
- public void insert (int value) {
+ public void insert(int value) {
if (value < data) {
if (left == null) {
left = new Node(value);
- }
- else {
+ } else {
left.insert(value);
}
- }
- else {
+ } else {
if (right == null) {
right = new Node(value);
- }
- else {
+ } else {
right.insert(value);
}
}
@@ -103,9 +100,9 @@ public void printPostOrder() {
}
/**
- * O(n) time algorithm.
- * Uses O(n) space to store nodes in a queue to aid in traversal.
- */
+ * O(n) time algorithm.
+ * Uses O(n) space to store nodes in a queue to aid in traversal.
+ */
public void printLevelOrder() {
LinkedList queue = new LinkedList<>();
queue.add(this);
diff --git a/DataStructures/Trees/TrieImp.java b/DataStructures/Trees/TrieImp.java
index c55586ff0065..24450f16c2cb 100644
--- a/DataStructures/Trees/TrieImp.java
+++ b/DataStructures/Trees/TrieImp.java
@@ -1,10 +1,11 @@
-//Trie Data structure implementation without any libraries */
+package DataStructures.Trees;
/**
+ * Trie Data structure implementation without any libraries
*
* @author Dheeraj Kumar Barnwal (https://github.com/dheeraj92)
- *
*/
+
import java.util.Scanner;
public class TrieImp {
@@ -13,34 +14,37 @@ public class TrieNode {
TrieNode[] child;
boolean end;
- public TrieNode(){
+ public TrieNode() {
child = new TrieNode[26];
end = false;
}
}
+
private final TrieNode root;
- public TrieImp(){
+
+ public TrieImp() {
root = new TrieNode();
}
- public void insert(String word){
+ public void insert(String word) {
TrieNode currentNode = root;
- for(int i=0; i < word.length();i++){
- TrieNode node = currentNode.child[word.charAt(i)-'a'];
- if(node == null){
+ for (int i = 0; i < word.length(); i++) {
+ TrieNode node = currentNode.child[word.charAt(i) - 'a'];
+ if (node == null) {
node = new TrieNode();
- currentNode.child[word.charAt(i)-'a']=node;
+ currentNode.child[word.charAt(i) - 'a'] = node;
}
currentNode = node;
}
currentNode.end = true;
}
- public boolean search(String word){
+
+ public boolean search(String word) {
TrieNode currentNode = root;
- for(int i=0;i= min and <= max. */
- boolean isBSTUtil(Node node, int min, int max)
- {
+ boolean isBSTUtil(Node node, int min, int max) {
/* an empty tree is BST */
if (node == null)
return true;
-
+
/* false if this node violates the min/max constraints */
if (node.data < min || node.data > max)
return false;
@@ -40,23 +39,7 @@ boolean isBSTUtil(Node node, int min, int max)
/* otherwise check the subtrees recursively
tightening the min/max constraints */
// Allow only distinct values
- return (isBSTUtil(node.left, min, node.data-1) &&
- isBSTUtil(node.right, node.data+1, max));
- }
-
- /* Driver program to test above functions */
- public static void main(String args[])
- {
- ValidBSTOrNot tree = new ValidBSTOrNot();
- tree.root = new Node(4);
- tree.root.left = new Node(2);
- tree.root.right = new Node(5);
- tree.root.left.left = new Node(1);
- tree.root.left.right = new Node(3);
-
- if (tree.isBST())
- System.out.println("IS BST");
- else
- System.out.println("Not a BST");
+ return (isBSTUtil(node.left, min, node.data - 1) &&
+ isBSTUtil(node.right, node.data + 1, max));
}
}
\ No newline at end of file
diff --git a/Dynamic Programming/CoinChange.java b/Dynamic Programming/CoinChange.java
deleted file mode 100644
index f4cda7203b7c..000000000000
--- a/Dynamic Programming/CoinChange.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- *
- * @author Varun Upadhyay (https://github.com/varunu28)
- *
- */
-
-public class CoinChange {
-
- // Driver Program
- public static void main(String[] args) {
-
- int amount = 12;
- int[] coins = {1, 2, 5};
-
- System.out.println("Number of combinations of getting change for " + amount + " is: " + change(coins, amount));
- }
-
- /**
- * This method finds the number of combinations of getting change for a given amount and change coins
- *
- * @param coins The list of coins
- * @param amount The amount for which we need to find the change
- * Finds the number of combinations of change
- **/
- public static int change(int[] coins, int amount) {
-
- int[] combinations = new int[amount+1];
- combinations[0] = 1;
-
- for (int coin : coins) {
- for (int i=coin; i insert ? insert : replace;
- min = delete > min ? min : delete;
- dp[i + 1][j + 1] = min;
- }
- }
- }
- /* return the final answer , after traversing through both the strings*/
- return dp[len1][len2];
- }
-
-
- // Driver program to test above function
- public static void main(String args[])
- {
- Scanner input = new Scanner(System.in);
- String s1,s2;
- System.out.println("Enter the First String");
- s1 = input.nextLine();
- System.out.println("Enter the Second String");
- s2 = input.nextLine();
- //ans stores the final Edit Distance between the two strings
- int ans=0;
- ans=minDistance(s1,s2);
- System.out.println("The minimum Edit Distance between \"" + s1 + "\" and \"" + s2 +"\" is "+ans);
- }
- }
diff --git a/Dynamic Programming/EggDropping.java b/Dynamic Programming/EggDropping.java
deleted file mode 100644
index 382d7ea86c2c..000000000000
--- a/Dynamic Programming/EggDropping.java
+++ /dev/null
@@ -1,53 +0,0 @@
-//Dynamic Programming solution for the Egg Dropping Puzzle
-public class EggDropping
-{
-
- // min trials with n eggs and m floors
-
- private static int minTrials(int n, int m)
- {
-
- int eggFloor[][] = new int[n+1][m+1];
- int result, x;
-
- for (int i = 1; i <= n; i++)
- {
- eggFloor[i][0] = 0; // Zero trial for zero floor.
- eggFloor[i][1] = 1; // One trial for one floor
- }
-
- // j trials for only 1 egg
-
- for (int j = 1; j <= m; j++)
- eggFloor[1][j] = j;
-
- // Using bottom-up approach in DP
-
- for (int i = 2; i <= n; i++)
- {
- for (int j = 2; j <= m; j++)
- {
- eggFloor[i][j] = Integer.MAX_VALUE;
- for (x = 1; x <= j; x++)
- {
- result = 1 + Math.max(eggFloor[i-1][x-1], eggFloor[i][j-x]);
-
- //choose min of all values for particular x
- if (result < eggFloor[i][j])
- eggFloor[i][j] = result;
- }
- }
- }
-
- return eggFloor[n][m];
- }
-
- //testing program
- public static void main(String args[])
- {
- int n = 2, m = 4;
- //result outputs min no. of trials in worst case for n eggs and m floors
- int result = minTrials(n, m);
- System.out.println(result);
- }
-}
diff --git a/Dynamic Programming/Fibonacci.java b/Dynamic Programming/Fibonacci.java
deleted file mode 100644
index b2524b4db471..000000000000
--- a/Dynamic Programming/Fibonacci.java
+++ /dev/null
@@ -1,75 +0,0 @@
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- *
- * @author Varun Upadhyay (https://github.com/varunu28)
- *
- */
-
-public class Fibonacci {
-
- private static Map map = new HashMap();
-
- public static void main(String[] args) throws Exception {
-
- BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
- int n = Integer.parseInt(br.readLine());
-
- System.out.println(fibMemo(n)); // Returns 8 for n = 6
- System.out.println(fibBotUp(n)); // Returns 8 for n = 6
- }
-
- /**
- * This method finds the nth fibonacci number using memoization technique
- *
- * @param n The input n for which we have to determine the fibonacci number
- * Outputs the nth fibonacci number
- **/
-
- private static int fibMemo(int n) {
- if (map.containsKey(n)) {
- return map.get(n);
- }
-
- int f;
-
- if (n <= 2) {
- f = 1;
- }
- else {
- f = fibMemo(n-1) + fibMemo(n-2);
- map.put(n,f);
- }
-
- return f;
- }
-
- /**
- * This method finds the nth fibonacci number using bottom up
- *
- * @param n The input n for which we have to determine the fibonacci number
- * Outputs the nth fibonacci number
- **/
-
- private static int fibBotUp(int n) {
-
- Map fib = new HashMap();
-
- for (int i=1;imaxsum){
- maxsum=cursum;
- }
- if(cursum<=0){
- cursum=0;
- }
- }
- return maxsum;
- }
-
- /**
- * Main method
- *
- * @param args Command line arguments
- */
- public static void main(String[] args) {
- Scanner sc=new Scanner(System.in);
- int n,arr[],i;
- n=sc.nextInt();
- arr=new int[n];
- for(i=0;i lcsMatrix[i][j-1] ? lcsMatrix[i-1][j] : lcsMatrix[i][j-1];
- }
- }
- }
- return lcsString(str1, str2, lcsMatrix);
- }
-
- public static String lcsString (String str1, String str2, int[][] lcsMatrix) {
- StringBuilder lcs = new StringBuilder();
- int i = str1.length(),
- j = str2.length();
- while(i > 0 && j > 0) {
- if(str1.charAt(i-1) == str2.charAt(j-1)) {
- lcs.append(str1.charAt(i-1));
- i--;
- j--;
- } else if(lcsMatrix[i-1][j] > lcsMatrix[i][j-1]) {
- i--;
- } else {
- j--;
- }
- }
- return lcs.reverse().toString();
- }
-
- public static void main(String[] args) {
- String str1 = "DSGSHSRGSRHTRD";
- String str2 = "DATRGAGTSHS";
- String lcs = getLCS(str1, str2);
-
- //Print LCS
- if(lcs != null) {
- System.out.println("String 1: " + str1);
- System.out.println("String 2: " + str2);
- System.out.println("LCS: " + lcs);
- System.out.println("LCS length: " + lcs.length());
- }
- }
-}
\ No newline at end of file
diff --git a/Dynamic Programming/RodCutting.java b/Dynamic Programming/RodCutting.java
deleted file mode 100644
index cd2512059ae2..000000000000
--- a/Dynamic Programming/RodCutting.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/* A Dynamic Programming solution for Rod cutting problem
- Returns the best obtainable price for a rod of
- length n and price[] as prices of different pieces */
-
-public class RodCutting {
-
- private static int cutRod(int price[],int n)
- {
- int val[] = new int[n+1];
- val[0] = 0;
-
- for (int i = 1; i<=n; i++)
- {
- int max_val = Integer.MIN_VALUE;
- for (int j = 0; j < i; j++)
- max_val = Math.max(max_val,price[j] + val[i-j-1]);
-
- val[i] = max_val;
- }
-
- return val[n];
- }
-
- //main function to test
- public static void main(String args[])
- {
- int arr[] = new int[] {2, 5, 13, 19, 20};
- int size = arr.length;
- System.out.println("Maximum Obtainable Value is " +
- cutRod(arr, size));
- }
-}
diff --git a/DynamicProgramming/CoinChange.java b/DynamicProgramming/CoinChange.java
new file mode 100644
index 000000000000..7e4e6181ccc9
--- /dev/null
+++ b/DynamicProgramming/CoinChange.java
@@ -0,0 +1,79 @@
+package DynamicProgramming;
+
+/**
+ * @author Varun Upadhyay (https://github.com/varunu28)
+ */
+public class CoinChange {
+
+ // Driver Program
+ public static void main(String[] args) {
+
+ int amount = 12;
+ int[] coins = {2, 4, 5};
+
+ System.out.println("Number of combinations of getting change for " + amount + " is: " + change(coins, amount));
+ System.out.println("Minimum number of coins required for amount :" + amount + " is: " + minimumCoins(coins, amount));
+
+ }
+
+ /**
+ * This method finds the number of combinations of getting change for a given amount and change coins
+ *
+ * @param coins The list of coins
+ * @param amount The amount for which we need to find the change
+ * Finds the number of combinations of change
+ **/
+ public static int change(int[] coins, int amount) {
+
+ int[] combinations = new int[amount + 1];
+ combinations[0] = 1;
+
+ for (int coin : coins) {
+ for (int i = coin; i < amount + 1; i++) {
+ combinations[i] += combinations[i - coin];
+ }
+ // Uncomment the below line to see the state of combinations for each coin
+ // printAmount(combinations);
+ }
+
+ return combinations[amount];
+ }
+
+ /**
+ * This method finds the minimum number of coins needed for a given amount.
+ *
+ * @param coins The list of coins
+ * @param amount The amount for which we need to find the minimum number of coins.
+ * Finds the the minimum number of coins that make a given value.
+ **/
+ public static int minimumCoins(int[] coins, int amount) {
+ //minimumCoins[i] will store the minimum coins needed for amount i
+ int[] minimumCoins = new int[amount + 1];
+
+ minimumCoins[0] = 0;
+
+ for (int i = 1; i <= amount; i++) {
+ minimumCoins[i] = Integer.MAX_VALUE;
+ }
+ for (int i = 1; i <= amount; i++) {
+ for (int coin : coins) {
+ if (coin <= i) {
+ int sub_res = minimumCoins[i - coin];
+ if (sub_res != Integer.MAX_VALUE && sub_res + 1 < minimumCoins[i])
+ minimumCoins[i] = sub_res + 1;
+ }
+ }
+ }
+ // Uncomment the below line to see the state of combinations for each coin
+ //printAmount(minimumCoins);
+ return minimumCoins[amount];
+ }
+
+ // A basic print method which prints all the contents of the array
+ public static void printAmount(int[] arr) {
+ for (int i = 0; i < arr.length; i++) {
+ System.out.print(arr[i] + " ");
+ }
+ System.out.println();
+ }
+}
\ No newline at end of file
diff --git a/DynamicProgramming/EditDistance.java b/DynamicProgramming/EditDistance.java
new file mode 100644
index 000000000000..210469b84108
--- /dev/null
+++ b/DynamicProgramming/EditDistance.java
@@ -0,0 +1,78 @@
+package DynamicProgramming;
+
+/**
+ * A DynamicProgramming based solution for Edit Distance problem In Java
+ * Description of Edit Distance with an Example:
+ *
+ * Edit distance is a way of quantifying how dissimilar two strings (e.g., words) are to one another,
+ * by counting the minimum number of operations required to transform one string into the other. The
+ * distance operations are the removal, insertion, or substitution of a character in the string.
+ *
+ *
+ * The Distance between "kitten" and "sitting" is 3. A minimal edit script that transforms the former into the latter is:
+ *
+ * kitten → sitten (substitution of "s" for "k")
+ * sitten → sittin (substitution of "i" for "e")
+ * sittin → sitting (insertion of "g" at the end).
+ *
+ * @author SUBHAM SANGHAI
+ **/
+
+import java.util.Scanner;
+
+public class EditDistance {
+
+ public static int minDistance(String word1, String word2) {
+ int len1 = word1.length();
+ int len2 = word2.length();
+ // len1+1, len2+1, because finally return dp[len1][len2]
+ int[][] dp = new int[len1 + 1][len2 + 1];
+ /* If second string is empty, the only option is to
+ insert all characters of first string into second*/
+ for (int i = 0; i <= len1; i++) {
+ dp[i][0] = i;
+ }
+ /* If first string is empty, the only option is to
+ insert all characters of second string into first*/
+ for (int j = 0; j <= len2; j++) {
+ dp[0][j] = j;
+ }
+ //iterate though, and check last char
+ for (int i = 0; i < len1; i++) {
+ char c1 = word1.charAt(i);
+ for (int j = 0; j < len2; j++) {
+ char c2 = word2.charAt(j);
+ //if last two chars equal
+ if (c1 == c2) {
+ //update dp value for +1 length
+ dp[i + 1][j + 1] = dp[i][j];
+ } else {
+ /* if two characters are different ,
+ then take the minimum of the various operations(i.e insertion,removal,substitution)*/
+ int replace = dp[i][j] + 1;
+ int insert = dp[i][j + 1] + 1;
+ int delete = dp[i + 1][j] + 1;
+
+ int min = replace > insert ? insert : replace;
+ min = delete > min ? min : delete;
+ dp[i + 1][j + 1] = min;
+ }
+ }
+ }
+ /* return the final answer , after traversing through both the strings*/
+ return dp[len1][len2];
+ }
+
+
+ public static void main(String[] args) {
+ Scanner input = new Scanner(System.in);
+ String s1, s2;
+ System.out.println("Enter the First String");
+ s1 = input.nextLine();
+ System.out.println("Enter the Second String");
+ s2 = input.nextLine();
+ //ans stores the final Edit Distance between the two strings
+ int ans = minDistance(s1, s2);
+ System.out.println("The minimum Edit Distance between \"" + s1 + "\" and \"" + s2 + "\" is " + ans);
+ }
+}
diff --git a/DynamicProgramming/EggDropping.java b/DynamicProgramming/EggDropping.java
new file mode 100644
index 000000000000..f53712bd9304
--- /dev/null
+++ b/DynamicProgramming/EggDropping.java
@@ -0,0 +1,49 @@
+package DynamicProgramming;
+
+/**
+ * DynamicProgramming solution for the Egg Dropping Puzzle
+ */
+public class EggDropping {
+
+ // min trials with n eggs and m floors
+
+ private static int minTrials(int n, int m) {
+
+ int[][] eggFloor = new int[n + 1][m + 1];
+ int result, x;
+
+ for (int i = 1; i <= n; i++) {
+ eggFloor[i][0] = 0; // Zero trial for zero floor.
+ eggFloor[i][1] = 1; // One trial for one floor
+ }
+
+ // j trials for only 1 egg
+
+ for (int j = 1; j <= m; j++)
+ eggFloor[1][j] = j;
+
+ // Using bottom-up approach in DP
+
+ for (int i = 2; i <= n; i++) {
+ for (int j = 2; j <= m; j++) {
+ eggFloor[i][j] = Integer.MAX_VALUE;
+ for (x = 1; x <= j; x++) {
+ result = 1 + Math.max(eggFloor[i - 1][x - 1], eggFloor[i][j - x]);
+
+ // choose min of all values for particular x
+ if (result < eggFloor[i][j])
+ eggFloor[i][j] = result;
+ }
+ }
+ }
+
+ return eggFloor[n][m];
+ }
+
+ public static void main(String args[]) {
+ int n = 2, m = 4;
+ // result outputs min no. of trials in worst case for n eggs and m floors
+ int result = minTrials(n, m);
+ System.out.println(result);
+ }
+}
diff --git a/DynamicProgramming/Fibonacci.java b/DynamicProgramming/Fibonacci.java
new file mode 100644
index 000000000000..35af98add478
--- /dev/null
+++ b/DynamicProgramming/Fibonacci.java
@@ -0,0 +1,98 @@
+package DynamicProgramming;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Varun Upadhyay (https://github.com/varunu28)
+ */
+
+public class Fibonacci {
+
+ private static Map map = new HashMap<>();
+
+ public static void main(String[] args) throws Exception {
+
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ int n = Integer.parseInt(br.readLine());
+
+ // Methods all returning [0, 1, 1, 2, 3, 5, ...] for n = [0, 1, 2, 3, 4, 5, ...]
+ System.out.println(fibMemo(n));
+ System.out.println(fibBotUp(n));
+ }
+
+ /**
+ * This method finds the nth fibonacci number using memoization technique
+ *
+ * @param n The input n for which we have to determine the fibonacci number
+ * Outputs the nth fibonacci number
+ **/
+ private static int fibMemo(int n) {
+ if (map.containsKey(n)) {
+ return map.get(n);
+ }
+
+ int f;
+
+ if (n <= 1) {
+ f = n;
+ } else {
+ f = fibMemo(n - 1) + fibMemo(n - 2);
+ map.put(n, f);
+ }
+ return f;
+ }
+
+ /**
+ * This method finds the nth fibonacci number using bottom up
+ *
+ * @param n The input n for which we have to determine the fibonacci number
+ * Outputs the nth fibonacci number
+ **/
+ private static int fibBotUp(int n) {
+
+ Map fib = new HashMap<>();
+
+ for (int i = 0; i <= n; i++) {
+ int f;
+ if (i <= 1) {
+ f = i;
+ } else {
+ f = fib.get(i - 1) + fib.get(i - 2);
+ }
+ fib.put(i, f);
+ }
+
+ return fib.get(n);
+ }
+
+
+ /**
+ * This method finds the nth fibonacci number using bottom up
+ *
+ * @param n The input n for which we have to determine the fibonacci number
+ * Outputs the nth fibonacci number
+ *
+ * This is optimized version of Fibonacci Program. Without using Hashmap and recursion.
+ * It saves both memory and time.
+ * Space Complexity will be O(1)
+ * Time Complexity will be O(n)
+ *
+ * Whereas , the above functions will take O(n) Space.
+ * @author Shoaib Rayeen (https://github.com/shoaibrayeen)
+ **/
+ private static int fibOptimized(int n) {
+ if (n == 0) {
+ return 0;
+ }
+ int prev = 0, res = 1, next;
+ for (int i = 2; i < n; i++) {
+ next = prev + res;
+ prev = res;
+ res = next;
+ }
+ return res;
+ }
+}
\ No newline at end of file
diff --git a/DynamicProgramming/FordFulkerson.java b/DynamicProgramming/FordFulkerson.java
new file mode 100644
index 000000000000..7a162fbb06d1
--- /dev/null
+++ b/DynamicProgramming/FordFulkerson.java
@@ -0,0 +1,72 @@
+package DynamicProgramming;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Vector;
+
+public class FordFulkerson {
+ final static int INF = 987654321;
+ // edges
+ static int V;
+ static int[][] capacity, flow;
+
+ public static void main(String[] args) {
+ System.out.println("V : 6");
+ V = 6;
+ capacity = new int[V][V];
+
+ capacity[0][1] = 12;
+ capacity[0][3] = 13;
+ capacity[1][2] = 10;
+ capacity[2][3] = 13;
+ capacity[2][4] = 3;
+ capacity[2][5] = 15;
+ capacity[3][2] = 7;
+ capacity[3][4] = 15;
+ capacity[4][5] = 17;
+
+ System.out.println("Max capacity in networkFlow : " + networkFlow(0, 5));
+ }
+
+ private static int networkFlow(int source, int sink) {
+ flow = new int[V][V];
+ int totalFlow = 0;
+ while (true) {
+ Vector parent = new Vector<>(V);
+ for (int i = 0; i < V; i++)
+ parent.add(-1);
+ Queue q = new LinkedList<>();
+ parent.set(source, source);
+ q.add(source);
+ while (!q.isEmpty() && parent.get(sink) == -1) {
+ int here = q.peek();
+ q.poll();
+ for (int there = 0; there < V; ++there)
+ if (capacity[here][there] - flow[here][there] > 0 && parent.get(there) == -1) {
+ q.add(there);
+ parent.set(there, here);
+ }
+ }
+ if (parent.get(sink) == -1)
+ break;
+
+ int amount = INF;
+ String printer = "path : ";
+ StringBuilder sb = new StringBuilder();
+ for (int p = sink; p != source; p = parent.get(p)) {
+ amount = Math.min(capacity[parent.get(p)][p] - flow[parent.get(p)][p], amount);
+ sb.append(p + "-");
+ }
+ sb.append(source);
+ for (int p = sink; p != source; p = parent.get(p)) {
+ flow[parent.get(p)][p] += amount;
+ flow[p][parent.get(p)] -= amount;
+ }
+ totalFlow += amount;
+ printer += sb.reverse() + " / max flow : " + totalFlow;
+ System.out.println(printer);
+ }
+
+ return totalFlow;
+ }
+}
diff --git a/DynamicProgramming/KadaneAlgorithm.java b/DynamicProgramming/KadaneAlgorithm.java
new file mode 100644
index 000000000000..8d77c7a7c556
--- /dev/null
+++ b/DynamicProgramming/KadaneAlgorithm.java
@@ -0,0 +1,55 @@
+package DynamicProgramming;
+
+import java.util.Scanner;
+
+/**
+ * Program to implement Kadane’s Algorithm to
+ * calculate maximum contiguous subarray sum of an array
+ * Time Complexity: O(n)
+ *
+ * @author Nishita Aggarwal
+ */
+
+public class KadaneAlgorithm {
+
+ /**
+ * This method implements Kadane's Algorithm
+ *
+ * @param arr The input array
+ * @return The maximum contiguous subarray sum of the array
+ */
+ static int largestContiguousSum(int arr[]) {
+ int i, len = arr.length, cursum = 0, maxsum = Integer.MIN_VALUE;
+ if (len == 0) //empty array
+ return 0;
+ for (i = 0; i < len; i++) {
+ cursum += arr[i];
+ if (cursum > maxsum) {
+ maxsum = cursum;
+ }
+ if (cursum <= 0) {
+ cursum = 0;
+ }
+ }
+ return maxsum;
+ }
+
+ /**
+ * Main method
+ *
+ * @param args Command line arguments
+ */
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ int n, arr[], i;
+ n = sc.nextInt();
+ arr = new int[n];
+ for (i = 0; i < n; i++) {
+ arr[i] = sc.nextInt();
+ }
+ int maxContSum = largestContiguousSum(arr);
+ System.out.println(maxContSum);
+ sc.close();
+ }
+
+}
diff --git a/DynamicProgramming/Knapsack.java b/DynamicProgramming/Knapsack.java
new file mode 100644
index 000000000000..025d3cd2b2e2
--- /dev/null
+++ b/DynamicProgramming/Knapsack.java
@@ -0,0 +1,37 @@
+package DynamicProgramming;
+
+/**
+ * A DynamicProgramming based solution for 0-1 Knapsack problem
+ */
+
+public class Knapsack {
+
+ private static int knapSack(int W, int wt[], int val[], int n) {
+ int i, w;
+ int rv[][] = new int[n + 1][W + 1]; //rv means return value
+
+ // Build table rv[][] in bottom up manner
+ for (i = 0; i <= n; i++) {
+ for (w = 0; w <= W; w++) {
+ if (i == 0 || w == 0)
+ rv[i][w] = 0;
+ else if (wt[i - 1] <= w)
+ rv[i][w] = Math.max(val[i - 1] + rv[i - 1][w - wt[i - 1]], rv[i - 1][w]);
+ else
+ rv[i][w] = rv[i - 1][w];
+ }
+ }
+
+ return rv[n][W];
+ }
+
+
+ // Driver program to test above function
+ public static void main(String args[]) {
+ int val[] = new int[]{50, 100, 130};
+ int wt[] = new int[]{10, 20, 40};
+ int W = 50;
+ int n = val.length;
+ System.out.println(knapSack(W, wt, val, n));
+ }
+}
diff --git a/DynamicProgramming/LevenshteinDistance.java b/DynamicProgramming/LevenshteinDistance.java
new file mode 100644
index 000000000000..c4d53143f80b
--- /dev/null
+++ b/DynamicProgramming/LevenshteinDistance.java
@@ -0,0 +1,56 @@
+package DynamicProgramming;
+
+/**
+ * @author Kshitij VERMA (github.com/kv19971)
+ * LEVENSHTEIN DISTANCE dyamic programming implementation to show the difference between two strings (https://en.wikipedia.org/wiki/Levenshtein_distance)
+ */
+
+public class LevenshteinDistance {
+ private static int minimum(int a, int b, int c) {
+ if (a < b && a < c) {
+ return a;
+ } else if (b < a && b < c) {
+ return b;
+ } else {
+ return c;
+ }
+ }
+
+ private static int calculate_distance(String a, String b) {
+ int len_a = a.length() + 1;
+ int len_b = b.length() + 1;
+ int[][] distance_mat = new int[len_a][len_b];
+ for (int i = 0; i < len_a; i++) {
+ distance_mat[i][0] = i;
+ }
+ for (int j = 0; j < len_b; j++) {
+ distance_mat[0][j] = j;
+ }
+ for (int i = 0; i < len_a; i++) {
+ for (int j = 0; j < len_b; j++) {
+ int cost;
+ if (a.charAt(i) == b.charAt(j)) {
+ cost = 0;
+ } else {
+ cost = 1;
+ }
+ distance_mat[i][j] = minimum(distance_mat[i - 1][j], distance_mat[i - 1][j - 1], distance_mat[i][j - 1]) + cost;
+
+
+ }
+
+ }
+ return distance_mat[len_a - 1][len_b - 1];
+
+ }
+
+ public static void main(String[] args) {
+ String a = ""; // enter your string here
+ String b = ""; // enter your string here
+
+ System.out.print("Levenshtein distance between " + a + " and " + b + " is: ");
+ System.out.println(calculate_distance(a, b));
+
+
+ }
+}
diff --git a/DynamicProgramming/LongestCommonSubsequence.java b/DynamicProgramming/LongestCommonSubsequence.java
new file mode 100644
index 000000000000..fad223748bdd
--- /dev/null
+++ b/DynamicProgramming/LongestCommonSubsequence.java
@@ -0,0 +1,68 @@
+package DynamicProgramming;
+
+class LongestCommonSubsequence {
+
+ public static String getLCS(String str1, String str2) {
+
+ //At least one string is null
+ if (str1 == null || str2 == null)
+ return null;
+
+ //At least one string is empty
+ if (str1.length() == 0 || str2.length() == 0)
+ return "";
+
+ String[] arr1 = str1.split("");
+ String[] arr2 = str2.split("");
+
+ //lcsMatrix[i][j] = LCS of first i elements of arr1 and first j characters of arr2
+ int[][] lcsMatrix = new int[arr1.length + 1][arr2.length + 1];
+
+ for (int i = 0; i < arr1.length + 1; i++)
+ lcsMatrix[i][0] = 0;
+ for (int j = 1; j < arr2.length + 1; j++)
+ lcsMatrix[0][j] = 0;
+ for (int i = 1; i < arr1.length + 1; i++) {
+ for (int j = 1; j < arr2.length + 1; j++) {
+ if (arr1[i - 1].equals(arr2[j - 1])) {
+ lcsMatrix[i][j] = lcsMatrix[i - 1][j - 1] + 1;
+ } else {
+ lcsMatrix[i][j] = lcsMatrix[i - 1][j] > lcsMatrix[i][j - 1] ? lcsMatrix[i - 1][j] : lcsMatrix[i][j - 1];
+ }
+ }
+ }
+ return lcsString(str1, str2, lcsMatrix);
+ }
+
+ public static String lcsString(String str1, String str2, int[][] lcsMatrix) {
+ StringBuilder lcs = new StringBuilder();
+ int i = str1.length(),
+ j = str2.length();
+ while (i > 0 && j > 0) {
+ if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
+ lcs.append(str1.charAt(i - 1));
+ i--;
+ j--;
+ } else if (lcsMatrix[i - 1][j] > lcsMatrix[i][j - 1]) {
+ i--;
+ } else {
+ j--;
+ }
+ }
+ return lcs.reverse().toString();
+ }
+
+ public static void main(String[] args) {
+ String str1 = "DSGSHSRGSRHTRD";
+ String str2 = "DATRGAGTSHS";
+ String lcs = getLCS(str1, str2);
+
+ //Print LCS
+ if (lcs != null) {
+ System.out.println("String 1: " + str1);
+ System.out.println("String 2: " + str2);
+ System.out.println("LCS: " + lcs);
+ System.out.println("LCS length: " + lcs.length());
+ }
+ }
+}
\ No newline at end of file
diff --git a/Dynamic Programming/LongestIncreasingSubsequence.java b/DynamicProgramming/LongestIncreasingSubsequence.java
similarity index 60%
rename from Dynamic Programming/LongestIncreasingSubsequence.java
rename to DynamicProgramming/LongestIncreasingSubsequence.java
index eaa574a40989..2b07e040db13 100644
--- a/Dynamic Programming/LongestIncreasingSubsequence.java
+++ b/DynamicProgramming/LongestIncreasingSubsequence.java
@@ -1,12 +1,12 @@
+package DynamicProgramming;
+
import java.util.Scanner;
/**
- *
* @author Afrizal Fikri (https://github.com/icalF)
- *
*/
public class LongestIncreasingSubsequence {
- public static void main(String[] args) throws Exception {
+ public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
@@ -20,7 +20,7 @@ public static void main(String[] args) throws Exception {
}
private static int upperBound(int[] ar, int l, int r, int key) {
- while (l < r-1) {
+ while (l < r - 1) {
int m = (l + r) / 2;
if (ar[m] >= key)
r = m;
@@ -35,10 +35,12 @@ private static int LIS(int[] array) {
int N = array.length;
if (N == 0)
return 0;
-
+
int[] tail = new int[N];
- int length = 1; // always points empty slot in tail
-
+
+ // always points empty slot in tail
+ int length = 1;
+
tail[0] = array[0];
for (int i = 1; i < N; i++) {
@@ -46,17 +48,17 @@ private static int LIS(int[] array) {
if (array[i] < tail[0])
tail[0] = array[i];
- // array[i] extends largest subsequence
- else if (array[i] > tail[length-1])
+ // array[i] extends largest subsequence
+ else if (array[i] > tail[length - 1])
tail[length++] = array[i];
- // array[i] will become end candidate of an existing subsequence or
- // Throw away larger elements in all LIS, to make room for upcoming grater elements than array[i]
- // (and also, array[i] would have already appeared in one of LIS, identify the location and replace it)
+ // array[i] will become end candidate of an existing subsequence or
+ // Throw away larger elements in all LIS, to make room for upcoming grater elements than array[i]
+ // (and also, array[i] would have already appeared in one of LIS, identify the location and replace it)
else
- tail[upperBound(tail, -1, length-1, array[i])] = array[i];
+ tail[upperBound(tail, -1, length - 1, array[i])] = array[i];
}
-
+
return length;
}
}
\ No newline at end of file
diff --git a/DynamicProgramming/LongestValidParentheses.java b/DynamicProgramming/LongestValidParentheses.java
new file mode 100644
index 000000000000..bc5f18ae0593
--- /dev/null
+++ b/DynamicProgramming/LongestValidParentheses.java
@@ -0,0 +1,61 @@
+package DynamicProgramming;
+
+import java.util.Scanner;
+
+/**
+ * Given a string containing just the characters '(' and ')', find the length of
+ * the longest valid (well-formed) parentheses substring.
+ *
+ * @author Libin Yang (https://github.com/yanglbme)
+ * @since 2018/10/5
+ */
+
+public class LongestValidParentheses {
+
+ public static int getLongestValidParentheses(String s) {
+ if (s == null || s.length() < 2) {
+ return 0;
+ }
+ char[] chars = s.toCharArray();
+ int n = chars.length;
+ int[] res = new int[n];
+ res[0] = 0;
+ res[1] = chars[1] == ')' && chars[0] == '(' ? 2 : 0;
+
+ int max = res[1];
+
+ for (int i = 2; i < n; ++i) {
+ if (chars[i] == ')') {
+ if (chars[i - 1] == '(') {
+ res[i] = res[i - 2] + 2;
+ } else {
+ int index = i - res[i - 1] - 1;
+ if (index >= 0 && chars[index] == '(') {
+ // ()(())
+ res[i] = res[i - 1] + 2 + (index - 1 >= 0 ? res[index - 1] : 0);
+ }
+ }
+ }
+ max = Math.max(max, res[i]);
+ }
+
+ return max;
+
+ }
+
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+
+ while (true) {
+ String str = sc.nextLine();
+ if ("quit".equals(str)) {
+ break;
+ }
+ int len = getLongestValidParentheses(str);
+ System.out.println(len);
+
+ }
+
+ sc.close();
+ }
+}
diff --git a/DynamicProgramming/MatrixChainMultiplication.java b/DynamicProgramming/MatrixChainMultiplication.java
new file mode 100644
index 000000000000..66b2a35824e2
--- /dev/null
+++ b/DynamicProgramming/MatrixChainMultiplication.java
@@ -0,0 +1,136 @@
+package DynamicProgramming;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class MatrixChainMultiplication {
+ private static Scanner scan = new Scanner(System.in);
+ private static ArrayList mArray = new ArrayList<>();
+ private static int size;
+ private static int[][] m;
+ private static int[][] s;
+ private static int[] p;
+
+ public static void main(String[] args) {
+ int count = 1;
+ while (true) {
+ String[] mSize = input("input size of matrix A(" + count + ") ( ex. 10 20 ) : ");
+ int col = Integer.parseInt(mSize[0]);
+ if (col == 0) break;
+ int row = Integer.parseInt(mSize[1]);
+
+ Matrix matrix = new Matrix(count, col, row);
+ mArray.add(matrix);
+ count++;
+ }
+ for (Matrix m : mArray) {
+ System.out.format("A(%d) = %2d x %2d\n", m.count(), m.col(), m.row());
+ }
+
+ size = mArray.size();
+ m = new int[size + 1][size + 1];
+ s = new int[size + 1][size + 1];
+ p = new int[size + 1];
+
+ for (int i = 0; i < size + 1; i++) {
+ Arrays.fill(m[i], -1);
+ Arrays.fill(s[i], -1);
+ }
+
+ for (int i = 0; i < p.length; i++) {
+ p[i] = i == 0 ? mArray.get(i).col() : mArray.get(i - 1).row();
+ }
+
+ matrixChainOrder();
+ for (int i = 0; i < size; i++) {
+ System.out.print("-------");
+ }
+ System.out.println();
+ printArray(m);
+ for (int i = 0; i < size; i++) {
+ System.out.print("-------");
+ }
+ System.out.println();
+ printArray(s);
+ for (int i = 0; i < size; i++) {
+ System.out.print("-------");
+ }
+ System.out.println();
+
+ System.out.println("Optimal solution : " + m[1][size]);
+ System.out.print("Optimal parens : ");
+ printOptimalParens(1, size);
+ }
+
+ private static void printOptimalParens(int i, int j) {
+ if (i == j) {
+ System.out.print("A" + i);
+ } else {
+ System.out.print("(");
+ printOptimalParens(i, s[i][j]);
+ printOptimalParens(s[i][j] + 1, j);
+ System.out.print(")");
+ }
+ }
+
+ private static void printArray(int[][] array) {
+ for (int i = 1; i < size + 1; i++) {
+ for (int j = 1; j < size + 1; j++) {
+ System.out.print(String.format("%7d", array[i][j]));
+ }
+ System.out.println();
+ }
+ }
+
+ private static void matrixChainOrder() {
+ for (int i = 1; i < size + 1; i++) {
+ m[i][i] = 0;
+ }
+
+ for (int l = 2; l < size + 1; l++) {
+ for (int i = 1; i < size - l + 2; i++) {
+ int j = i + l - 1;
+ m[i][j] = Integer.MAX_VALUE;
+
+ for (int k = i; k < j; k++) {
+ int q = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
+ if (q < m[i][j]) {
+ m[i][j] = q;
+ s[i][j] = k;
+ }
+ }
+ }
+ }
+ }
+
+ private static String[] input(String string) {
+ System.out.print(string);
+ return (scan.nextLine().split(" "));
+ }
+
+}
+
+class Matrix {
+ private int count;
+ private int col;
+ private int row;
+
+ Matrix(int count, int col, int row) {
+ this.count = count;
+ this.col = col;
+ this.row = row;
+ }
+
+ int count() {
+ return count;
+ }
+
+ int col() {
+ return col;
+ }
+
+ int row() {
+ return row;
+ }
+}
diff --git a/DynamicProgramming/RodCutting.java b/DynamicProgramming/RodCutting.java
new file mode 100644
index 000000000000..d57c69ce9ae4
--- /dev/null
+++ b/DynamicProgramming/RodCutting.java
@@ -0,0 +1,32 @@
+package DynamicProgramming;
+
+/**
+ * A DynamicProgramming solution for Rod cutting problem
+ * Returns the best obtainable price for a rod of
+ * length n and price[] as prices of different pieces
+ */
+public class RodCutting {
+
+ private static int cutRod(int[] price, int n) {
+ int val[] = new int[n + 1];
+ val[0] = 0;
+
+ for (int i = 1; i <= n; i++) {
+ int max_val = Integer.MIN_VALUE;
+ for (int j = 0; j < i; j++)
+ max_val = Math.max(max_val, price[j] + val[i - j - 1]);
+
+ val[i] = max_val;
+ }
+
+ return val[n];
+ }
+
+ // main function to test
+ public static void main(String args[]) {
+ int[] arr = new int[]{2, 5, 13, 19, 20};
+ int size = arr.length;
+ System.out.println("Maximum Obtainable Value is " +
+ cutRod(arr, size));
+ }
+}
diff --git a/Maths/AbsoluteValue.java b/Maths/AbsoluteValue.java
new file mode 100644
index 000000000000..82faf81ff92a
--- /dev/null
+++ b/Maths/AbsoluteValue.java
@@ -0,0 +1,24 @@
+package Maths;
+
+/**
+ * @author PatOnTheBack
+ */
+
+public class AbsoluteValue {
+
+ public static void main(String[] args) {
+ int value = -34;
+ System.out.println("The absolute value of " + value + " is " + absVal(value));
+ }
+
+ /**
+ * If value is less than zero, make value positive.
+ *
+ * @param value a number
+ * @return the absolute value of a number
+ */
+ public static int absVal(int value) {
+ return value > 0 ? value : -value;
+ }
+
+}
diff --git a/MinimizingLateness/MinimizingLateness.java b/MinimizingLateness/MinimizingLateness.java
index a6613cbcb369..e5f71e9ef44a 100644
--- a/MinimizingLateness/MinimizingLateness.java
+++ b/MinimizingLateness/MinimizingLateness.java
@@ -1,52 +1,57 @@
-import java.io.*;
-import java.util.*;
+package MinimizingLateness;
+
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.StringTokenizer;
public class MinimizingLateness {
- private static class Schedule { // Schedule class
- int t = 0; // Time required for the operation to be performed
- int d = 0; // Time the job should be completed
- int s = 0; // Start time of the task
- int f = 0; // End time of the operation
-
- public Schedule(int t, int d) {
- this.t = t;
- this.d = d;
- }
- }
-
- public static void main(String[] args) throws IOException {
- // TODO Auto-generated method stub
- StringTokenizer token;
-
- String ch;
- BufferedReader in = new BufferedReader(new FileReader("input.txt"));
- int indexCount; // size of array index
- ch = in.readLine();
- indexCount = Integer.parseInt(ch); // The first line specifies the size of the operation (= the size of the array)
- System.out.println("Input Data : ");
- System.out.println(indexCount); // number of operations
- Schedule array[] = new Schedule[indexCount]; // Create an array to hold the operation
- int i = 0;
- while ((ch = in.readLine()) != null) {
- token = new StringTokenizer(ch, " ");
- // Include the time required for the operation to be performed in the array and the time it should be completed.
- array[i] = new Schedule(Integer.parseInt(token.nextToken()), Integer.parseInt(token.nextToken()));
- i++; // ë‹¤ìŒ ì¸ë±ìŠ¤
- System.out.println(array[i - 1].t + " " + array[i - 1].d);
- }
-
- int tryTime = 0; // Total time worked
- int lateness = 0; // Lateness
- for (int j = 0; j < indexCount - 1; j++) {
- array[j].s = tryTime; // Start time of the task
- array[j].f = tryTime + array[j].t; // Time finished
- tryTime = tryTime + array[j].t; // Add total work time
- // Lateness
- lateness = lateness + Math.max(0, tryTime - array[j].d);
- }
- System.out.println();
- System.out.println("Output Data : ");
- System.out.println(lateness);
- }
+ private static class Schedule { // Schedule class
+ int t = 0; // Time required for the operation to be performed
+ int d = 0; // Time the job should be completed
+ int s = 0; // Start time of the task
+ int f = 0; // End time of the operation
+
+ public Schedule(int t, int d) {
+ this.t = t;
+ this.d = d;
+ }
+ }
+
+ public static void main(String[] args) throws IOException {
+ StringTokenizer token;
+
+ BufferedReader in = new BufferedReader(new FileReader("MinimizingLateness/lateness_data.txt"));
+ String ch = in.readLine();
+ if (ch == null || ch.isEmpty()) {
+ return;
+ }
+ int indexCount = Integer.parseInt(ch);
+ System.out.println("Input Data : ");
+ System.out.println(indexCount); // number of operations
+ Schedule[] array = new Schedule[indexCount]; // Create an array to hold the operation
+ int i = 0;
+ while ((ch = in.readLine()) != null) {
+ token = new StringTokenizer(ch, " ");
+ // Include the time required for the operation to be performed in the array and the time it should be completed.
+ array[i] = new Schedule(Integer.parseInt(token.nextToken()), Integer.parseInt(token.nextToken()));
+ i++;
+ System.out.println(array[i - 1].t + " " + array[i - 1].d);
+ }
+
+ int tryTime = 0; // Total time worked
+ int lateness = 0; // Lateness
+ for (int j = 0; j < indexCount - 1; j++) {
+ array[j].s = tryTime; // Start time of the task
+ array[j].f = tryTime + array[j].t; // Time finished
+ tryTime = tryTime + array[j].t; // Add total work time
+ // Lateness
+ lateness = lateness + Math.max(0, tryTime - array[j].d);
+ }
+ System.out.println();
+ System.out.println("Output Data : ");
+ System.out.println(lateness);
+ }
}
diff --git a/MinimizingLateness/data06_lateness.txt b/MinimizingLateness/lateness_data.txt
similarity index 100%
rename from MinimizingLateness/data06_lateness.txt
rename to MinimizingLateness/lateness_data.txt
diff --git a/Misc/MedianOfRunningArray.java b/Misc/MedianOfRunningArray.java
new file mode 100644
index 000000000000..32bbf51947a1
--- /dev/null
+++ b/Misc/MedianOfRunningArray.java
@@ -0,0 +1,52 @@
+package Misc;
+
+import java.util.Collections;
+import java.util.PriorityQueue;
+
+
+/**
+ * @author shrutisheoran
+ */
+public class MedianOfRunningArray {
+ private PriorityQueue p1;
+ private PriorityQueue p2;
+
+ //Constructor
+ public MedianOfRunningArray() {
+ this.p1 = new PriorityQueue<>(Collections.reverseOrder()); //Max Heap
+ this.p2 = new PriorityQueue<>(); //Min Heap
+ }
+
+ /*
+ Inserting lower half of array to max Heap
+ and upper half to min heap
+ */
+ public void insert(Integer e) {
+ p2.add(e);
+ if (p2.size() - p1.size() > 1)
+ p1.add(p2.remove());
+ }
+
+ /*
+ Returns median at any given point
+ */
+ public Integer median() {
+ if (p1.size() == p2.size())
+ return (p1.peek() + p2.peek()) / 2;
+ return p1.size() > p2.size() ? p1.peek() : p2.peek();
+ }
+
+ public static void main(String[] args) {
+ /*
+ Testing the median function
+ */
+
+ MedianOfRunningArray p = new MedianOfRunningArray();
+ int arr[] = {10, 7, 4, 9, 2, 3, 11, 17, 14};
+ for (int i = 0; i < 9; i++) {
+ p.insert(arr[i]);
+ System.out.print(p.median() + " ");
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/Misc/PalindromePrime.java b/Misc/PalindromePrime.java
new file mode 100644
index 000000000000..b13a23d83792
--- /dev/null
+++ b/Misc/PalindromePrime.java
@@ -0,0 +1,46 @@
+package Misc;
+
+import java.util.Scanner;
+
+public class PalindromePrime {
+
+ public static void main(String[] args) { // Main funtion
+ Scanner in = new Scanner(System.in);
+ System.out.println("Enter the quantity of First Palindromic Primes you want");
+ int n = in.nextInt(); // Input of how many first pallindromic prime we want
+ functioning(n); // calling function - functioning
+ }
+
+ public static boolean prime(int num) { // checking if number is prime or not
+ for (int divisor = 3; divisor <= Math.sqrt(num); divisor += 2) {
+ if (num % divisor == 0) {
+ return false; // false if not prime
+ }
+ }
+ return true; // True if prime
+ }
+
+ public static int reverse(int n) { // Returns the reverse of the number
+ int reverse = 0;
+ while (n != 0) {
+ reverse *= 10;
+ reverse += n % 10;
+ n /= 10;
+ }
+ return reverse;
+ }
+
+ public static void functioning(int y) {
+ if (y == 0) return;
+ System.out.print(2 + "\n"); // print the first Palindromic Prime
+ int count = 1;
+ int num = 3;
+ while (count < y) {
+ if (num == reverse(num) && prime(num)) { // number is prime and it's reverse is same
+ count++; // counts check when to terminate while loop
+ System.out.print(num + "\n"); // print the Palindromic Prime
+ }
+ num += 2; // inrease iterator value by two
+ }
+ }
+}
diff --git a/Misc/PalindromicPrime.java b/Misc/PalindromicPrime.java
deleted file mode 100644
index 866467206456..000000000000
--- a/Misc/PalindromicPrime.java
+++ /dev/null
@@ -1,41 +0,0 @@
-import java.util.Scanner;
-public class PalindromePrime {
-
- public static void main(String[] args) { // Main funtion
- Scanner in = new Scanner(System.in);
- System.out.println("Enter the quantity of First Palindromic Primes you want");
- int n = in.nextInt(); // Input of how mant first pallindromic prime we want
- funtioning(n); // calling funtion - functioning
- }
-
- public static boolean prime(int num) { // checking if number is prime or not
- for (int divisor = 2; divisor <= num / 2; divisor++) {
- if (num % divisor == 0) {
- return false; // false if not prime
- }
- }
- return true; // True if prime
- }
-
- public static int reverse(int n){ // Returns the reverse of the number
- int reverse = 0;
- while(n!=0){
- reverse = reverse * 10;
- reverse = reverse + n%10;
- n = n/10;
- }
- return reverse;
- }
-
- public static void funtioning(int y){
- int count =0;
- int num = 2;
- while(count < y){
- if(prime(num) && num == reverse(num)){ // number is prime and it's reverse is same
- count++; // counts check when to terminate while loop
- System.out.print(num + "\n"); // Print the Palindromic Prime
- }
- num++; // inrease iterator value by one
- }
- }
-};
diff --git a/Misc/heap_sort.java b/Misc/heap_sort.java
index 991d689ba70f..5222be4093d1 100644
--- a/Misc/heap_sort.java
+++ b/Misc/heap_sort.java
@@ -1,72 +1,67 @@
-public class heap_sort
-{
- public void sort(int arr[])
- {
+package Misc;
+
+public class heap_sort {
+ public void sort(int[] arr) {
int n = arr.length;
-
+
// Build heap (rearrange array)
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
-
+
// One by one extract an element from heap
- for (int i=n-1; i>=0; i--)
- {
+ for (int i = n - 1; i >= 0; i--) {
// Move current root to end
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
-
+
// call max heapify on the reduced heap
heapify(arr, i, 0);
}
}
-
+
// To heapify a subtree rooted with node i which is
// an index in arr[]. n is size of heap
- void heapify(int arr[], int n, int i)
- {
+ void heapify(int[] arr, int n, int i) {
int largest = i; // Initialize largest as root
- int l = 2*i + 1; // left = 2*i + 1
- int r = 2*i + 2; // right = 2*i + 2
-
+ int l = 2 * i + 1; // left = 2*i + 1
+ int r = 2 * i + 2; // right = 2*i + 2
+
// If left child is larger than root
if (l < n && arr[l] > arr[largest])
largest = l;
-
+
// If right child is larger than largest so far
if (r < n && arr[r] > arr[largest])
largest = r;
-
+
// If largest is not root
- if (largest != i)
- {
+ if (largest != i) {
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;
-
+
// Recursively heapify the affected sub-tree
heapify(arr, n, largest);
}
}
-
+
/* A utility function to print array of size n */
- static void printArray(int arr[])
- {
+ static void printArray(int[] arr) {
int n = arr.length;
- for (int i=0; i 0) {
- remainder = number % 10;
- sum = sum + (remainder * remainder * remainder);
- number = number / 10;
- }
- if (sum == temp) {
- return true;
- } else {
- return false;
- }
+ /**
+ * Checks whether a given number is an armstrong number or not. Armstrong
+ * number is a number that is equal to the sum of cubes of its digits for
+ * example 0, 1, 153, 370, 371, 407 etc.
+ *
+ * @param number
+ * @return boolean
+ */
+ public static boolean checkIfANumberIsAmstrongOrNot(int number) {
+ int remainder, sum = 0, temp = 0;
+ temp = number;
+ while (number > 0) {
+ remainder = number % 10;
+ sum = sum + (remainder * remainder * remainder);
+ number = number / 10;
+ }
+ if (sum == temp) {
+ return true;
+ } else {
+ return false;
+ }
+ }
- }
+ private static int inputInt(String string) {
+ System.out.print(string);
+ return Integer.parseInt(scan.nextLine());
+ }
}
\ No newline at end of file
diff --git a/Others/BrianKernighanAlgorithm.java b/Others/BrianKernighanAlgorithm.java
index cb27eec150ef..a35234f0e2af 100644
--- a/Others/BrianKernighanAlgorithm.java
+++ b/Others/BrianKernighanAlgorithm.java
@@ -1,55 +1,49 @@
+package Others;
+
import java.util.Scanner;
/**
- *
* @author Nishita Aggarwal
- *
+ *
* Brian Kernighan’s Algorithm
- *
+ *
* algorithm to count the number of set bits in a given number
- *
+ *
* Subtraction of 1 from a number toggles all the bits (from right to left) till the rightmost set bit(including the
- * rightmost set bit).
- * So if we subtract a number by 1 and do bitwise & with itself i.e. (n & (n-1)), we unset the rightmost set bit.
- *
+ * rightmost set bit).
+ * So if we subtract a number by 1 and do bitwise & with itself i.e. (n & (n-1)), we unset the rightmost set bit.
+ *
* If we do n & (n-1) in a loop and count the no of times loop executes we get the set bit count.
- *
- *
+ *
+ *
* Time Complexity: O(logn)
- *
*/
public class BrianKernighanAlgorithm {
-
- /**
- * @param num: number in which we count the set bits
- *
- * @return int: Number of set bits
- * */
- static int countSetBits(int num)
- {
- int cnt = 0;
- while(num != 0)
- {
- num = num & (num-1);
- cnt++;
- }
- return cnt;
- }
-
-
- /**
- *
- * @param args : command line arguments
- *
- */
- public static void main(String args[])
- {
- Scanner sc = new Scanner(System.in);
- int num = sc.nextInt();
- int setBitCount = countSetBits(num);
- System.out.println(setBitCount);
- sc.close();
- }
+
+ /**
+ * @param num: number in which we count the set bits
+ * @return int: Number of set bits
+ */
+ static int countSetBits(int num) {
+ int cnt = 0;
+ while (num != 0) {
+ num = num & (num - 1);
+ cnt++;
+ }
+ return cnt;
+ }
+
+
+ /**
+ * @param args : command line arguments
+ */
+ public static void main(String args[]) {
+ Scanner sc = new Scanner(System.in);
+ int num = sc.nextInt();
+ int setBitCount = countSetBits(num);
+ System.out.println(setBitCount);
+ sc.close();
+ }
}
diff --git a/Others/CRC32.java b/Others/CRC32.java
new file mode 100644
index 000000000000..80eb3d5c730c
--- /dev/null
+++ b/Others/CRC32.java
@@ -0,0 +1,31 @@
+package Others;
+
+import java.util.BitSet;
+
+/**
+ * Generates a crc32 checksum for a given string or byte array
+ */
+public class CRC32 {
+
+ public static void main(String[] args) {
+ System.out.println(Integer.toHexString(crc32("Hello World")));
+ }
+
+ public static int crc32(String str) {
+ return crc32(str.getBytes());
+ }
+
+ public static int crc32(byte[] data) {
+ BitSet bitSet = BitSet.valueOf(data);
+ int crc32 = 0xFFFFFFFF; // initial value
+ for (int i = 0; i < data.length * 8; i++) {
+ if (((crc32 >>> 31) & 1) != (bitSet.get(i) ? 1 : 0))
+ crc32 = (crc32 << 1) ^ 0x04C11DB7; // xor with polynomial
+ else
+ crc32 = (crc32 << 1);
+ }
+ crc32 = Integer.reverse(crc32); // result reflect
+ return crc32 ^ 0xFFFFFFFF; // final xor value
+ }
+
+}
diff --git a/Others/CRCAlgorithm.java b/Others/CRCAlgorithm.java
new file mode 100644
index 000000000000..d53e3a02c2e3
--- /dev/null
+++ b/Others/CRCAlgorithm.java
@@ -0,0 +1,203 @@
+package Others;
+
+import java.util.ArrayList;
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * @author dimgrichr
+ */
+public class CRCAlgorithm {
+
+ private int correctMess;
+
+ private int wrongMess;
+
+ private int wrongMessCaught;
+
+ private int wrongMessNotCaught;
+
+ private int messSize;
+
+ private double ber;
+
+ private boolean messageChanged;
+
+ private ArrayList message;
+
+ private ArrayList dividedMessage;
+
+ private ArrayList p;
+
+ private Random randomGenerator;
+
+
+ /**
+ * The algorithm's main constructor.
+ * The most significant variables, used in the algorithm,
+ * are set in their initial values.
+ *
+ * @param str The binary number P, in a string form, which is used by the CRC algorithm
+ * @param size The size of every transmitted message
+ * @param ber The Bit Error Rate
+ */
+ public CRCAlgorithm(String str, int size, double ber) {
+ messageChanged = false;
+ message = new ArrayList<>();
+ messSize = size;
+ dividedMessage = new ArrayList<>();
+ p = new ArrayList<>();
+ for (int i = 0; i < str.length(); i++) {
+ p.add(Character.getNumericValue(str.charAt(i)));
+ }
+ randomGenerator = new Random();
+ correctMess = 0;
+ wrongMess = 0;
+ wrongMessCaught = 0;
+ wrongMessNotCaught = 0;
+ this.ber = ber;
+ }
+
+
+ /**
+ * Returns the counter wrongMess
+ *
+ * @return wrongMess, the number of Wrong Messages
+ */
+ public int getWrongMess() {
+ return wrongMess;
+ }
+
+ /**
+ * Returns the counter wrongMessCaught
+ *
+ * @return wrongMessCaught, the number of wrong messages, which are caught by the CRC algoriithm
+ */
+ public int getWrongMessCaught() {
+ return wrongMessCaught;
+ }
+
+ /**
+ * Returns the counter wrongMessNotCaught
+ *
+ * @return wrongMessNotCaught, the number of wrong messages, which are not caught by the CRC algorithm
+ */
+ public int getWrongMessNotCaught() {
+ return wrongMessNotCaught;
+ }
+
+ /**
+ * Returns the counter correctMess
+ *
+ * @return correctMess, the number of the Correct Messages
+ */
+ public int getCorrectMess() {
+ return correctMess;
+ }
+
+ /**
+ * Resets some of the object's values, used on the main function,
+ * so that it can be re-used, in order not to waste too much memory and time,
+ * by creating new objects.
+ */
+ public void refactor() {
+ messageChanged = false;
+ message = new ArrayList<>();
+ dividedMessage = new ArrayList<>();
+ }
+
+ /**
+ * Random messages, consisted of 0's and 1's,
+ * are generated, so that they can later be transmitted
+ */
+ public void generateRandomMess() {
+ for (int i = 0; i < messSize; i++) {
+ int x = ThreadLocalRandom.current().nextInt(0, 2);
+ message.add(x);
+ }
+ }
+
+ /**
+ * The most significant part of the CRC algorithm.
+ * The message is divided by P, so the dividedMessage ArrayList is created.
+ * If check == true, the dividedMessaage is examined, in order to see if it contains any 1's.
+ * If it does, the message is considered to be wrong by the receiver,so the variable wrongMessCaught changes.
+ * If it does not, it is accepted, so one of the variables correctMess, wrongMessNotCaught, changes.
+ * If check == false, the diviided Message is added at the end of the ArrayList message.
+ *
+ * @param check the variable used to determine, if the message is going to be checked from the receiver
+ * if true, it is checked
+ * otherwise, it is not
+ */
+ public void divideMessageWithP(boolean check) {
+ ArrayList x = new ArrayList<>();
+ ArrayList k = (ArrayList) message.clone();
+ if (!check) {
+ for (int i = 0; i < p.size() - 1; i++) {
+ k.add(0);
+ }
+ }
+ while (!k.isEmpty()) {
+ while (x.size() < p.size() && !k.isEmpty()) {
+ x.add(k.get(0));
+ k.remove(0);
+ }
+ if (x.size() == p.size()) {
+ for (int i = 0; i < p.size(); i++) {
+ if (x.get(i) == p.get(i)) {
+ x.set(i, 0);
+ } else {
+ x.set(i, 1);
+ }
+ }
+ for (int i = 0; i < x.size() && x.get(i) != 1; i++) {
+ x.remove(0);
+ }
+ }
+ }
+ dividedMessage = (ArrayList) x.clone();
+ if (!check) {
+ for (int z : dividedMessage) {
+ message.add(z);
+ }
+ } else {
+ if (dividedMessage.contains(1) && messageChanged) {
+ wrongMessCaught++;
+ } else if (!dividedMessage.contains(1) && messageChanged) {
+ wrongMessNotCaught++;
+ } else if (!messageChanged) {
+ correctMess++;
+ }
+ }
+ }
+
+ /**
+ * Once the message is transmitted, some of it's elements,
+ * is possible to change from 1 to 0, or from 0 to 1,
+ * because of the Bit Error Rate (ber).
+ * For every element of the message, a random double number is created.
+ * If that number is smaller than ber, then the spesific element changes.
+ * On the other hand, if it's bigger than ber, it does not.
+ * Based on these changes. the boolean variable messageChanged, gets the value:
+ * true, or false.
+ */
+ public void changeMess() {
+ for (int y : message) {
+ double x = randomGenerator.nextDouble();
+ while (x < 0.0000 || x > 1.00000) {
+ x = randomGenerator.nextDouble();
+ }
+ if (x < ber) {
+ messageChanged = true;
+ if (y == 1) {
+ message.set(message.indexOf(y), 0);
+ } else {
+ message.set(message.indexOf(y), 1);
+ }
+ }
+ }
+ if (messageChanged) {
+ wrongMess++;
+ }
+ }
+}
diff --git a/Others/CountChar.java b/Others/CountChar.java
index 6504aabb4929..217a3be238f8 100644
--- a/Others/CountChar.java
+++ b/Others/CountChar.java
@@ -1,43 +1,44 @@
+package Others;
+
import java.util.Scanner;
/**
* @author Kyler Smith, 2017
- *
+ *
* Implementation of a character count.
* (Slow, could be improved upon, effectively O(n).
- * */
+ */
public class CountChar {
public static void main(String[] args) {
- Scanner input = new Scanner(System.in);
- System.out.print("Enter your text: ");
- String str = input.nextLine();
+ Scanner input = new Scanner(System.in);
+ System.out.print("Enter your text: ");
+ String str = input.nextLine();
input.close();
System.out.println("There are " + CountCharacters(str) + " characters.");
}
-
+
/**
* @param str: String to count the characters
- *
* @return int: Number of characters in the passed string
- * */
+ */
private static int CountCharacters(String str) {
- int count = 0;
+ int count = 0;
- if(str == "" || str == null) //Exceptions
- {
- return 0;
- }
+ if (str == "" || str == null) {
+ return 0;
+ }
- for(int i = 0; i < str.length(); i++) {
- if(!Character.isWhitespace(str.charAt(i))) {
- count++;
- }}
+ for (int i = 0; i < str.length(); i++) {
+ if (!Character.isWhitespace(str.charAt(i))) {
+ count++;
+ }
+ }
return count;
- }
+ }
}
diff --git a/Others/CountWords.java b/Others/CountWords.java
new file mode 100644
index 000000000000..5dc6375597c8
--- /dev/null
+++ b/Others/CountWords.java
@@ -0,0 +1,50 @@
+package Others;
+
+import java.util.Scanner;
+
+/**
+ * You enter a string into this program, and it will return how many words were
+ * in that particular string
+ *
+ * @author Marcus
+ */
+public class CountWords {
+
+ public static void main(String[] args) {
+ Scanner input = new Scanner(System.in);
+ System.out.println("Enter your text: ");
+ String str = input.nextLine();
+
+ System.out.println("Your text has " + wordCount(str) + " word(s)");
+ System.out.println("Your text has " + secondaryWordCount(str) + " word(s)");
+ input.close();
+ }
+
+ private static int wordCount(String s) {
+ if (s == null || s.isEmpty())
+ return 0;
+ return s.trim().split("[\\s]+").length;
+ }
+
+ /**
+ * counts the number of words in a sentence but ignores all potential
+ * non-alphanumeric characters that do not represent a word. runs in O(n) where
+ * n is the length of s
+ *
+ * @param s String: sentence with word(s)
+ * @return int: number of words
+ */
+ private static int secondaryWordCount(String s) {
+ if (s == null || s.isEmpty())
+ return 0;
+ StringBuilder sb = new StringBuilder();
+ for (char c : s.toCharArray()) {
+ if (Character.isLetter(c) || Character.isDigit(c))
+ sb.append(c);
+ }
+ s = sb.toString();
+ return s.trim().split("[\\s]+").length;
+
+ }
+
+}
diff --git a/Others/Dijkshtra.java b/Others/Dijkshtra.java
index 05011dd4212f..c2b1558e88db 100644
--- a/Others/Dijkshtra.java
+++ b/Others/Dijkshtra.java
@@ -1,61 +1,84 @@
-/*
-@author : Mayank K Jha
+package Others;
-*/
-
-
-import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;
+/**
+ * @author Mayank K Jha
+ */
+
public class Dijkshtra {
-public static void main(String[] args) throws IOException {
- Scanner in =new Scanner(System.in);
-
- int n=in.nextInt(); //n = Number of nodes or vertices
- int m=in.nextInt(); //m = Number of Edges
- long w[][]=new long [n+1][n+1]; //Adjacency Matrix
-
- //Initializing Matrix with Certain Maximum Value for path b/w any two vertices
- for (long[] row: w)
- Arrays.fill(row, 1000000l);
- //From above,we Have assumed that,initially path b/w any two Pair of vertices is Infinite such that Infinite = 1000000l
- //For simplicity , We can also take path Value = Long.MAX_VALUE , but i have taken Max Value = 1000000l .
-
- //Taking Input as Edge Location b/w a pair of vertices
- for(int i=0;icmp){ //Comparing previous edge value with current value - Cycle Case
- w[x][y]=cmp; w[y][x]=cmp;
- }
- }
-
- //Implementing Dijkshtra's Algorithm
-
- Stack t=new Stack();
- int src=in.nextInt();
- for(int i=1;i<=n;i++){
- if(i!=src){t.push(i);}}
- Stack p=new Stack();
+ public static void main(String[] args) {
+ Scanner in = new Scanner(System.in);
+
+ // n = Number of nodes or vertices
+ int n = in.nextInt();
+ // m = Number of Edges
+ int m = in.nextInt();
+
+ // Adjacency Matrix
+ long[][] w = new long[n + 1][n + 1];
+
+ // Initializing Matrix with Certain Maximum Value for path b/w any two vertices
+ for (long[] row : w) {
+ Arrays.fill(row, 1000000L);
+ }
+
+ /* From above,we Have assumed that,initially path b/w any two Pair of vertices is Infinite such that Infinite = 1000000l
+ For simplicity , We can also take path Value = Long.MAX_VALUE , but i have taken Max Value = 1000000l */
+
+ // Taking Input as Edge Location b/w a pair of vertices
+ for (int i = 0; i < m; i++) {
+ int x = in.nextInt(), y = in.nextInt();
+ long cmp = in.nextLong();
+
+ // Comparing previous edge value with current value - Cycle Case
+ if (w[x][y] > cmp) {
+ w[x][y] = cmp;
+ w[y][x] = cmp;
+ }
+ }
+
+ // Implementing Dijkshtra's Algorithm
+ Stack t = new Stack<>();
+ int src = in.nextInt();
+
+ for (int i = 1; i <= n; i++) {
+ if (i != src) {
+ t.push(i);
+ }
+ }
+
+ Stack p = new Stack<>();
p.push(src);
- w[src][src]=0;
- while(!t.isEmpty()){int min=989997979,loc=-1;
- for(int i=0;i
+ * NOTE: The inputs to Dijkstra's algorithm are a directed and weighted graph consisting
+ * of 2 or more nodes, generally represented by an adjacency matrix or list, and a start node.
+ *
+ * Original source of code: https://rosettacode.org/wiki/Dijkstra%27s_algorithm#Java
+ * Also most of the comments are from RosettaCode.
+ */
+
+import java.util.*;
+
+public class Dijkstra {
+ private static final Graph.Edge[] GRAPH = {
+ // Distance from node "a" to node "b" is 7.
+ // In the current Graph there is no way to move the other way (e,g, from "b" to "a"),
+ // a new edge would be needed for that
+ new Graph.Edge("a", "b", 7),
+ new Graph.Edge("a", "c", 9),
+ new Graph.Edge("a", "f", 14),
+ new Graph.Edge("b", "c", 10),
+ new Graph.Edge("b", "d", 15),
+ new Graph.Edge("c", "d", 11),
+ new Graph.Edge("c", "f", 2),
+ new Graph.Edge("d", "e", 6),
+ new Graph.Edge("e", "f", 9),
+ };
+ private static final String START = "a";
+ private static final String END = "e";
+
+ /**
+ * main function
+ * Will run the code with "GRAPH" that was defined above.
+ */
+ public static void main(String[] args) {
+ Graph g = new Graph(GRAPH);
+ g.dijkstra(START);
+ g.printPath(END);
+ //g.printAllPaths();
+ }
+}
+
+class Graph {
+ // mapping of vertex names to Vertex objects, built from a set of Edges
+ private final Map graph;
+
+ /**
+ * One edge of the graph (only used by Graph constructor)
+ */
+ public static class Edge {
+ public final String v1, v2;
+ public final int dist;
+
+ public Edge(String v1, String v2, int dist) {
+ this.v1 = v1;
+ this.v2 = v2;
+ this.dist = dist;
+ }
+ }
+
+ /**
+ * One vertex of the graph, complete with mappings to neighbouring vertices
+ */
+ public static class Vertex implements Comparable {
+ public final String name;
+ // MAX_VALUE assumed to be infinity
+ public int dist = Integer.MAX_VALUE;
+ public Vertex previous = null;
+ public final Map neighbours = new HashMap<>();
+
+ public Vertex(String name) {
+ this.name = name;
+ }
+
+ private void printPath() {
+ if (this == this.previous) {
+ System.out.printf("%s", this.name);
+ } else if (this.previous == null) {
+ System.out.printf("%s(unreached)", this.name);
+ } else {
+ this.previous.printPath();
+ System.out.printf(" -> %s(%d)", this.name, this.dist);
+ }
+ }
+
+ public int compareTo(Vertex other) {
+ if (dist == other.dist)
+ return name.compareTo(other.name);
+
+ return Integer.compare(dist, other.dist);
+ }
+
+ @Override
+ public String toString() {
+ return "(" + name + ", " + dist + ")";
+ }
+ }
+
+ /**
+ * Builds a graph from a set of edges
+ */
+ public Graph(Edge[] edges) {
+ graph = new HashMap<>(edges.length);
+
+ // one pass to find all vertices
+ for (Edge e : edges) {
+ if (!graph.containsKey(e.v1)) graph.put(e.v1, new Vertex(e.v1));
+ if (!graph.containsKey(e.v2)) graph.put(e.v2, new Vertex(e.v2));
+ }
+
+ // another pass to set neighbouring vertices
+ for (Edge e : edges) {
+ graph.get(e.v1).neighbours.put(graph.get(e.v2), e.dist);
+ // graph.get(e.v2).neighbours.put(graph.get(e.v1), e.dist); // also do this for an undirected graph
+ }
+ }
+
+ /**
+ * Runs dijkstra using a specified source vertex
+ */
+ public void dijkstra(String startName) {
+ if (!graph.containsKey(startName)) {
+ System.err.printf("Graph doesn't contain start vertex \"%s\"\n", startName);
+ return;
+ }
+ final Vertex source = graph.get(startName);
+ NavigableSet q = new TreeSet<>();
+
+ // set-up vertices
+ for (Vertex v : graph.values()) {
+ v.previous = v == source ? source : null;
+ v.dist = v == source ? 0 : Integer.MAX_VALUE;
+ q.add(v);
+ }
+
+ dijkstra(q);
+ }
+
+ /**
+ * Implementation of dijkstra's algorithm using a binary heap.
+ */
+ private void dijkstra(final NavigableSet q) {
+ Vertex u, v;
+ while (!q.isEmpty()) {
+ // vertex with shortest distance (first iteration will return source)
+ u = q.pollFirst();
+ if (u.dist == Integer.MAX_VALUE)
+ break; // we can ignore u (and any other remaining vertices) since they are unreachable
+
+ // look at distances to each neighbour
+ for (Map.Entry a : u.neighbours.entrySet()) {
+ v = a.getKey(); // the neighbour in this iteration
+
+ final int alternateDist = u.dist + a.getValue();
+ if (alternateDist < v.dist) { // shorter path to neighbour found
+ q.remove(v);
+ v.dist = alternateDist;
+ v.previous = u;
+ q.add(v);
+ }
+ }
+ }
+ }
+
+ /**
+ * Prints a path from the source to the specified vertex
+ */
+ public void printPath(String endName) {
+ if (!graph.containsKey(endName)) {
+ System.err.printf("Graph doesn't contain end vertex \"%s\"\n", endName);
+ return;
+ }
+
+ graph.get(endName).printPath();
+ System.out.println();
+ }
+
+ /**
+ * Prints the path from the source to every vertex (output order is not guaranteed)
+ */
+ public void printAllPaths() {
+ for (Vertex v : graph.values()) {
+ v.printPath();
+ System.out.println();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Others/EulersFunction.java b/Others/EulersFunction.java
new file mode 100644
index 000000000000..0f848442bc92
--- /dev/null
+++ b/Others/EulersFunction.java
@@ -0,0 +1,27 @@
+package Others;
+
+/**
+ * You can read more about Euler's totient function
+ *
+ * See https://en.wikipedia.org/wiki/Euler%27s_totient_function
+ */
+public class EulersFunction {
+ // This method returns us number of x that (x < n) and gcd(x, n) == 1 in O(sqrt(n)) time complexity;
+ public static int getEuler(int n) {
+ int result = n;
+ for (int i = 2; i * i <= n; i++) {
+ if (n % i == 0) {
+ while (n % i == 0) n /= i;
+ result -= result / i;
+ }
+ }
+ if (n > 1) result -= result / n;
+ return result;
+ }
+
+ public static void main(String[] args) {
+ for (int i = 1; i < 100; i++) {
+ System.out.println(getEuler(i));
+ }
+ }
+}
diff --git a/Others/Factorial.java b/Others/Factorial.java
index 11265ec00e12..652607e5107b 100644
--- a/Others/Factorial.java
+++ b/Others/Factorial.java
@@ -1,49 +1,50 @@
+package Others;
+
import java.util.Scanner;
/**
* This program will print out the factorial of any non-negative
* number that you input into it.
- *
- * @author Marcus
*
+ * @author Marcus
*/
-public class Factorial{
+public class Factorial {
+
+ /**
+ * The main method
+ *
+ * @param args Command line arguments
+ */
+ public static void main(String[] args) {
+ Scanner input = new Scanner(System.in);
+ System.out.print("Enter a non-negative integer: ");
- /**
- * The main method
- *
- * @param args Command line arguments
- */
- public static void main(String[] args){
- Scanner input = new Scanner(System.in);
- System.out.print("Enter a non-negative integer: ");
-
- //If user does not enter an Integer, we want program to fail gracefully, letting the user know why it terminated
- try{
+ //If user does not enter an Integer, we want program to fail gracefully, letting the user know why it terminated
+ try {
int number = input.nextInt();
-
- //We keep prompting the user until they enter a positive number
- while(number < 0){
- System.out.println("Your input must be non-negative. Please enter a positive number: ");
- number = input.nextInt();
+
+ //We keep prompting the user until they enter a positive number
+ while (number < 0) {
+ System.out.println("Your input must be non-negative. Please enter a positive number: ");
+ number = input.nextInt();
}
- //Display the result
- System.out.println("The factorial of " + number + " will yield: " + factorial(number));
-
- }catch(Exception e){
+ //Display the result
+ System.out.println("The factorial of " + number + " will yield: " + factorial(number));
+
+ } catch (Exception e) {
System.out.println("Error: You did not enter an integer. Program has terminated.");
- }
- input.close();
}
-
- /**
- * Recursive Factorial Method
- *
- * @param n The number to factorial
- * @return The factorial of the number
- */
- public static long factorial(int n){
- if(n == 0 || n == 1) return 1;
- return n * factorial(n - 1);
- }
+ input.close();
+ }
+
+ /**
+ * Recursive Factorial Method
+ *
+ * @param n The number to factorial
+ * @return The factorial of the number
+ */
+ public static long factorial(int n) {
+ if (n == 0 || n == 1) return 1;
+ return n * factorial(n - 1);
+ }
}
diff --git a/Others/FibToN.java b/Others/FibToN.java
index 1d1efdc1e753..03aad56fd833 100644
--- a/Others/FibToN.java
+++ b/Others/FibToN.java
@@ -1,24 +1,33 @@
+package Others;
+
import java.util.Scanner;
+/**
+ * Fibonacci sequence, and characterized by the fact that every number
+ * after the first two is the sum of the two preceding ones.
+ *
+ * Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21,...
+ *
+ * Source for the explanation: https://en.wikipedia.org/wiki/Fibonacci_number
+ */
+
public class FibToN {
+ public static void main(String[] args) {
+ //take input
+ Scanner scn = new Scanner(System.in);
+ int N = scn.nextInt();
+ // print all Fibonacci numbers that are smaller than your given input N
+ int first = 0, second = 1;
+ scn.close();
+ while (first <= N) {
+ //print first fibo 0 then add second fibo into it while updating second as well
+
+ System.out.println(first);
- public static void main(String[] args) {
- //take input
- Scanner scn = new Scanner(System.in);
- int N = scn.nextInt();
- // print fibonacci sequence less than N
- int first = 0, second = 1;
- //first fibo and second fibonacci are 0 and 1 respectively
- scn.close();
- while(first <= N){
- //print first fibo 0 then add second fibo into it while updating second as well
-
- System.out.println(first);
-
- int next = first+ second;
- first = second;
- second = next;
- }
- }
+ int next = first + second;
+ first = second;
+ second = next;
+ }
+ }
}
diff --git a/Others/FloydTriangle.java b/Others/FloydTriangle.java
index f8d479a8dbac..70479dd24e63 100644
--- a/Others/FloydTriangle.java
+++ b/Others/FloydTriangle.java
@@ -1,17 +1,19 @@
+package Others;
+
import java.util.Scanner;
class FloydTriangle {
public static void main(String[] args) {
- Scanner sc = new Scanner(System.in);
- System.out.println("Enter the number of rows which you want in your Floyd Triangle: ");
- int r = sc.nextInt(), n = 0;
- sc.close();
- for(int i=0; i < r; i++) {
- for(int j=0; j <= i; j++) {
- System.out.print(++n + " ");
- }
- System.out.println();
- }
- }
+ Scanner sc = new Scanner(System.in);
+ System.out.println("Enter the number of rows which you want in your Floyd Triangle: ");
+ int r = sc.nextInt(), n = 0;
+ sc.close();
+ for (int i = 0; i < r; i++) {
+ for (int j = 0; j <= i; j++) {
+ System.out.print(++n + " ");
+ }
+ System.out.println();
+ }
+ }
}
diff --git a/Others/GCD.java b/Others/GCD.java
index 08da3805e9d8..bba2ccf88706 100644
--- a/Others/GCD.java
+++ b/Others/GCD.java
@@ -1,30 +1,42 @@
-//Oskar Enmalm 3/10/17
-//This is Euclid's algorithm which is used to find the greatest common denominator
-//Overide function name gcd
-
-public class GCD{
-
- public static int gcd(int num1, int num2) {
-
- int gcdValue = num1 % num2;
- while (gcdValue != 0) {
- num2 = gcdValue;
- gcdValue = num2 % gcdValue;
+package Others;
+
+/**
+ * This is Euclid's algorithm which is used to find the greatest common denominator
+ * Overide function name gcd
+ *
+ * @author Oskar Enmalm 3/10/17
+ */
+public class GCD {
+
+ public static int gcd(int num1, int num2) {
+
+ if (num1 == 0)
+ return num2;
+
+ while (num2 != 0) {
+ if (num1 > num2)
+ num1 -= num2;
+ else
+ num2 -= num1;
}
- return num2;
+
+ return num1;
}
- public static int gcd(int[] number) {
- int result = number[0];
- for(int i = 1; i < number.length; i++)
- //call gcd function (input two value)
- result = gcd(result, number[i]);
-
- return result;
- }
-
- public static void main(String[] args) {
- int[] myIntArray = {4,16,32};
- //call gcd function (input array)
- System.out.println(gcd(myIntArray));
+
+ public static int gcd(int[] number) {
+ int result = number[0];
+ for (int i = 1; i < number.length; i++)
+ // call gcd function (input two value)
+ result = gcd(result, number[i]);
+
+ return result;
+ }
+
+ public static void main(String[] args) {
+ int[] myIntArray = {4, 16, 32};
+
+ // call gcd function (input array)
+ System.out.println(gcd(myIntArray)); // => 4
+ System.out.printf("gcd(40,24)=%d gcd(24,40)=%d\n", gcd(40, 24), gcd(24, 40)); // => 8
}
}
diff --git a/Others/GuassLegendre.java b/Others/GuassLegendre.java
new file mode 100644
index 000000000000..409f626478ba
--- /dev/null
+++ b/Others/GuassLegendre.java
@@ -0,0 +1,46 @@
+package Others;
+
+import java.lang.Math;
+
+/**
+ * Guass Legendre Algorithm
+ * ref https://en.wikipedia.org/wiki/Gauss–Legendre_algorithm
+ *
+ * @author AKS1996
+ */
+public class GuassLegendre {
+
+ public static void main(String[] args) {
+ for (int i = 1; i <= 3; ++i)
+ System.out.println(pi(i));
+
+ }
+
+ static double pi(int l) {
+ /*
+ * l: No of loops to run
+ */
+
+ double a = 1, b = Math.pow(2, -0.5), t = 0.25, p = 1;
+ for (int i = 0; i < l; ++i) {
+ double temp[] = update(a, b, t, p);
+ a = temp[0];
+ b = temp[1];
+ t = temp[2];
+ p = temp[3];
+ }
+
+ return Math.pow(a + b, 2) / (4 * t);
+ }
+
+ static double[] update(double a, double b, double t, double p) {
+ double values[] = new double[4];
+ values[0] = (a + b) / 2;
+ values[1] = Math.sqrt(a * b);
+ values[2] = t - p * Math.pow(a - values[0], 2);
+ values[3] = 2 * p;
+
+ return values;
+ }
+
+}
diff --git a/Others/GuassLengendre.java b/Others/GuassLengendre.java
deleted file mode 100644
index 289516aee3ea..000000000000
--- a/Others/GuassLengendre.java
+++ /dev/null
@@ -1,44 +0,0 @@
-import java.lang.Math;
-/*
- * author: @AKS1996
- * Guass Legendre Algorithm
- * ref https://en.wikipedia.org/wiki/Gauss–Legendre_algorithm
- *
- */
-
-public class GuassLegendre {
-
- public static void main(String[] args) {
- for(int i=1;i<=3;++i)
- System.out.println(pi(i));
-
- }
-
- static double pi(int l){
- /*
- * l: No of loops to run
- */
-
- double a = 1,b=Math.pow(2,-0.5),t=0.25,p=1;
- for(int i=0;i{
- @Override
- public int compare(Node o1, Node o2) {
- if(o1.freq>o2.freq){return 1;}
- else if(o1.freq it=li.iterator();
- while(it.hasNext()){Node n=it.next();System.out.print(n.freq+" ");}System.out.println();
- }
-
- //Function for making tree (Huffman Tree)
- public static Node make_huffmann_tree(List li){
- //Sorting list in increasing order of its letter frequency
- li.sort(new comp());
- Node temp=null;
- Iterator it=li.iterator();
- //System.out.println(li.size());
- //Loop for making huffman tree till only single node remains in list
- while(true){
- temp=new Node();
- //a and b are Node which are to be combine to make its parent
- Node a=new Node(),b=new Node();
- a=null;b=null;
- //checking if list is eligible for combining or not
- //here first assignment of it.next in a will always be true as list till end will
- //must have atleast one node
- a=(Node)it.next();
- //Below condition is to check either list has 2nd node or not to combine
- //If this condition will be false, then it means construction of huffman tree is completed
- if(it.hasNext()){b=(Node)it.next();}
- //Combining first two smallest nodes in list to make its parent whose frequncy
- //will be equals to sum of frequency of these two nodes
- if(b!=null){
- temp.freq=a.freq+b.freq;a.data=0;b.data=1;//assigining 0 and 1 to left and right nodes
- temp.left=a;temp.right=b;
- //after combing, removing first two nodes in list which are already combined
- li.remove(0);//removes first element which is now combined -step1
- li.remove(0);//removes 2nd element which comes on 1st position after deleting first in step1
- li.add(temp);//adding new combined node to list
- //print_list(li); //For visualizing each combination step
- }
- //Sorting after combining to again repeat above on sorted frequency list
- li.sort(new comp());
- it=li.iterator();//resetting list pointer to first node (head/root of tree)
- if(li.size()==1){return (Node)it.next();} //base condition ,returning root of huffman tree
- }
-}
-
- //Function for finding path between root and given letter ch
- public static void dfs(Node n,String ch){
- Stack st=new Stack(); // stack for storing path
- int freq=n.freq; // recording root freq to avoid it adding in path encoding
- find_path_and_encode(st,n,ch,freq);
- }
-
- //A simple utility function to print stack (Used for printing path)
- public static void print_path(Stack st){
- for(int i=0;i st,Node root,String s,int f){
- //Base condition
- if(root!= null){
- if(root.freq!=f){st.push(root);} // avoiding root to add in path/encoding bits
- if(root.letr.equals(s)){print_path(st);return;} // Recursion stopping condition when path gets founded
- find_path_and_encode(st,root.left,s,f);
- find_path_and_encode(st,root.right,s,f);
- //Popping if path not found in right or left of this node,because we previously
- //pushed this node in taking a mindset that it might be in path
- st.pop();
- }
- }
-
- public static void main(String args[]){
- List li=new LinkedList<>();
- Scanner in=new Scanner(System.in);
- System.out.println("Enter number of distinct letters ");
- int n=in.nextInt();
- String s[]=new String[n];
- System.out.print("Enter letters with its frequncy to encode\n");
- for(int i=0;i 0 && T.charAt(i) != P.charAt(q)) {
- q = pi[q - 1];
+ while (q > 0 && haystack.charAt(i) != needle.charAt(q)) {
+ q = pi[q - 1];
}
- if (T.charAt(i) == P.charAt(q)) {
+ if (haystack.charAt(i) == needle.charAt(q)) {
q++;
}
if (q == n) {
System.out.println("Pattern starts: " + (i + 1 - n));
- q = pi[q - 1];
+ q = pi[q - 1];
}
}
-
}
- // return the prefix function
- private int[] computePrefixFunction(final String P) {
+ // return the prefix function
+ private static int[] computePrefixFunction(final String P) {
final int n = P.length();
final int[] pi = new int[n];
pi[0] = 0;
@@ -49,7 +52,6 @@ private int[] computePrefixFunction(final String P) {
pi[i] = q;
}
-
return pi;
}
-}
+}
\ No newline at end of file
diff --git a/Others/Krishnamurthy.java b/Others/Krishnamurthy.java
new file mode 100644
index 000000000000..f2f3533a7549
--- /dev/null
+++ b/Others/Krishnamurthy.java
@@ -0,0 +1,30 @@
+package Others;
+
+import java.util.Scanner;
+
+class Krishnamurthy {
+ static int fact(int n) {
+ int i, p = 1;
+ for (i = n; i >= 1; i--)
+ p = p * i;
+ return p;
+ }
+
+ public static void main(String args[]) {
+ Scanner sc = new Scanner(System.in);
+ int a, b, s = 0;
+ System.out.print("Enter the number : ");
+ a = sc.nextInt();
+ int n = a;
+ while (a > 0) {
+ b = a % 10;
+ s = s + fact(b);
+ a = a / 10;
+ }
+ if (s == n)
+ System.out.print(n + " is a krishnamurthy number");
+ else
+ System.out.print(n + " is not a krishnamurthy number");
+ sc.close();
+ }
+}
diff --git a/Others/LinearCongruentialGenerator.java b/Others/LinearCongruentialGenerator.java
index b03c10daec2a..7ce224e0e9fe 100644
--- a/Others/LinearCongruentialGenerator.java
+++ b/Others/LinearCongruentialGenerator.java
@@ -1,56 +1,59 @@
+package Others;
+
/***
* A pseudorandom number generator.
- *
+ *
* @author Tobias Carryer
- * Date: October 10, 2017
+ * @date October 10, 2017
*/
public class LinearCongruentialGenerator {
private double a, c, m, previousValue;
-
+
/***
* These parameters are saved and used when nextNumber() is called.
* The current timestamp in milliseconds is used as the seed.
- *
+ *
* @param multiplier
* @param increment
* @param modulo The maximum number that can be generated (exclusive). A common value is 2^32.
*/
- public LinearCongruentialGenerator( double multiplier, double increment, double modulo ) {
+ public LinearCongruentialGenerator(double multiplier, double increment, double modulo) {
this(System.currentTimeMillis(), multiplier, increment, modulo);
}
-
+
/***
* These parameters are saved and used when nextNumber() is called.
- *
+ *
* @param seed
* @param multiplier
* @param increment
* @param modulo The maximum number that can be generated (exclusive). A common value is 2^32.
*/
- public LinearCongruentialGenerator( double seed, double multiplier, double increment, double modulo ) {
+ public LinearCongruentialGenerator(double seed, double multiplier, double increment, double modulo) {
this.previousValue = seed;
this.a = multiplier;
this.c = increment;
this.m = modulo;
}
-
+
/**
* The smallest number that can be generated is zero.
* The largest number that can be generated is modulo-1. modulo is set in the constructor.
+ *
* @return a pseudorandom number.
*/
public double nextNumber() {
previousValue = (a * previousValue + c) % m;
return previousValue;
}
-
- public static void main( String[] args ) {
+
+ public static void main(String[] args) {
// Show the LCG in action.
// Decisive proof that the LCG works could be made by adding each number
// generated to a Set while checking for duplicates.
LinearCongruentialGenerator lcg = new LinearCongruentialGenerator(1664525, 1013904223, Math.pow(2.0, 32.0));
- for( int i = 0; i < 512; i++ ) {
+ for (int i = 0; i < 512; i++) {
System.out.println(lcg.nextNumber());
}
}
diff --git a/Others/LowestBasePalindrome.java b/Others/LowestBasePalindrome.java
index d0df5c30f511..97b445b2ff61 100644
--- a/Others/LowestBasePalindrome.java
+++ b/Others/LowestBasePalindrome.java
@@ -1,144 +1,146 @@
+package Others;
+
import java.util.InputMismatchException;
import java.util.Scanner;
/**
* Class for finding the lowest base in which a given integer is a palindrome.
* Includes auxiliary methods for converting between bases and reversing strings.
- *
+ *
* NOTE: There is potential for error, see note at line 63.
- *
+ *
* @author RollandMichael
* @version 2017.09.28
- *
*/
public class LowestBasePalindrome {
-
- public static void main(String[] args) {
- Scanner in = new Scanner(System.in);
- int n=0;
- while (true) {
- try {
- System.out.print("Enter number: ");
- n = in.nextInt();
- break;
- } catch (InputMismatchException e) {
- System.out.println("Invalid input!");
- in.next();
- }
- }
- System.out.println(n+" is a palindrome in base "+lowestBasePalindrome(n));
- System.out.println(base2base(Integer.toString(n),10, lowestBasePalindrome(n)));
- }
-
- /**
- * Given a number in base 10, returns the lowest base in which the
- * number is represented by a palindrome (read the same left-to-right
- * and right-to-left).
- * @param num A number in base 10.
- * @return The lowest base in which num is a palindrome.
- */
- public static int lowestBasePalindrome(int num) {
- int base, num2=num;
- int digit;
- char digitC;
- boolean foundBase=false;
- String newNum = "";
- String digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
- while (!foundBase) {
- // Try from bases 2 to num-1
- for (base=2; base0) {
- // Obtain the first digit of n in the current base,
- // which is equivalent to the integer remainder of (n/base).
- // The next digit is obtained by dividing n by the base and
- // continuing the process of getting the remainder. This is done
- // until n is <=0 and the number in the new base is obtained.
- digit = (num % base);
- num/=base;
- // If the digit isn't in the set of [0-9][A-Z] (beyond base 36), its character
- // form is just its value in ASCII.
-
- // NOTE: This may cause problems, as the capital letters are ASCII values
- // 65-90. It may cause false positives when one digit is, for instance 10 and assigned
- // 'A' from the character array and the other is 65 and also assigned 'A'.
-
- // Regardless, the character is added to the representation of n
- // in the current base.
- if (digit>=digits.length()) {
- digitC=(char)(digit);
- newNum+=digitC;
- continue;
- }
- newNum+=digits.charAt(digit);
- }
- // Num is assigned back its original value for the next iteration.
- num=num2;
- // Auxiliary method reverses the number.
- String reverse = reverse(newNum);
- // If the number is read the same as its reverse, then it is a palindrome.
- // The current base is returned.
- if (reverse.equals(newNum)) {
- foundBase=true;
- return base;
- }
- }
- }
- // If all else fails, n is always a palindrome in base n-1. ("11")
- return num-1;
- }
-
- private static String reverse(String str) {
- String reverse = "";
- for(int i=str.length()-1; i>=0; i--) {
- reverse += str.charAt(i);
- }
- return reverse;
- }
-
- private static String base2base(String n, int b1, int b2) {
- // Declare variables: decimal value of n,
- // character of base b1, character of base b2,
- // and the string that will be returned.
- int decimalValue = 0, charB2;
- char charB1;
- String output="";
- // Go through every character of n
- for (int i=0; i9 and store it in charB2
- if (charB1 >= 'A' && charB1 <= 'Z')
- charB2 = 10 + (charB1 - 'A');
- // Else, store the integer value in charB2
- else
- charB2 = charB1 - '0';
- // Convert the digit to decimal and add it to the
- // decimalValue of n
- decimalValue = decimalValue * b1 + charB2;
- }
-
- // Converting the decimal value to base b2:
- // A number is converted from decimal to another base
- // by continuously dividing by the base and recording
- // the remainder until the quotient is zero. The number in the
- // new base is the remainders, with the last remainder
- // being the left-most digit.
-
- // While the quotient is NOT zero:
- while (decimalValue != 0) {
- // If the remainder is a digit < 10, simply add it to
- // the left side of the new number.
- if (decimalValue % b2 < 10)
- output = Integer.toString(decimalValue % b2) + output;
- // If the remainder is >= 10, add a character with the
- // corresponding value to the new number. (A = 10, B = 11, C = 12, ...)
- else
- output = (char)((decimalValue % b2)+55) + output;
- // Divide by the new base again
- decimalValue /= b2;
- }
- return output;
- }
+
+ public static void main(String[] args) {
+ Scanner in = new Scanner(System.in);
+ int n = 0;
+ while (true) {
+ try {
+ System.out.print("Enter number: ");
+ n = in.nextInt();
+ break;
+ } catch (InputMismatchException e) {
+ System.out.println("Invalid input!");
+ in.next();
+ }
+ }
+ System.out.println(n + " is a palindrome in base " + lowestBasePalindrome(n));
+ System.out.println(base2base(Integer.toString(n), 10, lowestBasePalindrome(n)));
+ }
+
+ /**
+ * Given a number in base 10, returns the lowest base in which the
+ * number is represented by a palindrome (read the same left-to-right
+ * and right-to-left).
+ *
+ * @param num A number in base 10.
+ * @return The lowest base in which num is a palindrome.
+ */
+ public static int lowestBasePalindrome(int num) {
+ int base, num2 = num;
+ int digit;
+ char digitC;
+ boolean foundBase = false;
+ String newNum = "";
+ String digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+ while (!foundBase) {
+ // Try from bases 2 to num-1
+ for (base = 2; base < num2; base++) {
+ newNum = "";
+ while (num > 0) {
+ // Obtain the first digit of n in the current base,
+ // which is equivalent to the integer remainder of (n/base).
+ // The next digit is obtained by dividing n by the base and
+ // continuing the process of getting the remainder. This is done
+ // until n is <=0 and the number in the new base is obtained.
+ digit = (num % base);
+ num /= base;
+ // If the digit isn't in the set of [0-9][A-Z] (beyond base 36), its character
+ // form is just its value in ASCII.
+
+ // NOTE: This may cause problems, as the capital letters are ASCII values
+ // 65-90. It may cause false positives when one digit is, for instance 10 and assigned
+ // 'A' from the character array and the other is 65 and also assigned 'A'.
+
+ // Regardless, the character is added to the representation of n
+ // in the current base.
+ if (digit >= digits.length()) {
+ digitC = (char) (digit);
+ newNum += digitC;
+ continue;
+ }
+ newNum += digits.charAt(digit);
+ }
+ // Num is assigned back its original value for the next iteration.
+ num = num2;
+ // Auxiliary method reverses the number.
+ String reverse = reverse(newNum);
+ // If the number is read the same as its reverse, then it is a palindrome.
+ // The current base is returned.
+ if (reverse.equals(newNum)) {
+ foundBase = true;
+ return base;
+ }
+ }
+ }
+ // If all else fails, n is always a palindrome in base n-1. ("11")
+ return num - 1;
+ }
+
+ private static String reverse(String str) {
+ String reverse = "";
+ for (int i = str.length() - 1; i >= 0; i--) {
+ reverse += str.charAt(i);
+ }
+ return reverse;
+ }
+
+ private static String base2base(String n, int b1, int b2) {
+ // Declare variables: decimal value of n,
+ // character of base b1, character of base b2,
+ // and the string that will be returned.
+ int decimalValue = 0, charB2;
+ char charB1;
+ String output = "";
+ // Go through every character of n
+ for (int i = 0; i < n.length(); i++) {
+ // store the character in charB1
+ charB1 = n.charAt(i);
+ // if it is a non-number, convert it to a decimal value >9 and store it in charB2
+ if (charB1 >= 'A' && charB1 <= 'Z')
+ charB2 = 10 + (charB1 - 'A');
+ // Else, store the integer value in charB2
+ else
+ charB2 = charB1 - '0';
+ // Convert the digit to decimal and add it to the
+ // decimalValue of n
+ decimalValue = decimalValue * b1 + charB2;
+ }
+
+ // Converting the decimal value to base b2:
+ // A number is converted from decimal to another base
+ // by continuously dividing by the base and recording
+ // the remainder until the quotient is zero. The number in the
+ // new base is the remainders, with the last remainder
+ // being the left-most digit.
+
+ // While the quotient is NOT zero:
+ while (decimalValue != 0) {
+ // If the remainder is a digit < 10, simply add it to
+ // the left side of the new number.
+ if (decimalValue % b2 < 10)
+ output = Integer.toString(decimalValue % b2) + output;
+ // If the remainder is >= 10, add a character with the
+ // corresponding value to the new number. (A = 10, B = 11, C = 12, ...)
+ else
+ output = (char) ((decimalValue % b2) + 55) + output;
+ // Divide by the new base again
+ decimalValue /= b2;
+ }
+ return output;
+ }
}
diff --git a/Others/Node.java b/Others/Node.java
deleted file mode 100644
index ab495b77de01..000000000000
--- a/Others/Node.java
+++ /dev/null
@@ -1,16 +0,0 @@
-public class Node {
- public Object anElement;
- public Node less;
- public Node greater;
-
- public Node(Object theElement) {
- this(theElement, null, null); //an empty node at the end will be by itself with no children, therefore the other 2 parameters are always null
- //obviously the node can still be a child of other elements
- }
-
- public Node(Object currentElement, Node lessSide, Node greaterSide) {
- anElement = currentElement;
- this.less = lessSide;
- this.greater = greaterSide;
- }
-}
diff --git a/Others/Palindrome.java b/Others/Palindrome.java
index 0bbddb7544c8..af4a72fdede3 100644
--- a/Others/Palindrome.java
+++ b/Others/Palindrome.java
@@ -1,26 +1,50 @@
+package Others;
+
class Palindrome {
-
- private String reverseString(String x){ //*helper method
- String output = "";
- for(int i=x.length()-1; i>=0; i--){
- output += x.charAt(i); //addition of chars create String
- }
- return output;
- }
-
-
- public Boolean FirstWay(String x){ //*palindrome method, returns true if palindrome
- return (x.equalsIgnoreCase(reverseString(x)));
- }
-
- public boolean SecondWay(String x)
- {
- if (x.length() == 0 || x.length() == 1)
- return true;
-
- if (x.charAt(0) != x.charAt(x.length() - 1))
- return false;
-
- return SecondWay(x.substring(1 , x.length() - 1));
- }
- }
+
+ private String reverseString(String x) { // *helper method
+ StringBuilder output = new StringBuilder(x);
+ return output.reverse().toString();
+ }
+
+ public boolean FirstWay(String x) { // *palindrome method, returns true if palindrome
+ if (x == null || x.length() <= 1)
+ return true;
+ return x.equalsIgnoreCase(reverseString(x));
+ }
+
+ public boolean SecondWay(String x) {
+ if (x.length() == 0 || x.length() == 1)
+ return true;
+
+ if (x.charAt(0) != x.charAt(x.length() - 1))
+ return false;
+
+ return SecondWay(x.substring(1, x.length() - 1));
+ }
+
+ /**
+ * This method ignores all non-alphanumeric characters and case runs in O(n)
+ * where n is the length of s
+ *
+ * @param s String to check
+ * @return true if s is palindrome else false
+ */
+ public boolean isPalindrome(String s) {
+ s = s.toLowerCase().trim();
+ StringBuilder sb = new StringBuilder();
+ for (char c : s.toCharArray()) {
+ if (Character.isLetter(c) || Character.isDigit(c))
+ sb.append(c);
+ }
+ s = sb.toString();
+ int start = 0;
+ int end = s.length() - 1;
+ while (start <= end) {
+ if (s.charAt(start++) != s.charAt(end--))
+ return false;
+
+ }
+ return true;
+ }
+}
diff --git a/Others/PasswordGen.java b/Others/PasswordGen.java
index bde0a50fe621..8d49e6c65633 100644
--- a/Others/PasswordGen.java
+++ b/Others/PasswordGen.java
@@ -1,23 +1,25 @@
+package Others;
+
import java.util.Collections;
import java.util.Random;
import java.util.List;
import java.util.ArrayList;
-/*
- Creates a random password from ASCII letters
- Given password length bounds
-
- author: AKS1996
- date: 2017-10-25
-*/
+/**
+ * Creates a random password from ASCII letters
+ * Given password length bounds
+ *
+ * @author AKS1996
+ * @date 2017.10.25
+ */
class PasswordGen {
- public static void main(String args[]){
- String password = generatePassword(8,16);
- System.out.print("Password: " + password);
+ public static void main(String args[]) {
+ String password = generatePassword(8, 16);
+ System.out.print("Password: " + password);
}
-
- static String generatePassword(int min_length, int max_length){
+
+ static String generatePassword(int min_length, int max_length) {
Random random = new Random();
String upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ -25,10 +27,10 @@ static String generatePassword(int min_length, int max_length){
String numbers = "0123456789";
String specialChars = "!@#$%^&*(){}?";
- String allChars = upper+lower+numbers+specialChars;
+ String allChars = upper + lower + numbers + specialChars;
List letters = new ArrayList();
- for(char c:allChars.toCharArray())
+ for (char c : allChars.toCharArray())
letters.add(c);
// Inbuilt method to randomly shuffle a elements of a list
@@ -36,7 +38,7 @@ static String generatePassword(int min_length, int max_length){
String password = "";
// Note that size of the password is also random
- for(int i = random.nextInt(max_length-min_length) + min_length; i>0; --i) {
+ for (int i = random.nextInt(max_length - min_length) + min_length; i > 0; --i) {
password += letters.get(random.nextInt(letters.size()));
}
diff --git a/Others/PerlinNoise.java b/Others/PerlinNoise.java
index 1d0f795a3a35..dbd0a86e4512 100644
--- a/Others/PerlinNoise.java
+++ b/Others/PerlinNoise.java
@@ -1,3 +1,5 @@
+package Others;
+
import java.util.Random;
import java.util.Scanner;
@@ -6,11 +8,11 @@
*/
public class PerlinNoise {
/**
- * @param width width of noise array
- * @param height height of noise array
+ * @param width width of noise array
+ * @param height height of noise array
* @param octaveCount numbers of layers used for blending noise
* @param persistence value of impact each layer get while blending
- * @param seed used for randomizer
+ * @param seed used for randomizer
* @return float array containing calculated "Perlin-Noise" values
*/
static float[][] generatePerlinNoise(int width, int height, int octaveCount, float persistence, long seed) {
@@ -20,14 +22,14 @@ static float[][] generatePerlinNoise(int width, int height, int octaveCount, flo
Random random = new Random(seed);
//fill base array with random values as base for noise
- for(int x = 0; x < width; x++) {
- for(int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ for (int y = 0; y < height; y++) {
base[x][y] = random.nextFloat();
}
}
//calculate octaves with different roughness
- for(int octave = 0; octave < octaveCount; octave++) {
+ for (int octave = 0; octave < octaveCount; octave++) {
noiseLayers[octave] = generatePerlinNoiseLayer(base, width, height, octave);
}
@@ -35,12 +37,12 @@ static float[][] generatePerlinNoise(int width, int height, int octaveCount, flo
float totalAmplitude = 0f;
//calculate perlin noise by blending each layer together with specific persistence
- for(int octave = octaveCount - 1; octave >= 0; octave--) {
+ for (int octave = octaveCount - 1; octave >= 0; octave--) {
amplitude *= persistence;
totalAmplitude += amplitude;
- for(int x = 0; x < width; x++) {
- for(int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ for (int y = 0; y < height; y++) {
//adding each value of the noise layer to the noise
//by increasing amplitude the rougher noises will have more impact
perlinNoise[x][y] += noiseLayers[octave][x][y] * amplitude;
@@ -49,7 +51,7 @@ static float[][] generatePerlinNoise(int width, int height, int octaveCount, flo
}
//normalize values so that they stay between 0..1
- for(int x = 0; x < width; x++) {
+ for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
perlinNoise[x][y] /= totalAmplitude;
}
@@ -59,8 +61,8 @@ static float[][] generatePerlinNoise(int width, int height, int octaveCount, flo
}
/**
- * @param base base random float array
- * @param width width of noise array
+ * @param base base random float array
+ * @param width width of noise array
* @param height height of noise array
* @param octave current layer
* @return float array containing calculated "Perlin-Noise-Layer" values
@@ -72,13 +74,13 @@ static float[][] generatePerlinNoiseLayer(float[][] base, int width, int height,
int period = 1 << octave; //2^k
float frequency = 1f / period; // 1/2^k
- for(int x = 0; x < width; x++) {
+ for (int x = 0; x < width; x++) {
//calculates the horizontal sampling indices
int x0 = (x / period) * period;
int x1 = (x0 + period) % width;
float horizintalBlend = (x - x0) * frequency;
- for(int y = 0; y < height; y++) {
+ for (int y = 0; y < height; y++) {
//calculates the vertical sampling indices
int y0 = (y / period) * period;
int y1 = (y0 + period) % height;
@@ -99,8 +101,8 @@ static float[][] generatePerlinNoiseLayer(float[][] base, int width, int height,
}
/**
- * @param a value of point a
- * @param b value of point b
+ * @param a value of point a
+ * @param b value of point b
* @param alpha determine which value has more impact (closer to 0 -> a, closer to 1 -> b)
* @return interpolated value
*/
@@ -143,8 +145,8 @@ public static void main(String[] args) {
final int length = chars.length;
final float step = 1f / length;
//output based on charset
- for(int x = 0; x < width; x++) {
- for(int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ for (int y = 0; y < height; y++) {
float value = step;
float noiseValue = perlinNoise[x][y];
diff --git a/Others/PowerOfTwoOrNot.java b/Others/PowerOfTwoOrNot.java
index 36facfeddb76..349eb9de5807 100644
--- a/Others/PowerOfTwoOrNot.java
+++ b/Others/PowerOfTwoOrNot.java
@@ -1,33 +1,36 @@
+package Others;
+
import java.util.Scanner;
/**
-*A utility to check if a given number is power of two or not.
-*For example 8,16 etc.
-*/
+ * A utility to check if a given number is power of two or not.
+ * For example 8,16 etc.
+ */
+
public class PowerOfTwoOrNot {
-
- public static void main (String[] args) {
-
- Scanner sc = new Scanner(System.in);
- System.out.println("Enter the number");
- int num = sc.nextInt();
- boolean isPowerOfTwo = checkIfPowerOfTwoOrNot(num);
- if (isPowerOfTwo) {
- System.out.println("Number is a power of two");
- } else {
- System.out.println("Number is not a power of two");
- }
- }
+ public static void main(String[] args) {
-/**
-* Checks whether given number is power of two or not.
-*
-* @param number
-* @return boolean
-*/
-public static boolean checkIfPowerOfTwoOrNot(int number) {
- return number != 0 && ((number & (number-1)) == 0);
- }
+ Scanner sc = new Scanner(System.in);
+ System.out.println("Enter the number");
+ int num = sc.nextInt();
+ boolean isPowerOfTwo = checkIfPowerOfTwoOrNot(num);
+ if (isPowerOfTwo) {
+ System.out.println("Number is a power of two");
+ } else {
+ System.out.println("Number is not a power of two");
+ }
+ }
+
+
+ /**
+ * Checks whether given number is power of two or not.
+ *
+ * @param number
+ * @return boolean
+ */
+ public static boolean checkIfPowerOfTwoOrNot(int number) {
+ return number != 0 && ((number & (number - 1)) == 0);
+ }
}
diff --git a/Others/QueueUsingTwoStacks.java b/Others/QueueUsingTwoStacks.java
index 271c35c1859d..d138f71aabfb 100644
--- a/Others/QueueUsingTwoStacks.java
+++ b/Others/QueueUsingTwoStacks.java
@@ -1,3 +1,5 @@
+package Others;
+
import java.util.Stack;
/**
diff --git a/Others/removeDuplicateFromString.java b/Others/RemoveDuplicateFromString.java
similarity index 71%
rename from Others/removeDuplicateFromString.java
rename to Others/RemoveDuplicateFromString.java
index ce8f3499cede..2e4b11285c89 100644
--- a/Others/removeDuplicateFromString.java
+++ b/Others/RemoveDuplicateFromString.java
@@ -1,19 +1,19 @@
+package Others;
+
import java.io.BufferedReader;
import java.io.InputStreamReader;
/**
- *
* @author Varun Upadhyay (https://github.com/varunu28)
- *
*/
-public class removeDuplicateFromString {
- public static void main (String[] args) throws Exception{
+public class RemoveDuplicateFromString {
+ public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
- String inp_str = br.readLine();
+ String inpStr = br.readLine();
- System.out.println("Actual string is: " + inp_str);
- System.out.println("String after removing duplicates: " + removeDuplicate(inp_str));
+ System.out.println("Actual string is: " + inpStr);
+ System.out.println("String after removing duplicates: " + removeDuplicate(inpStr));
br.close();
}
@@ -21,17 +21,18 @@ public static void main (String[] args) throws Exception{
/**
* This method produces a string after removing all the duplicate characters from input string and returns it
* Example: Input String - "aabbbccccddddd"
- * Output String - "abcd"
+ * Output String - "abcd"
+ *
* @param s String from which duplicate characters have to be removed
* @return string with only unique characters
*/
public static String removeDuplicate(String s) {
- if(s.isEmpty() || s == null) {
+ if (s == null || s.isEmpty()) {
return s;
}
- StringBuilder sb = new StringBuilder("");
+ StringBuilder sb = new StringBuilder();
int n = s.length();
for (int i = 0; i < n; i++) {
diff --git a/Others/ReturnSubsequence.java b/Others/ReturnSubsequence.java
index ef3aaed09dd9..bb1b413afd1d 100644
--- a/Others/ReturnSubsequence.java
+++ b/Others/ReturnSubsequence.java
@@ -1,58 +1,41 @@
-/*
-This program will return all the subsequences of the input string in a string array;
-Sample Input:
-abc
-Sample Output:
-"" ( Empty String )
-c
-b
-bc
-a
-ac
-ab
-abc
-
- */
+package Others;
import java.util.Scanner;
public class ReturnSubsequence {
- /*
- Main function will accept the given string and implement return subsequences function
- */
public static void main(String[] args) {
System.out.println("Enter String: ");
- Scanner s=new Scanner(System.in);
- String givenString=s.next(); //given string
- String[] subsequence=returnSubsequence(givenString); //calling returnSubsequence() function
+ Scanner s = new Scanner(System.in);
+ String givenString = s.next(); //given string
+ String[] subsequence = returnSubsequence(givenString); //calling returnSubsequence() function
System.out.println("Subsequences : ");
- for(int i=0;i stack=new Stack<>();
+ private static Stack stack = new Stack<>();
//Main function
public static void main(String[] args) {
//To Create a Dummy Stack containing integers from 0-9
- for(int i=0;i<10;i++)
- {
+ for (int i = 0; i < 10; i++) {
stack.push(i);
}
System.out.println("STACK");
//To print that dummy Stack
- for(int k=9;k>=0;k--)
- {
+ for (int k = 9; k >= 0; k--) {
System.out.println(k);
}
@@ -28,8 +28,7 @@ public static void main(String[] args) {
System.out.println("REVERSED STACK : ");
//To print reversed stack
- while (!stack.isEmpty())
- {
+ while (!stack.isEmpty()) {
System.out.println(stack.pop());
}
@@ -38,13 +37,13 @@ public static void main(String[] args) {
//Function Used to reverse Stack Using Recursion
private static void reverseUsingRecursion(Stack stack) {
- if(stack.isEmpty()) // If stack is empty then return
+ if (stack.isEmpty()) // If stack is empty then return
{
return;
}
/* All items are stored in call stack until we reach the end*/
- int temptop=stack.peek();
+ int temptop = stack.peek();
stack.pop();
reverseUsingRecursion(stack); //Recursion call
insertAtEnd(temptop); // Insert items held in call stack one by one into stack
@@ -52,11 +51,9 @@ private static void reverseUsingRecursion(Stack stack) {
//Function used to insert element at the end of stack
private static void insertAtEnd(int temptop) {
- if(stack.isEmpty())
- {
+ if (stack.isEmpty()) {
stack.push(temptop); // If stack is empty push the element
- }
- else {
+ } else {
int temp = stack.peek(); /* All the items are stored in call stack until we reach end*/
stack.pop();
diff --git a/Others/ReverseString.java b/Others/ReverseString.java
index 9f4d9775bb43..76bbfb5da93a 100644
--- a/Others/ReverseString.java
+++ b/Others/ReverseString.java
@@ -1,46 +1,46 @@
+package Others;
+
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* This method produces a reversed version of a string
- *
- * @author Unknown
*
+ * @author Unknown
*/
-class ReverseString
-{
-
- /**
- * This method reverses the string str and returns it
- * @param str String to be reversed
- * @return Reversed string
- */
- public static String reverse(String str){
- if(str.isEmpty() || str == null) return str;
-
- char arr[] = str.toCharArray();
- for(int i = 0, j = str.length() - 1; i < j; i++, j--){
+public class ReverseString {
+
+ /**
+ * This method reverses the string str and returns it
+ *
+ * @param str String to be reversed
+ * @return Reversed string
+ */
+ public static String reverse(String str) {
+ if (str == null || str.isEmpty()) return str;
+
+ char[] arr = str.toCharArray();
+ for (int i = 0, j = str.length() - 1; i < j; i++, j--) {
char temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
- }
- return new String(arr);
}
-
- /**
- * Main Method
- *
- * @param args Command line arguments
- * @throws IOException Exception thrown because of BufferedReader
- */
- public static void main(String args[]) throws IOException
- {
- BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
- System.out.println("Enter the string");
- String srr=br.readLine();
- System.out.println("Reverse="+reverse(srr));
- br.close();
- }
+ return new String(arr);
+ }
+
+ /**
+ * Main Method
+ *
+ * @param args Command line arguments
+ * @throws IOException Exception thrown because of BufferedReader
+ */
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ System.out.println("Enter the string");
+ String srr = br.readLine();
+ System.out.println("Reverse=" + reverse(srr));
+ br.close();
+ }
}
diff --git a/Others/RootPrecision.java b/Others/RootPrecision.java
index b792d692f675..388f1b2ec7b6 100644
--- a/Others/RootPrecision.java
+++ b/Others/RootPrecision.java
@@ -1,33 +1,34 @@
-import java.io.*;
-import java.util.*;
-import java.text.*;
-import java.math.*;
-import java.util.regex.*;
+package Others;
+
+import java.util.Scanner;
public class RootPrecision {
public static void main(String[] args) {
- //take input
- Scanner scn = new Scanner(System.in);
-
- int N = scn.nextInt(); //N is the input number
- int P = scn.nextInt(); //P is precision value for eg - P is 3 in 2.564 and 5 in 3.80870.
-
- System.out.println(squareRoot(N, P));
- }
-
- public static double squareRoot(int N, int P) {
- double rv = 0; //rv means return value
-
+ // take input
+ Scanner scn = new Scanner(System.in);
+
+ // N is the input number
+ int N = scn.nextInt();
+
+ // P is precision value for eg - P is 3 in 2.564 and 5 in 3.80870.
+ int P = scn.nextInt();
+ System.out.println(squareRoot(N, P));
+ }
+
+ public static double squareRoot(int N, int P) {
+ // rv means return value
+ double rv;
+
double root = Math.pow(N, 0.5);
-
- //calculate precision to power of 10 and then multiply it with root value.
- int precision = (int) Math.pow(10, P);
- root = root * precision;
- /*typecast it into integer then divide by precision and again typecast into double
- so as to have decimal points upto P precision */
-
- rv = (int)root;
- return (double)rv/precision;
- }
-}
+
+ // calculate precision to power of 10 and then multiply it with root value.
+ int precision = (int) Math.pow(10, P);
+ root = root * precision;
+ /*typecast it into integer then divide by precision and again typecast into double
+ so as to have decimal points upto P precision */
+
+ rv = (int) root;
+ return rv / precision;
+ }
+}
\ No newline at end of file
diff --git a/Others/SJF.java b/Others/SJF.java
new file mode 100644
index 000000000000..e6b995f4846c
--- /dev/null
+++ b/Others/SJF.java
@@ -0,0 +1,181 @@
+package Others;
+/**
+ * Shortest job first.
+ * Shortest job first (SJF) or shortest job next, is a scheduling policy
+ * that selects the waiting process with the smallest execution time to execute next
+ * Shortest Job first has the advantage of having minimum average waiting time among all scheduling algorithms.
+ * It is a Greedy Algorithm.
+ * It may cause starvation if shorter processes keep coming.
+ * This problem has been solved using the concept of aging.
+ *
+ * @author shivg7706
+ * @since 2018/10/27
+ */
+
+import java.util.Scanner;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.*;
+
+class Process {
+
+ public int pid;
+ public int arrivalTime;
+ public int burstTime;
+ public int priority;
+ public int turnAroundTime;
+ public int waitTime;
+ public int remainingTime;
+}
+
+class Schedule {
+
+ private int noOfProcess;
+ private int timer = 0;
+ private ArrayList processes;
+ private ArrayList remainingProcess;
+ private ArrayList gantChart;
+ private float burstAll;
+ private Map> arrivals;
+
+ Schedule() {
+ Scanner in = new Scanner(System.in);
+
+ processes = new ArrayList();
+ remainingProcess = new ArrayList();
+
+ gantChart = new ArrayList<>();
+ arrivals = new HashMap<>();
+
+ System.out.print("Enter the no. of processes: ");
+ noOfProcess = in.nextInt();
+ System.out.println("Enter the arrival, burst and priority of processes");
+ for (int i = 0; i < noOfProcess; i++) {
+ Process p = new Process();
+ p.pid = i;
+ p.arrivalTime = in.nextInt();
+ p.burstTime = in.nextInt();
+ p.priority = in.nextInt();
+ p.turnAroundTime = 0;
+ p.waitTime = 0;
+ p.remainingTime = p.burstTime;
+
+ if (arrivals.get(p.arrivalTime) == null) {
+ arrivals.put(p.arrivalTime, new ArrayList