first commit

Author: 左程云

bin/topinterviewquestions/Problem_0001_TwoSum.class

@@ -0,0 +1,18 @@
+package topinterviewquestions;
+
+import java.util.HashMap;
+
+public class Problem_0001_TwoSum {
+
+	public static int[] twoSum(int[] nums, int target) {
+		HashMap<Integer, Integer> map = new HashMap<>();
+		for (int i = 0; i < nums.length; i++) {
+			if (map.containsKey(target - nums[i])) {
+				return new int[] { map.get(target - nums[i]), i };
+			}
+			map.put(nums[i], i);
+		}
+		return new int[] { -1, -1 };
+	}
+
+}

bin/topinterviewquestions/Problem_0002_AddTwoNumbers$ListNode.class

@@ -0,0 +1,55 @@
+package topinterviewquestions;
+
+public class Problem_0002_AddTwoNumbers {
+
+	// 不要提交这个类描述
+	public static class ListNode {
+		public int val;
+		public ListNode next;
+
+		public ListNode(int value) {
+			this.val = value;
+		}
+	}
+
+	public static ListNode addTwoNumbers(ListNode head1, ListNode head2) {
+		int ca = 0;
+		int n1 = 0;
+		int n2 = 0;
+		int n = 0;
+		ListNode c1 = head1;
+		ListNode c2 = head2;
+		ListNode node = null;
+		ListNode pre = null;
+		while (c1 != null || c2 != null) {
+			n1 = c1 != null ? c1.val : 0;
+			n2 = c2 != null ? c2.val : 0;
+			n = n1 + n2 + ca;
+			pre = node;
+			node = new ListNode(n % 10);
+			node.next = pre;
+			ca = n / 10;
+			c1 = c1 != null ? c1.next : null;
+			c2 = c2 != null ? c2.next : null;
+		}
+		if (ca == 1) {
+			pre = node;
+			node = new ListNode(1);
+			node.next = pre;
+		}
+		return reverseList(node);
+	}
+
+	public static ListNode reverseList(ListNode head) {
+		ListNode pre = null;
+		ListNode next = null;
+		while (head != null) {
+			next = head.next;
+			head.next = pre;
+			pre = head;
+			head = next;
+		}
+		return pre;
+	}
+
+}

bin/topinterviewquestions/Problem_0002_AddTwoNumbers.class

@@ -0,0 +1,26 @@
+package topinterviewquestions;
+
+public class Problem_0003_LongestSubstringWithoutRepeatingCharacters {
+
+	public static int lengthOfLongestSubstring(String str) {
+		if (str == null || str.equals("")) {
+			return 0;
+		}
+		char[] chas = str.toCharArray();
+		int[] map = new int[256];
+		for (int i = 0; i < 256; i++) {
+			map[i] = -1;
+		}
+		int len = 0;
+		int pre = -1;
+		int cur = 0;
+		for (int i = 0; i != chas.length; i++) {
+			pre = Math.max(pre, map[chas[i]]);
+			cur = i - pre;
+			len = Math.max(len, cur);
+			map[chas[i]] = i;
+		}
+		return len;
+	}
+
+}

bin/topinterviewquestions/Problem_0003_LongestSubstringWithoutRepeatingCharacters.class

@@ -0,0 +1,75 @@
+package topinterviewquestions;
+
+public class Problem_0004_MedianOfTwoSortedArrays {
+
+	public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
+		int size = nums1.length + nums2.length;
+		boolean even = (size & 1) == 0;
+		if (nums1.length != 0 && nums2.length != 0) {
+			if (even) {
+				return (double) (findKthNum(nums1, nums2, size / 2) + findKthNum(nums1, nums2, size / 2 + 1)) / 2D;
+			} else {
+				return findKthNum(nums1, nums2, size / 2 + 1);
+			}
+		} else if (nums1.length != 0) {
+			if (even) {
+				return (double) (nums1[(size - 1) / 2] + nums1[size / 2]) / 2;
+			} else {
+				return nums1[size / 2];
+			}
+		} else if (nums2.length != 0) {
+			if (even) {
+				return (double) (nums2[(size - 1) / 2] + nums2[size / 2]) / 2;
+			} else {
+				return nums2[size / 2];
+			}
+		} else {
+			return 0;
+		}
+	}
+
+	public static int findKthNum(int[] arr1, int[] arr2, int kth) {
+		int[] longs = arr1.length >= arr2.length ? arr1 : arr2;
+		int[] shorts = arr1.length < arr2.length ? arr1 : arr2;
+		int l = longs.length;
+		int s = shorts.length;
+		if (kth <= s) {
+			return getUpMedian(shorts, 0, kth - 1, longs, 0, kth - 1);
+		}
+		if (kth > l) {
+			if (shorts[kth - l - 1] >= longs[l - 1]) {
+				return shorts[kth - l - 1];
+			}
+			if (longs[kth - s - 1] >= shorts[s - 1]) {
+				return longs[kth - s - 1];
+			}
+			return getUpMedian(shorts, kth - l, s - 1, longs, kth - s, l - 1);
+		}
+		if (longs[kth - s - 1] >= shorts[s - 1]) {
+			return longs[kth - s - 1];
+		}
+		return getUpMedian(shorts, 0, s - 1, longs, kth - s, kth - 1);
+	}
+
+	public static int getUpMedian(int[] a1, int s1, int e1, int[] a2, int s2, int e2) {
+		int mid1 = 0;
+		int mid2 = 0;
+		int offset = 0;
+		while (s1 < e1) {
+			mid1 = (s1 + e1) / 2;
+			mid2 = (s2 + e2) / 2;
+			offset = ((e1 - s1 + 1) & 1) ^ 1;
+			if (a1[mid1] > a2[mid2]) {
+				e1 = mid1;
+				s2 = mid2 + offset;
+			} else if (a1[mid1] < a2[mid2]) {
+				s1 = mid1 + offset;
+				e2 = mid2;
+			} else {
+				return a1[mid1];
+			}
+		}
+		return Math.min(a1[s1], a2[s2]);
+	}
+
+}

bin/topinterviewquestions/Problem_0004_MedianOfTwoSortedArrays.class

@@ -0,0 +1,48 @@
+package topinterviewquestions;
+
+public class Problem_0005_LongestPalindromicSubstring {
+
+	public static String longestPalindrome(String str) {
+		if (str == null || str.length() == 0) {
+			return "";
+		}
+		char[] charArr = manacherString(str);
+		int[] pArr = new int[charArr.length];
+		int index = -1;
+		int pR = -1;
+		int max = Integer.MIN_VALUE;
+		int mid = 0;
+		for (int i = 0; i != charArr.length; i++) {
+			pArr[i] = pR > i ? Math.min(pArr[2 * index - i], pR - i) : 1;
+			while (i + pArr[i] < charArr.length && i - pArr[i] > -1) {
+				if (charArr[i + pArr[i]] == charArr[i - pArr[i]])
+					pArr[i]++;
+				else {
+					break;
+				}
+			}
+			if (i + pArr[i] > pR) {
+				pR = i + pArr[i];
+				index = i;
+			}
+			if (max < pArr[i]) {
+				max = pArr[i];
+				mid = i;
+			}
+		}
+		mid = (mid - 1) / 2;
+		max = max - 1;
+		return str.substring((max & 1) == 0 ? mid - (max / 2) + 1 : mid - (max / 2), mid + (max / 2) + 1);
+	}
+
+	public static char[] manacherString(String str) {
+		char[] charArr = str.toCharArray();
+		char[] res = new char[str.length() * 2 + 1];
+		int index = 0;
+		for (int i = 0; i != res.length; i++) {
+			res[i] = (i & 1) == 0 ? '#' : charArr[index++];
+		}
+		return res;
+	}
+
+}

bin/topinterviewquestions/Problem_0005_LongestPalindromicSubstring.class

@@ -0,0 +1,21 @@
+package topinterviewquestions;
+
+public class Problem_0007_ReverseInteger {
+
+	public static int reverse(int x) {
+		boolean neg = ((x >>> 31) & 1) == 1;
+		x = neg ? x : -x;
+		int m = Integer.MIN_VALUE / 10;
+		int o = Integer.MIN_VALUE % 10;
+		int res = 0;
+		while (x != 0) {
+			if (res < m || (res == m && x % 10 < o)) {
+				return 0;
+			}
+			res = res * 10 + x % 10;
+			x /= 10;
+		}
+		return neg ? res : Math.abs(res);
+	}
+
+}

bin/topinterviewquestions/Problem_0007_ReverseInteger.class

@@ -0,0 +1,67 @@
+package topinterviewquestions;
+
+public class Problem_0008_StringToInteger {
+
+	public static int myAtoi(String str) {
+		if (str == null || str.equals("")) {
+			return 0;
+		}
+		str = removeHeadZero(str.trim());
+		if (str == null || str.equals("")) {
+			return 0;
+		}
+		char[] chas = str.toCharArray();
+		if (!isValid(chas)) {
+			return 0;
+		}
+		boolean posi = chas[0] == '-' ? false : true;
+		int minq = Integer.MIN_VALUE / 10;
+		int minr = Integer.MIN_VALUE % 10;
+		int res = 0;
+		int cur = 0;
+		for (int i = (chas[0] == '-' || chas[0] == '+') ? 1 : 0; i < chas.length; i++) {
+			cur = '0' - chas[i];
+			if ((res < minq) || (res == minq && cur < minr)) {
+				return posi ? Integer.MAX_VALUE : Integer.MIN_VALUE;
+			}
+			res = res * 10 + cur;
+		}
+		if (posi && res == Integer.MIN_VALUE) {
+			return Integer.MAX_VALUE;
+		}
+		return posi ? -res : res;
+	}
+
+	public static String removeHeadZero(String str) {
+		boolean r = (str.startsWith("+") || str.startsWith("-"));
+		int s = r ? 1 : 0;
+		for (; s < str.length(); s++) {
+			if (str.charAt(s) != '0') {
+				break;
+			}
+		}
+		int e = -1;
+		for (int i = str.length() - 1; i >= (r ? 1 : 0); i--) {
+			if (str.charAt(i) < '0' || str.charAt(i) > '9') {
+				e = i;
+			}
+		}
+		return (r ? String.valueOf(str.charAt(0)) : "") + str.substring(s, e == -1 ? str.length() : e);
+	}
+
+	public static boolean isValid(char[] chas) {
+		if (chas[0] != '-' && chas[0] != '+' && (chas[0] < '0' || chas[0] > '9')) {
+			return false;
+		}
+		if ((chas[0] == '-' || chas[0] == '+') && chas.length == 1) {
+			return false;
+		}
+		for (int i = 1; i < chas.length; i++) {
+			if (chas[i] < '0' || chas[i] > '9') {
+				return false;
+			}
+		}
+		return true;
+	}
+
+}

bin/topinterviewquestions/Problem_0008_StringToInteger.class

@@ -0,0 +1,71 @@
+package topinterviewquestions;
+
+public class Problem_0010_RegularExpressionMatching {
+
+	public static boolean isMatch(String str, String exp) {
+		if (str == null || exp == null) {
+			return false;
+		}
+		char[] s = str.toCharArray();
+		char[] e = exp.toCharArray();
+		if (!isValid(s, e)) {
+			return false;
+		}
+		boolean[][] dp = initDPMap(s, e);
+		for (int i = s.length - 1; i > -1; i--) {
+			for (int j = e.length - 2; j > -1; j--) {
+				if (e[j + 1] != '*') {
+					dp[i][j] = (s[i] == e[j] || e[j] == '.') && dp[i + 1][j + 1];
+				} else {
+					int si = i;
+					while (si != s.length && (s[si] == e[j] || e[j] == '.')) {
+						if (dp[si][j + 2]) {
+							dp[i][j] = true;
+							break;
+						}
+						si++;
+					}
+					if (dp[i][j] != true) {
+						dp[i][j] = dp[si][j + 2];
+					}
+				}
+			}
+		}
+		return dp[0][0];
+	}
+
+	public static boolean isValid(char[] s, char[] e) {
+		for (int i = 0; i < s.length; i++) {
+			if (s[i] == '*' || s[i] == '.') {
+				return false;
+			}
+		}
+		for (int i = 0; i < e.length; i++) {
+			if (e[i] == '*' && (i == 0 || e[i - 1] == '*')) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static boolean[][] initDPMap(char[] s, char[] e) {
+		int slen = s.length;
+		int elen = e.length;
+		boolean[][] dp = new boolean[slen + 1][elen + 1];
+		dp[slen][elen] = true;
+		for (int j = elen - 2; j > -1; j = j - 2) {
+			if (e[j] != '*' && e[j + 1] == '*') {
+				dp[slen][j] = true;
+			} else {
+				break;
+			}
+		}
+		if (slen > 0 && elen > 0) {
+			if ((e[elen - 1] == '.' || s[slen - 1] == e[elen - 1])) {
+				dp[slen - 1][elen - 1] = true;
+			}
+		}
+		return dp;
+	}
+
+}