Algorithms Documentation [Java]

Author: TawfikYasser

algorithms/Java/README.md

@@ -0,0 +1,55 @@
+# Python
+
+## Arrays
+1. [Count Inversions](arrays/count-inversions.java)
+2. [Kadanes Algorithm](arrays/Kadanes_Algorithm.java)
+3. [Left Rotation](arrays/left_rotation.java)
+4. [Unique Digits of Large Number](arrays/unique-digits-of-large-number.java)
+
+## Graphs
+1. [Dijkstras](graphs/Dijkstras.java)
+
+## Linked Lists
+1. [Circular](linked-lists/circular.java)
+2. [Clone Linked List](linked-lists/clone-linkedlist-with-rnd-pointer.java)
+3. [Doubly](linked-lists/doubly.java)
+4. [Reverse](linked-lists/reverse.java)
+5. [Singly](linked-lists/singly.java)
+
+## Queues
+1. [Circular Queue using Linked List](queues/circular-queue-linked-list.java)
+2. [Queue using Linked List](queues/queue-linked-list.java)
+
+## Scheduling
+1. [Multi-Level Queue Scheduling](scheduling/multi-level-queue-scheduling.java)
+2. [Rund Robin](scheduling/round-robin.java)
+
+## Searching
+1. [Binary Search](searching/binary-search.java)
+2. [Jump Search](searching/jump-search.java)
+3. [Linear Search](searching/linear-search.java)
+
+## Sorting
+1. [Bubble Sort](sorting/bubble-sort.java)
+2. [Counting Sort](sorting/counting-sort.java)
+3. [Heap Sort](sorting/heap-sort.java)
+4. [Insertion Sort](sorting/insertion-sort.java)
+5. [Merge Sort](sorting/merge-sort.java)
+6. [Quick Sort](sorting/quick-sort.java)
+7. [Selection Sort](sorting/selection-sort.java)
+
+## Stacks
+1. [Balanced Paranthesis](stacks/balanced-paranthesis.java)
+2. [Stack](stacks/stack.java)
+3. [The Stock Span Problem](stacks/the-stock-span-problem.java)
+
+## Strings
+1. [KMP](strings/kmp.java)
+2. [Palindrome](strings/palindrome.java)
+3. [Rabin Krap](strings/rabin-karp.java)
+4. [Sequence](strings/sequence.java)
+5. [Split String](strings/SplitString.java)
+6. [Tokenizer](strings/tokenizer.java)
+
+## Trees
+1. [Pre in Post Traversal](trees/pre_in_post_traversal.java)

algorithms/Java/arrays/Kadanes_Algorithm.java

@@ -0,0 +1,30 @@
+// Java program to print largest contiguous array sum
+
+import java.io.*;
+import java.util.*;
+ 
+class Kadane
+{
+    public static void main (String[] args)
+    {
+        int [] a = {-2, -3, 4, -1, -2, 1, 5, -3};
+        System.out.println("Maximum contiguous sum is " +
+                                       maxSubArraySum(a));
+    }
+ 
+    static int maxSubArraySum(int a[])
+    {
+        int size = a.length;
+        int max_so_far = Integer.MIN_VALUE, max_ending_here = 0;
+ 
+        for (int i = 0; i < size; i++)
+        {
+            max_ending_here = max_ending_here + a[i];
+            if (max_so_far < max_ending_here)
+                max_so_far = max_ending_here;
+            if (max_ending_here < 0)
+                max_ending_here = 0;
+        }
+        return max_so_far;
+    }
+}

algorithms/Java/arrays/count-inversions.java

@@ -0,0 +1,59 @@
+// Algorithm Type: Divide & Conquer
+// Time Complexity: O(n*log(n))
+
+import java.io.File;
+import java.lang.reflect.Array;
+import java.util.*;
+
+public class inversions {
+  private static long count_split_inv(int[] arr, int[] left, int[] right) {
+    long split_inv = 0;
+    int ridx = 0, lidx = 0;
+    int size = arr.length;
+    int rsize = right.length;
+    int lsize = left.length;
+    for (int i = 0; i < size; i++) {
+      if (lidx != lsize && ridx != rsize) {
+        if (right[ridx] <= left[lidx]) {
+          arr[i] = right[ridx];
+          ridx++;
+          split_inv += lsize - lidx;
+        } else {
+          arr[i] = left[lidx];
+          lidx++;
+        }
+      } else if (lidx == lsize) {
+        arr[i] = right[ridx];
+        ridx++;
+      } else if (ridx == rsize) {
+        arr[i] = left[lidx];
+        lidx++;
+      }
+    }
+    return split_inv;
+  }
+
+  private static long count_inversions(int[] arr) {
+    int size = arr.length;
+    if (size == 1) {
+      return 0;
+    }
+    int[] left = Arrays.copyOfRange(arr, 0, size / 2);
+    int[] right = Arrays.copyOfRange(arr, size / 2, size);
+    long left_inv = count_inversions(left);
+    long right_inv = count_inversions(right);
+    long split_inv = count_split_inv(arr, left, right);
+
+    return left_inv + right_inv + split_inv;
+  }
+
+  public static void main(String[] args) {
+    try {
+      int[] arr = {8, 2, 1, 5, 7, 3, 9, 2, 0, 1};
+      System.out.println(count_inversions(arr));
+    } catch (Exception e) {
+      System.out.println("Err... ");
+    }
+
+  }
+}

algorithms/Java/arrays/left_rotation.java

@@ -0,0 +1,51 @@
+public class left_rotation{
+
+    public static void rotateToLeft(int [] arr){
+        if(arr == null || arr.length == 0){
+            System.out.println("no rotation possible");
+            return;
+        }
+        //take the first element
+        int firstElement = arr[0];
+        //move everything in the left
+        for(int i = 0; i < arr.length -1; i++){
+            arr[i] = arr[i + 1];
+        }
+        //the first element become the last element
+        arr[arr.length - 1] = firstElement;
+    }
+
+    public static void print(int [] arr){
+        System.out.print("[");
+        for(int i = 0; i < arr.length; i++)
+            System.out.print(arr[i] + ", ");
+        System.out.println("]");
+    }
+
+    public static void main(String [] args){
+        int [] arr = {1,2,3,4,5,6,7,8,9};
+        int n = 3;  //number of times to rotate the array
+
+        System.out.print("before: ");
+        print(arr);
+
+        System.out.println("rotating " + n + " times to left");
+        for(int i = 0; i < n; i++)
+            rotateToLeft(arr);  //move to left n times
+
+        System.out.print("after: ");
+        print(arr);
+    }
+}
+
+/*
+    to run the file:
+        javac left_rotation.java
+        java left_rotation
+    
+    result:
+        before: [1, 2, 3, 4, 5, 6, 7, 8, 9, ]
+        rotating 3 times to left
+        after: [4, 5, 6, 7, 8, 9, 1, 2, 3, ]
+        
+*/

algorithms/Java/arrays/unique-digits-of-large-number.java

@@ -0,0 +1,62 @@
+import java.util.*;
+public class UniqueDigitsOfLargeNumber {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		Scanner sc=new Scanner(System.in);
+		int l,i,j,l1=0;
+		String s,p="";
+		char c,d;
+		System.out.println("Enter a large number");
+		s=sc.nextLine();
+		l=s.length();
+		for(i=0;i<l;i++)
+		{
+			c=s.charAt(i);
+			for(j=0;j<l1;j++)
+			{
+				if(p.charAt(j)==c)
+					break;
+			}
+			if(j==l1)
+			{
+				p=p+c;
+				l1=p.length();
+			}
+		}
+			System.out.print("The unique digits present in "+Long.parseLong(s)+" are ");
+			if(l1>1)
+			{
+				for(i=0;i<l1-1;i++)
+				{
+					System.out.print(p.charAt(i)+", ");
+				}
+				System.out.println("and "+p.charAt(l1-1)+".");
+				c=p.charAt(0);
+				for(i=0;i<l1;i++)
+				{
+					if(p.charAt(i)>c)
+						c=p.charAt(i);
+				}
+				s="";
+				s=s+c;
+				c--;
+				for(d=c;d>='0';d--)
+				{
+					for(i=0;i<l1;i++)
+					{
+						if(p.charAt(i)==d)
+							s=s+d;
+					}
+				}
+				System.out.println("The largest number possible out of these unique digits is "+Long.parseLong(s));
+			}
+			else
+			{
+				System.out.println(p.charAt(0)+".");
+				System.out.println("The largest number possible out of these unique digits is "+Integer.parseInt(p));
+			}
+		
+	}
+
+}

algorithms/Java/graphs/Dijkstras.java

@@ -0,0 +1,133 @@
+import java.util.*;
+
+class AdjListNode
+{
+	int dest;
+	int weight;
+	AdjListNode(int dest,int weight)
+	{
+		this.dest=dest;
+		this.weight=weight;
+	}
+}
+
+class NodeComparator implements Comparator<AdjListNode>
+{
+	@Override
+	public int compare(AdjListNode node1, AdjListNode node2) 
+	{		
+		if (node1.weight < node2.weight) 
+            		return -1; 
+        	if (node1.weight > node2.weight) 
+            		return 1; 
+        	return 0; 
+	}
+}
+
+class Dijkstras
+{
+	public int[] dijkstras(List<List<AdjListNode>> adj_list,int source)
+	{
+		int[] distance = new int[adj_list.size()];
+		Set<Integer> completed = new HashSet<Integer>();
+		for(int i=0;i<distance.length;++i)
+		{
+			distance[i] = Integer.MAX_VALUE;
+		}
+		PriorityQueue<AdjListNode> pq = new PriorityQueue<>(adj_list.size(),new NodeComparator());
+		AdjListNode source_node = new AdjListNode(source,0);
+		for(int i=0;i<distance.length;++i)
+		{
+			pq.add(new AdjListNode(i,Integer.MAX_VALUE));
+			
+		}
+		pq.add(source_node);
+		distance[source]=0;
+		while(!pq.isEmpty())
+		{
+			AdjListNode current = pq.remove();
+			if(!completed.contains(current.dest))
+			{
+				completed.add(current.dest);
+				for(AdjListNode n :adj_list.get(current.dest) )
+				{
+					if( distance[n.dest] > (distance[current.dest]+n.weight))
+					{
+						distance[n.dest] = distance[current.dest]+n.weight;
+						pq.add(new AdjListNode(n.dest, distance[n.dest]));
+					}
+				}
+			}
+		}
+		return distance;
+	}
+
+	public static void main(String args[])
+	{
+		/*
+		  	SAMPLE INPUT AND OUTPUT
+			___________________________
+
+			Input:
+			__________
+			Please enter the number of nodes N. Vertices will be [0,N-1]
+			6
+			Please Enter the number of Edges
+			9
+			Please enter each edge in the sequence <starting node> <destination node> <weight>
+			0 1 1
+			0 2 5
+			1 2 2
+			1 4 1
+			1 3 2
+			2 4 2
+			3 5 1
+			3 4 3
+			4 5 2
+			Please enter source vertex
+			0
+
+			Output:
+			___________
+			Distances from source 0
+			Node0--->0
+			Node1--->1
+			Node2--->3
+			Node3--->3
+			Node4--->2
+			Node5--->4
+		 */
+
+		List<List<AdjListNode>> adj_list = new ArrayList<List<AdjListNode>>();
+		System.out.println("Please enter the number of nodes N. Vertices will be [0,N-1]");
+		Scanner sc = new Scanner(System.in);
+		int v = sc.nextInt();
+		for(int i=0;i<v;++i)
+			adj_list.add(new ArrayList<AdjListNode>());
+		
+		System.out.println("Please enter the number of edges");
+		int e = sc.nextInt();
+		System.out.println("Please enter each edge in the sequence <starting node> <destination node> <weight>");
+		// Sample Data: 0 2 5 (edge from 0 to 2 with weight 5)
+		for(int i=0;i<e;++i)
+		{
+			int startnode = sc.nextInt();
+			int destnode = sc.nextInt();
+			int weight = sc.nextInt();
+		       	adj_list.get(startnode).add(new AdjListNode(destnode,weight));
+		}
+		int source;
+		System.out.println("Please enter source vertex");
+		source = sc.nextInt();
+		Dijkstras d = new Dijkstras();
+		int[] distances  = d.dijkstras(adj_list, source);  //source vertex is taken as 0
+		System.out.println("Distances from source "+source);
+		for(int i=0;i<distances.length;++i)
+		{
+			if(distances[i]==Integer.MAX_VALUE)
+				System.out.println("Node"+i+"--->"+"infinity");
+			else
+				System.out.println("Node"+i+"--->"+distances[i]);
+		}
+	}
+}