@@ -60,13 +60,13 @@ public class binaryTreeLevelOrderTraversal {
      * @return: Level order a list of lists of integer
      */
     public List<List<Integer>> levelOrder(TreeNode root) {
-        List<List<Integer>> results = new ArrayList<List<Integer>>();
+        List<List<Integer>> results = new ArrayList<>();
         if (root == null) {
             return results;
         }
 
         ArrayList<Integer> values = new ArrayList<Integer>();
-        Queue<TreeNode> q = new LinkedList<TreeNode>();
+        Queue<TreeNode> q = new LinkedList<>();
 
         q.offer(root);
         q.offer(null);
@@ -75,7 +75,7 @@ public List<List<Integer>> levelOrder(TreeNode root) {
             TreeNode node = q.poll();
             // null node used as a separator of every level
             if (node == null) {
-                results.add(new ArrayList<Integer>(values));
+                results.add(new ArrayList<>(values));
                 values.clear();
                 if (q.size() == 0) {
                     break;
 
@@ -13,8 +13,8 @@ public class inorderSuccessorInBSTTest {
 
     @Test
     public void testInorderSuccessor() throws Exception {
-        ArrayList<TreeNode> inputes = new ArrayList<TreeNode>();
-        ArrayList<TreeNode> targets = new ArrayList<TreeNode>();
+        ArrayList<TreeNode> inputes = new ArrayList<>();
+        ArrayList<TreeNode> targets = new ArrayList<>();
 
         TreeNode n0 = new TreeNode(2);
         TreeNode n1 = new TreeNode(1);
@@ -37,7 +37,7 @@ public void testInorderSuccessor() throws Exception {
         targets.add(t0);
 
 
-        ArrayList<TreeNode> results = new ArrayList<TreeNode>();
+        ArrayList<TreeNode> results = new ArrayList<>();
         results.add(null);
         results.add(nn0);
         results.add(t1);
 
@@ -13,10 +13,10 @@ public class lowestCommonAncestorOfABinaryTreeTest {
 
     @Test
     public void testLowestCommonAncestor() throws Exception {
-        ArrayList<TreeNode> inputeRoots = new ArrayList<TreeNode>();
-        ArrayList<TreeNode> inputeAs = new ArrayList<TreeNode>();
-        ArrayList<TreeNode> inputeBs = new ArrayList<TreeNode>();
-        ArrayList<TreeNode> results = new ArrayList<TreeNode>();
+        ArrayList<TreeNode> inputeRoots = new ArrayList<>();
+        ArrayList<TreeNode> inputeAs = new ArrayList<>();
+        ArrayList<TreeNode> inputeBs = new ArrayList<>();
+        ArrayList<TreeNode> results = new ArrayList<>();
 
         TreeNode n0 = new TreeNode(0);
         TreeNode n1 = new TreeNode(1);
 
@@ -30,7 +30,7 @@ public void testMaxDepth() throws Exception {
         n4.left = n5;
         n2.right = n6;
 
-        ArrayList<TreeNode> inputes = new ArrayList<TreeNode>();
+        ArrayList<TreeNode> inputes = new ArrayList<>();
         inputes.add(t0);
         inputes.add(n0);
         int[] results = {1,3};
 
@@ -65,8 +65,8 @@ public class MyQueue {
 	public Stack<Integer> stack2;
 	public int size;
 	public MyQueue() {
-		stack1 = new Stack<Integer>();
-		stack2 = new Stack<Integer>();
+		stack1 = new Stack<>();
+		stack2 = new Stack<>();
 		size = 0;
 	}
 
@@ -92,8 +92,7 @@ public int peek() {
 				stack2.push(stack1.pop());
 			}
 		}
-		int value = stack2.peek();
-		return value;
+		return stack2.peek();
 	}
 
 	public boolean empty() {
Original file line number	Diff line number	Diff line change
`@@ -65,8 +65,8 @@ public class MyQueue {`
`65`	`65`	`public Stack<Integer> stack2;`
`66`	`66`	`public int size;`
`67`	`67`	`public MyQueue() {`
`68`		`- stack1 = new Stack<Integer>();`
`69`		`- stack2 = new Stack<Integer>();`
	`68`	`+ stack1 = new Stack<>();`
	`69`	`+ stack2 = new Stack<>();`
`70`	`70`	`size = 0;`
`71`	`71`	`}`
`72`	`72`
`@@ -92,8 +92,7 @@ public int peek() {`
`92`	`92`	`stack2.push(stack1.pop());`
`93`	`93`	`}`
`94`	`94`	`}`
`95`		`- int value = stack2.peek();`
`96`		`- return value;`
	`95`	`+ return stack2.peek();`
`97`	`96`	`}`
`98`	`97`
`99`	`98`	`public boolean empty() {`