First 50 questions

Author: onufryk

src/com/onufryk/exercise/Question044.java

@@ -0,0 +1,56 @@
+package com.onufryk.exercise;
+
+import com.onufryk.exercise.struct.LinkedList;
+import com.onufryk.exercise.struct.Node;
+
+public class Question044 {
+	
+	public static class SingleEntryList extends LinkedList {
+		public void deduplicate() {
+			if (this.root == null) {
+				return;
+			}
+			Node previous = null;
+			Node cursor = this.root;
+			while (cursor != null) {
+				Node next = cursor.getNext();
+				
+				if (next != null && cursor.getValue() == next.getValue()) {
+					Integer duplicatedValue = cursor.getValue();
+					Node deleteMe = cursor;
+					while (deleteMe != null && deleteMe.getValue() == duplicatedValue) {
+						next = deleteMe.getNext();
+						deleteMe = null;
+						deleteMe = next;
+					}
+					if (previous == null) {
+						this.root = next;
+					} else {
+						previous.setNext(next);
+					}
+					cursor = next;
+				} else {
+					previous = cursor;
+					cursor = cursor.getNext();
+				}
+				
+			}
+			
+		}
+		
+	}
+
+	public static void main(String[] args) throws Exception {
+		Node root = new Node(1, new Node(2, new Node(3, new Node (3, new Node(4, new Node(4, new Node (5)))))));
+		SingleEntryList list = new SingleEntryList();
+		list.init(root);
+		
+		list.print();
+		
+		list.deduplicate();
+		
+		list.print();
+
+	}
+
+}

src/com/onufryk/exercise/Question045.java

@@ -0,0 +1,60 @@
+package com.onufryk.exercise;
+
+public class Question045 {
+	public int[] numbers = null;
+
+	public interface Criterion {
+		public boolean check(int number);
+	}
+
+	public Question045(int[] numbers) {
+		this.numbers = numbers;
+	}
+
+	public void reorder(Criterion criterion) {
+		int begin = 0;
+		int end = this.numbers.length - 1;
+		while (begin < end) {
+			while (begin < end && !criterion.check(this.numbers[begin])) {
+				begin++;
+			}
+			while (begin < end && criterion.check(this.numbers[end])) {
+				end--;
+			}
+			if (begin < end) {
+				int temp = this.numbers[begin];
+				this.numbers[begin] = this.numbers[end];
+				this.numbers[end] = temp;
+			}
+
+		}
+	}
+
+	public void print() {
+		if (this.numbers == null) {
+			System.out.println();
+			return;
+		}
+		for (int ii = 0; ii < this.numbers.length; ii++) {
+			System.out.print(this.numbers[ii]);
+			System.out.print(" ");
+		}
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		int[] numbers = { 1, 2, 3, 4, 5 };
+		Question045 app = new Question045(numbers);
+		app.print();
+		Criterion isEven = new Criterion() {
+			public boolean check(int num) {
+				if ((num & 0x1) == 0)
+					return true;
+				return false;
+			}
+		};
+		app.reorder(isEven);
+		app.print();
+	}
+
+}

src/com/onufryk/exercise/Question046.java

@@ -0,0 +1,52 @@
+package com.onufryk.exercise;
+
+public class Question046 {
+	public int[] numbers = null;
+	
+	
+	public Question046(int[] numbers) {
+		this.numbers = numbers;
+	}
+
+	public void print() {
+		if (this.numbers == null) {
+			System.out.println();
+			return;
+		}
+		for (int ii = 0; ii < this.numbers.length; ii++) {
+			System.out.print(this.numbers[ii]);
+			System.out.print(" ");
+		}
+		System.out.println();
+	}
+	
+	public void remove(int number) {
+		int begin = 0;
+		int end = this.numbers.length - 1;
+		while (this.numbers[begin] != number && begin < end) {
+			begin++;
+		}
+		while (begin < end) {
+			while (this.numbers[begin] != number && begin < end) {
+				begin++;
+			}
+			while (this.numbers[end] == number && begin < end) {
+				end--;
+			}
+			if (begin < end) {
+				numbers[begin] = numbers[end];
+				numbers[end] = number;
+			}
+			
+		}
+	}
+
+	public static void main(String[] args) {
+		int[] numbers = {4, 3, 2, 1, 2, 3, 6};
+		Question046 app = new Question046(numbers);
+		app.print();
+		app.remove(2);
+		app.print();
+	}
+
+}

src/com/onufryk/exercise/Question050.java

@@ -0,0 +1,71 @@
+package com.onufryk.exercise;
+
+import com.onufryk.exercise.struct.BinaryTree;
+import com.onufryk.exercise.struct.TreeNode;
+
+public class Question050 {
+	public static class SubsctructuredBinaryTree<Item extends Comparable<Item>> extends BinaryTree<Item> {
+
+		public SubsctructuredBinaryTree() {
+			super();
+			
+		}
+
+		public SubsctructuredBinaryTree(TreeNode<Item> root) {
+			super(root);
+		}
+		
+		public Boolean containsSubtree(TreeNode<Item> subtree) {
+			return this.containsSubtree(this.root, subtree);
+		}
+		private Boolean containsSubtree(TreeNode<Item> tree, TreeNode<Item> subtree) {
+			Boolean result = false;
+			if (tree == null || subtree == null) {
+				return false;
+			}
+			if (tree.value == subtree.value) {
+				result = this.hasSubtree(tree, subtree);
+			}
+			if (!result) {
+				result = this.containsSubtree(tree.left, subtree);
+			}
+			if (!result) {
+				result = this.containsSubtree(tree.right, subtree);
+			}
+			return result;
+		}
+		private Boolean hasSubtree(TreeNode<Item> tree, TreeNode<Item> subtree) {
+			Boolean result = false;
+			if (subtree == null) {
+				return true;
+			}
+			if (tree == null) {
+				return false;
+			}
+			if (tree.value != subtree.value) {
+				return false;
+			}
+			
+			return this.hasSubtree(tree.left, subtree.left) && this.hasSubtree(tree.right, subtree.right);
+		}
+	}
+	
+
+	public static void main(String[] args) {
+		TreeNode<Integer> root = new TreeNode<Integer>(8,  
+			new TreeNode<Integer>(8,  
+				new TreeNode<Integer>(9),  
+				new TreeNode<Integer>(2,  
+					new TreeNode<Integer>(4),  
+					new TreeNode<Integer>(7)
+				)
+			),  
+			new TreeNode<Integer>(7)
+		);
+		TreeNode<Integer> sub = new TreeNode<Integer>(8, new TreeNode<Integer>(9), new TreeNode<Integer>(2));
+		SubsctructuredBinaryTree<Integer> tree = new SubsctructuredBinaryTree<Integer>(root);
+		tree.traverseInOrder();
+		System.out.println(tree.containsSubtree(sub));
+	}
+
+}

src/com/onufryk/exercise/struct/TreeNode.java

@@ -13,6 +13,12 @@ public TreeNode() {
 	public TreeNode(Item value) {
 		this.value = value;
 	}
+	
+	public TreeNode(Item value, TreeNode<Item> left, TreeNode<Item> right) {
+		this.value = value;
+		this.left = left;
+		this.right = right;
+	}
 
 	public String toString() {
 		if (this.value != null) {