initial commit

Author: c0090555

AddBinary.java

@@ -0,0 +1,52 @@
+public class AddBinary {
+	public String addBinary(String a, String b) {
+		String l = a.length() > b.length() ? a : b;// long string
+		String s = l == a ? b : a;// short string
+		int carry = 0;
+		StringBuilder sb = new StringBuilder();
+		for (int i = l.length() - 1, j = s.length() - 1; j >= 0; i--, j--) {
+			Character cl = l.charAt(i);
+			Character cs = s.charAt(j);
+			if (cl == cs && cl == '0') {
+				sb.append(0 + carry);
+				carry = 0;
+			} else if (cl == cs && cl == '1') {
+				sb.append(0 + carry);
+				carry = 1;
+			} else if (cl != cs && carry == 0) {
+				sb.append(1);
+			} else if (cl != cs && carry == 1) {
+				sb.append(0);
+				carry = 1;
+			}
+		}
+
+		for (int i = l.length() - s.length() - 1; i >= 0; i--) {
+			Character cl = l.charAt(i);
+			if (cl == '0' && carry == 1) {
+				sb.append(1);
+				carry = 0;
+			} else if (cl == '1' && carry == 1) {
+				sb.append(0);
+				carry = 1;
+			} else {
+				sb.append(cl);
+			}
+		}
+		if(carry==1){
+			sb.append(1);
+		}
+		return sb.reverse().toString();
+	}
+
+	
+	public static void main(String[] args){
+		String c = "111";
+		String d = "10";
+		AddBinary o = new AddBinary();
+		String result = o.addBinary(c, d);
+		System.out.println("result "+result);
+		
+				
+	}
+}

AddTwoNumbersInLinkedList.java

@@ -0,0 +1,84 @@
+class ListNode {
+	int val;
+	ListNode next;
+
+	ListNode(int v) {
+		val = v;
+		next = null;
+	}
+}
+
+public class AddTwoNumbersInLinkedList {
+	public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+		int carry = 0;
+		int value = 0;
+		ListNode head;
+		ListNode temp;
+		ListNode node;
+		if (l1 == null || l2 == null) {
+			return null;
+		}
+		value = l1.val + l2.val;
+		head = new ListNode(value % 10);
+		node = head;
+		carry = value / 10;
+		l1 = l1.next;
+		l2 = l2.next;
+
+		while (l1 != null || l2 != null) {
+			value = 0;
+			if (l1 != null) {
+				value += l1.val;
+				l1 = l1.next;
+			}
+			if (l2 != null) {
+				value += l2.val;
+				l2 = l2.next;
+			}
+			value += carry;
+			carry = value / 10;
+			temp = new ListNode(value % 10);
+			node.next = temp;
+			node = node.next;
+		}
+		if(carry != 0){
+			temp = new ListNode(carry);
+			node.next = temp;
+		}
+		
+		return head;
+	}
+	public void printListNode(ListNode head){
+		while(head!=null){
+			System.out.print(head.val+"=>");
+			head = head.next;
+		}
+	}
+	
+	public static void main(String[] args){
+		AddTwoNumbersInLinkedList o = new AddTwoNumbersInLinkedList();
+		ListNode l1 = new ListNode(1);
+		ListNode head = l1;
+		for(int i = 2;i<5;i++){
+			ListNode l = new ListNode(i);
+			l1.next = l;
+			l1=l1.next;
+		}
+		o.printListNode(head);
+		System.out.println();
+		ListNode l2 = new ListNode(1);
+		ListNode head2 = l2;
+		for(int i = 2;i<4;i++){
+			ListNode l22 = new ListNode(i);
+			l2.next = l22;
+			l2=l2.next;
+		}
+		o.printListNode(head2);
+		System.out.println();
+
+		ListNode result = o.addTwoNumbers(head, head2);
+		o.printListNode(result);
+		
+	}
+
+}

Anagram.java

@@ -0,0 +1,50 @@
+import java.util.*;
+
+public class Anagram {
+	public ArrayList<String> anagrams(String[] strs) {
+		ArrayList<String> result = new ArrayList<String>();
+		HashMap<String, LinkedList<String>> map = new HashMap<String, LinkedList<String>>();
+		LinkedList<String> l = new LinkedList<String>();
+		for (String s : strs) {
+			String si = inorderString(s);
+			if (!map.containsKey(si)) {
+				l = new LinkedList<String>();
+
+			} else {
+				l = map.get(si);
+			}
+			l.push(s);
+			map.put(si, l);
+			System.out.println("si"+si+" l "+l);
+		}
+
+		System.out.println("key:"+map.keySet());
+		for (String si : map.keySet()) {
+			System.out.println("si "+si);
+			l = map.get(si);
+			if (l.size() > 1) {
+				for (String s : l) {
+					result.add(s);
+				}
+			}
+		}
+		return result;
+
+	}
+
+	public String inorderString(String str) {
+		char[] ch = str.toCharArray();//string => char array
+		Arrays.sort(ch);
+		System.out.println("ch:"+ch.toString());
+		return new String(ch);//char array => string
+	}
+
+	public static void main(String[] args) {
+		ArrayList<String> result;
+		String[] st = { "abc", "bca", "a", "bb", "ac", "ca", "" };
+		Anagram a = new Anagram();
+		result = a.anagrams(st);
+		System.out.println(result);
+	}
+
+}

BalancedBianryTree.java

@@ -0,0 +1,30 @@
+
+
+
+
+
+public class BalancedBianryTree {
+	public boolean isBalanced(TreeNode root) {
+		// Start typing your Java solution below
+		// DO NOT write main() function
+		if(root==null){
+			return true;
+		}
+		int diff = Math.abs(getHeight(root.left)-getHeight(root.right));
+		if(diff>1){
+			return false;
+		}
+		return isBalanced(root.left)||isBalanced(root.right);
+		
+	}
+	public int getHeight(TreeNode root){
+		if(root==null){
+			return 0;
+		}
+		int leftHeight = getHeight(root.left);
+		int rightHeight = getHeight(root.right);
+		return Math.max(leftHeight,rightHeight)+1;
+	}
+	
+	
+}

BestTimeToBuyAndSellStock.java

@@ -0,0 +1,25 @@
+/*
+Say you have an array for which the ith element is the price of a given stock on day i.
+
+If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
+ */
+public class BestTimeToBuyAndSellStock {
+	public int maxProfit(int[] prices) {
+		// Start typing your Java solution below
+		// DO NOT write main() function
+		if (prices.length == 0 || prices.length == 1) {
+			return 0;
+		}
+		int max = 0;
+		for (int i = 1; i < prices.length; i++) {
+			for (int j = 0; j < i; j++) {
+				if (prices[i] > prices[j]) {
+					int value = prices[i] - prices[j];
+					max = Math.max(max, value);
+				}
+			}
+		}
+
+		return max;
+	}
+}

BestTimeToBuyAndSellStockII.java

@@ -0,0 +1,25 @@
+/*
+Say you have an array for which the ith element is the price of a given stock on day i.
+
+Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+ */
+
+//the problem is actually to find all non-decreasing continuous subsequence
+
+public class BestTimeToBuyAndSellStockII {
+	public int maxProfit(int[] prices) {
+		// Start typing your Java solution below
+		// DO NOT write main() function
+		if (prices.length == 0 || prices.length == 1) {
+			return 0;
+		}
+		int value = 0;
+		for (int i = 0; i < prices.length - 1; i++) {
+			if (prices[i] <= prices[i + 1]) {
+				value += prices[i + 1] - prices[i];
+			}
+		}
+		return value;
+
+	}
+}

BestTimeToBuyAndSellStockIII.java

@@ -0,0 +1,57 @@
+/*
+Say you have an array for which the ith element is the price of a given stock on day i.
+
+Design an algorithm to find the maximum profit. You may complete at most two transactions.
+
+Note:
+You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+ */
+//idea comes from peking2 of Mitbbs
+// use two array dp1 and dp2 to traversal from both end
+
+public class BestTimeToBuyAndSellStockIII {
+	public int maxProfit(int[] prices) {
+		// Start typing your Java solution below
+		// DO NOT write main() function
+		if (prices.length == 0 || prices.length == 1) {
+			return 0;
+		}
+		int len = prices.length;
+		int[] dp1 = new int[prices.length];
+		int[] dp2 = new int[prices.length];
+		int min = prices[0];
+		int max = prices[len - 1];
+
+		// for dp1: travel from left to right
+		System.out.print(" " + dp1[0]);
+
+		for (int i = 1; i < len; i++) {
+			min = Math.min(min, prices[i]);
+			dp1[i] = Math.max(dp1[i - 1], prices[i] - min);
+			System.out.print(" " + dp1[i]);
+		}
+		System.out.println();
+		// for dp2: travel from right to left
+		System.out.print(" " + dp2[len - 1]);
+		for (int j = len - 2; j >= 0; j--) {
+			max = Math.max(max, prices[j]);
+			dp2[j] = Math.max(dp2[j + 1], max - prices[j]);
+			System.out.print(" " + dp2[j]);
+		}
+		System.out.println();
+		int ans = 0;
+		for (int k = 0; k < len; k++) {
+			ans = Math.max(ans, dp1[k] + dp2[k]);// You may not engage in
+													// multiple transactions at
+													// the same time
+		}
+		return ans;
+
+	}
+
+	public static void main(String[] args) {
+		BestTimeToBuyAndSellStockIII o = new BestTimeToBuyAndSellStockIII();
+		int[] prices = { 2, 1, 2, 1, 0, 1, 2 };
+		System.out.println(o.maxProfit(prices));
+	}
+}