Java Programs

Author: learning-zone

java-programs/AddTwoNumbersRepresentedByLinkedList.java

@@ -0,0 +1,120 @@
+package misc;
+
+/**
+ * Algorithm: 
+ * 1. Create two linked list which will represent two numbers. 
+ * 2. Reverse both linked list. 
+ * 3. Add two node values (Each node is being represented as single digit) starting from heads of two linkedlist. 
+ * 4. If sum is of above two node values is more than 10, then forward the carry.
+ * 
+ */
+public class AddTwoNumbersRepresentedByLinkedList {
+
+	private static Node head;
+
+	private static class Node {
+		private int value;
+		private Node next;
+
+		Node(int value) {
+			this.value = value;
+		}
+	}
+
+	public void addToTheLast(Node node) {
+		if (head == null) {
+			head = node;
+		} else {
+			Node temp = head;
+			while (temp.next != null)
+				temp = temp.next;
+
+			temp.next = node;
+		}
+	}
+
+	public void printList(Node printNode) {
+		Node temp = printNode;
+		while (temp != null) {
+			System.out.format("%d ", temp.value);
+			temp = temp.next;
+		}
+		System.out.println();
+	}
+
+	public static Node reverseLinkedList(Node node) {
+		if (node == null || node.next == null) {
+			return node;
+		}
+		Node remaining = reverseLinkedList(node.next);
+		node.next.next = node;
+		node.next = null;
+		return remaining;
+	}
+
+	// This function will do sum of numbers represented by linked list
+	public Node findSumOfNumbers(Node l1, Node l2) {
+		int carry = 0;
+		Node newHead = null;
+		Node tempNodeForIteration = null;
+		int sum = 0;
+		int firstIter = 0;
+		while (l1 != null || l2 != null) {
+			firstIter++;
+			sum = carry;
+			if (l1 != null) {
+				sum = sum + l1.value;
+				l1 = l1.next;
+			}
+			if (l2 != null) {
+				sum = sum + l2.value;
+				l2 = l2.next;
+			}
+			carry = sum / 10;
+			sum = sum % 10;
+			// Check if it first node for the result
+			if (firstIter == 1) {
+				tempNodeForIteration = new Node(sum);
+				newHead = tempNodeForIteration;
+			} else {
+				Node tempSumNode = new Node(sum);
+				tempNodeForIteration.next = tempSumNode;
+				tempNodeForIteration = tempNodeForIteration.next;
+			}
+		}
+		if (carry != 0) {
+			Node tempNode = new Node(carry);
+			tempNodeForIteration.next = tempNode;
+		}
+		return newHead;
+	}
+
+	public static void main(String[] args) {
+		AddTwoNumbersRepresentedByLinkedList list = new AddTwoNumbersRepresentedByLinkedList();
+
+		Node head1 = new Node(5);
+		list.addToTheLast(head1);
+		list.addToTheLast(new Node(6));
+		list.addToTheLast(new Node(7));
+		list.addToTheLast(new Node(1));
+		list.addToTheLast(new Node(2));
+		System.out.print("Number 1:  ");
+		list.printList(head1);
+		head = null;
+		Node head2 = new Node(6);
+		list.addToTheLast(head2);
+		list.addToTheLast(new Node(3));
+		list.addToTheLast(new Node(5));
+		list.addToTheLast(new Node(9));
+		System.out.print("Number 2:  ");
+		list.printList(head2);
+		head1 = reverseLinkedList(head1);
+		head2 = reverseLinkedList(head2);
+
+		// function to find sum of two linkedlist represent by number
+		Node result = list.findSumOfNumbers(head1, head2);
+		result = reverseLinkedList(result);
+		System.out.print("Sum:  ");
+		list.printList(result);
+	}
+}

java-programs/ArrayListToArray.java

@@ -0,0 +1,24 @@
+package misc;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class ArrayListToArray {
+
+	public static void main(String[] args) {
+		List<String> list = new ArrayList<>();
+		list.add("Apple");
+		list.add("Banana");
+		list.add("Mango");
+		System.out.println("Converting ArrayList to Array: ");
+		String[] item = list.toArray(new String[list.size()]);
+		for (String s : item) {
+			System.out.println(s);
+		}
+		System.out.println("Converting Array to ArrayList: ");
+		List<String> list2 = new ArrayList<>();
+		list2 = Arrays.asList(item);
+		System.out.println(list2);
+	}
+}

java-programs/ArraySort.java

@@ -0,0 +1,17 @@
+package misc;
+import java.util.Arrays;
+/**
+ * Note:-
+ * java.util.Arrays uses quicksort for primitive types such as int and 
+ * mergesort for objects that implement Comparable or use a Comparator.
+ */
+public class ArraySort {
+
+	public static void main(String[] args) {
+		String[] countries = {"India","United States","Malaysia","Australia","Lundon"};
+		Arrays.sort(countries);
+		for(int i = 0; i < countries.length; i++) {
+			System.out.println(countries[i]);
+		}
+	}
+}

java-programs/BinarySearchTreeImpl.java

@@ -0,0 +1,93 @@
+package misc;
+/**
+ * Note:- In BST all the nodes in the left sub-tree of the root node should be
+ * less than or equals to the data of the root. The data of all the nodes in the
+ * right subtree of the root node should be greater than the data of the root.
+ *
+ */
+public class BinarySearchTreeImpl {
+
+	public class BSTNode {
+
+		private BSTNode left;
+		private BSTNode right;
+		private Integer data;
+
+		public BSTNode(Integer data) {
+			this.data = data;
+		}
+
+		public BSTNode getLeft() {
+			return left;
+		}
+
+		public void setLeft(BSTNode left) {
+			this.left = left;
+		}
+
+		public BSTNode getRight() {
+			return right;
+		}
+
+		public void setRight(BSTNode right) {
+			this.right = right;
+		}
+
+		public Integer getData() {
+			return data;
+		}
+	}
+
+	private BSTNode root;
+
+	public boolean isEmpty() {
+		return (this.root == null);
+	}
+
+	public void insert(Integer data) {
+		System.out.print("[input: " + data + "]");
+		if (root == null) {
+			this.root = new BSTNode(data);
+			System.out.println(" -> inserted: " + data);
+			return;
+		}
+		insertNode(this.root, data);
+		System.out.println(" -> inserted: " + data);
+		System.out.println();
+	}
+
+	private BSTNode insertNode(BSTNode root, Integer data) {
+		BSTNode tmpNode = null;
+		System.out.print(" -> " + root.getData());
+		if (root.getData() >= data) {
+			System.out.print(" [L]");
+			if (root.getLeft() == null) {
+				root.setLeft(new BSTNode(data));
+				return root.getLeft();
+			} else {
+				System.out.println(" [R]");
+			}
+
+		} else {
+			System.out.print(" [R]");
+			if (root.getRight() == null) {
+				root.setRight(new BSTNode(data));
+				return root.getRight();
+			} else {
+				tmpNode = root.getRight();
+			}
+		}
+		return insertNode(tmpNode, data);
+	}
+
+	public static void main(String[] args) {
+		BinarySearchTreeImpl bst = new BinarySearchTreeImpl();
+		bst.insert(50);
+		bst.insert(30);
+		bst.insert(20);
+		bst.insert(40);
+		bst.insert(70);
+		bst.insert(60);
+		bst.insert(80);
+	}
+}

java-programs/BubbleSort.java

@@ -0,0 +1,38 @@
+package misc;
+/**
+ * Steps:- 
+ * Bubble Sort algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order.
+ * 
+ */
+public class BubbleSort {
+
+	public void bubbleSort(int[] arr) {
+		int n = arr.length;
+		int tmp = 0;
+		for (int i = 0; i < n ; i++) {
+			for (int j = 1; j < n-1; j++) {
+				if (arr[j-1] > arr[j]) {
+					tmp = arr[j - 1];
+					arr[j-1] = arr[j];
+					arr[j] = tmp;
+				}
+			}
+		}
+	}
+
+	void printArray(int arr[]) {
+		for (int i = 0; i < arr.length; i++) {
+			System.out.print(arr[i] + " ");
+		}
+		System.out.println("");
+	}
+
+	public static void main(String[] args) {
+		BubbleSort obj = new BubbleSort();
+		int arr[] = { 64, 34, 25, 12, 22, 11, 90 };
+
+		obj.bubbleSort(arr);
+		System.out.println("Sorted Array");
+		obj.printArray(arr);
+	}
+}

java-programs/BucketSort.java

@@ -0,0 +1,33 @@
+package misc;
+import java.util.Arrays;
+/**
+ * Bucket Sort is also known as bin sort. 
+ * It works by distributing the element into the array also called buckets.
+ * 
+ */
+public class BucketSort {
+
+	public static int[] bucketSort(int[] arr) {
+		int i, j;
+		int[] bucket = new int[arr.length + 1];
+		Arrays.fill(bucket, 0);
+		
+		for(i = 0; i < arr.length;  i++) {
+			bucket[arr[i]]++;
+		}
+		int k = 0;
+		for(i = 0; i <= arr.length; i++) {
+			for(j = 0; j < bucket[i]; j++) {
+				arr[k++] = i;
+			}
+		}
+		return arr;
+	}
+	public static void main(String[] args) {
+		int[] num = {3, 6, 1, 7, 2, 8, 10, 4, 9, 5};
+		bucketSort(num);
+		for(int i = 0; i < num.length; i++) {
+			System.out.print(num[i] + " ");
+		}
+	}
+}

java-programs/CheckNumberInString.java

@@ -0,0 +1,15 @@
+package misc;
+
+public class CheckNumberInString {
+
+	public static void main(String[] args) {
+		String str = "Lorem Ipsum has been the industry's standard dummy text ever since the 1500s.";
+		Boolean flag = false;		
+		for(int i = 0; i < str.length(); i++) {
+			flag = Character.isDigit(str.charAt(i));
+			if(flag) {
+				System.out.println(str + "\n ==> contains number"); break;
+			} 
+		}
+	}
+}

java-programs/CollectionSort.java

@@ -0,0 +1,29 @@
+package misc;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+/**
+ * Java Program to Sort a List using Collections.Sort methods 
+ * This implementation uses merge sort.
+ *
+ */
+public class CollectionSort {
+
+	public static void main(String[] args) {
+		
+		List<String> list = new ArrayList<>();
+		list.add("India");
+		list.add("India");
+		list.add("United States");
+		list.add("Malaysia");
+		list.add("Australia");
+		list.add("Lundon");
+		
+		Collections.sort(list);
+		Iterator<String> itr = list.iterator();
+		while(itr.hasNext()) {
+			System.out.println(itr.next());
+		}
+	}
+}

java-programs/ConvertArrayListToStringArray.java

@@ -0,0 +1,22 @@
+package misc;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ConvertArrayListToStringArray {
+	public static void main(String args[]) {
+		List<String> list = new ArrayList<String>();
+		
+		list.add("One");
+		list.add("Two");
+		list.add("Three");
+		list.add("Four");
+		list.add("Five");
+		
+		String[] stringArrayObject = new String[list.size()];
+		list.toArray(stringArrayObject);
+		
+		for(String str: stringArrayObject) {
+			System.out.print(str + ", ");
+		}
+	}
+}