51-60题
51. 构建乘积数组 – 发散思维能力
题目描述
给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。(注意:规定B[0] = A[1] * A[2] * … * A[n-1],B[n-1] = A[0] * A[1] * … * A[n-2];)
import java.util.ArrayList;
public class Solution {
public int[] multiply(int[] A) {
int len = A.length;
int[] B = new int[len];
B[0] = 1;
for (int i = 1; i < len; i++) {
// B[i] = A[0]*A[1]*...*A[i-1]
B[i] = B[i - 1] * A[i - 1];
}
int temp = 1;
for (int i = len - 1; i >= 0; i--) {
B[i] = B[i] * temp;
// temp = A[n-1]*A[n-2]*...*A[i+1]
temp *= A[i];
}
return B;
}
}
52. 正则表达式匹配 – 代码的完整性
题目描述
请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符,而’'表示它前面的字符可以出现任意次(包含0次)。 在本题中,匹配是指字符串的所有字符匹配整个模式。例如,字符串"aaa"与模式"a.a"和"abaca"匹配,但是与"aa.a"和"ab*a"均不匹配
public class Solution {
public static boolean match(char[] str, char[] pattern) {
if (str == null || pattern == null) {
return false;
}
return matchCore(str, 0, pattern, 0);
}
public static boolean matchCore(char[] str, int sIndex, char[] pattern,
int pIndex) {
int sLen = str.length;
int pLen = pattern.length;
if (sIndex == sLen && pIndex == pLen) {
return true;
}
if (sIndex != sLen && pIndex == pLen) {
return false;
}
if (pIndex + 1 < pLen && pattern[pIndex + 1] == '*') {
if ((sIndex < sLen && str[sIndex] == pattern[pIndex])
|| (pattern[pIndex] == '.' && sIndex < sLen)) {
return matchCore(str, sIndex + 1, pattern, pIndex + 2)// *为1
|| matchCore(str, sIndex + 1, pattern, pIndex)// *为n
|| matchCore(str, sIndex, pattern, pIndex + 2);// *为0
} else {
return matchCore(str, sIndex, pattern, pIndex + 2);// *为0
}
}
if (sIndex < sLen && str[sIndex] == pattern[pIndex]
|| (pattern[pIndex] == '.' && sIndex < sLen)) {
return matchCore(str, sIndex + 1, pattern, pIndex + 1);
}
return false;
}
}
53. 表示数值的字符串 – 代码的完整性
题目描述
请实现一个函数用来判断字符串是否表示数值(包括整数和小数)。例如,字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。 但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。
public class Solution {
public boolean isNumeric(char[] str) {
String sStr = String.valueOf(str);
return sStr.matches("[+|-]?\\d*(\\.\\d+)?([e|E][+|-]?\\d+)?");
}
}
54. 字符流中第一个不重复的字符 – 时间效率与空间效率的平衡
题目描述
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如,当从字符流中只读出前两个字符"go"时,第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时,第一个只出现一次的字符是"l"。
输出描述:
如果当前字符流没有存在出现一次的字符,返回#字符。
public class Solution {
String str = new String();
int[] hash = new int[256];
// Insert one char from stringstream
public void Insert(char ch) {
str += ch;
hash[ch]++;
}
// return the first appearence once char in current stringstream
public char FirstAppearingOnce() {
for (int i = 0; i < str.length(); i++) {
if (hash[str.charAt(i)] == 1) {
return str.charAt(i);
}
}
return '#';
}
}
55. 链表中环的入口结点 – 代码的鲁棒性
题目描述
给一个链表,若其中包含环,请找出该链表的环的入口结点,否则,输出null。
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ListNode EntryNodeOfLoop(ListNode pHead) {
if (pHead == null) {
return null;
}
ListNode a = pHead;
ListNode b = pHead;
boolean flag = false;
while (a.next != null && a.next.next != null) {
a = a.next.next;
b = b.next;
if (a == b) {
flag = true;
break;
}
}
if (!flag) {
return null;
}
ListNode temp = a.next;
int count = 1;
while (temp != a) {
temp = temp.next;
count++;
}
a = pHead;
b = pHead;
while (count > 0) {
a = a.next;
count--;
}
while (b != a) {
b = b.next;
a = a.next;
}
return a;
}
}
56. 删除链表中重复的结点 – 数据结构
题目描述
在一个排序的链表中,存在重复的结点,请删除该链表中重复的结点,重复的结点不保留,返回链表头指针。
例如,链表1->2->3->3->4->4->5 处理后为 1->2->5
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ListNode deleteDuplication(ListNode pHead) {
ListNode Head = new ListNode(0);
Head.next = pHead;
ListNode pre = Head;
ListNode last = Head.next;
while (last != null) {
if (last.next != null && last.next.val == last.val) {
while (last.next != null && last.next.val == last.val) {
last = last.next;
}
pre.next = last.next;
last = last.next;
} else {
pre = pre.next;
last = last.next;
}
}
return Head.next;
}
}
57. 二叉树的下一个结点 – 数据结构
题目描述
给定一个二叉树和其中的一个结点,请找出中序遍历顺序的下一个结点并且返回。注意,树中的结点不仅包含左右子结点,同时包含指向父结点的指针。
/*
public class TreeLinkNode {
int val;
TreeLinkNode left = null;
TreeLinkNode right = null;
TreeLinkNode next = null;
TreeLinkNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public TreeLinkNode GetNext(TreeLinkNode pNode) {
TreeLinkNode result = null;
if (pNode == null) {
return result;
}
if (pNode.right != null) {
TreeLinkNode pRight = pNode.right;
while (pRight.left != null) {
pRight = pRight.left;
}
result = pRight;
} else if (pNode.next != null) {
TreeLinkNode pCurrent = pNode;
TreeLinkNode pParent = pNode.next;
while (pParent != null && pCurrent == pParent.right) {
pCurrent = pParent;
pParent = pParent.next;
}
result = pParent;
}
return result;
}
}
58. 对称的二叉树 – 抽象问题形象化
题目描述
请实现一个函数,用来判断一颗二叉树是不是对称的。注意,如果一个二叉树同此二叉树的镜像是同样的,定义其为对称的。
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
boolean isSymmetrical(TreeNode pRoot) {
// 前序遍历,和根右左遍历
return isSymmetricalCore(pRoot, pRoot);
}
public boolean isSymmetricalCore(TreeNode pRoot, TreeNode pRoot2) {
if (pRoot == null && pRoot2 == null) {
return true;
}
if (pRoot == null || pRoot2 == null) {
return false;
}
if (pRoot.val != pRoot2.val) {
return false;
}
return isSymmetricalCore(pRoot.left, pRoot2.right)
&& isSymmetricalCore(pRoot.right, pRoot2.left);
}
}
59. 按之字形顺序打印二叉树 – 抽象问题具体化
题目描述
请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推。
import java.util.ArrayList;
import java.util.LinkedList;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
if (pRoot == null) {
return result;
}
ArrayList<Integer> arrayList = new ArrayList<Integer>();
LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(pRoot);
int start = 0;
int end = 1;
boolean flag = false;
while (!queue.isEmpty()) {
TreeNode temp = queue.poll();
arrayList.add(temp.val);
start++;
if (temp.left != null) {
queue.offer(temp.left);
}
if (temp.right != null) {
queue.offer(temp.right);
}
if (start == end) {
end = queue.size();
start = 0;
flag = !flag;
if (flag) {
result.add(arrayList);
arrayList = new ArrayList<Integer>();
} else {
ArrayList<Integer> tempList = new ArrayList<Integer>();
while (!arrayList.isEmpty()) {
tempList.add(arrayList.remove(arrayList.size() - 1));
}
result.add(tempList);
}
}
}
return result;
}
}
public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
if (pRoot == null) {
return result;
}
Stack<TreeNode> stack1 = new Stack<TreeNode>();
Stack<TreeNode> stack2 = new Stack<TreeNode>();
stack1.push(pRoot);
int layer = 1;
while (!stack1.isEmpty() || !stack2.isEmpty()) {
ArrayList<Integer> temp = new ArrayList<Integer>();
if (layer % 2 != 0) {
while (!stack1.isEmpty()) {
TreeNode tempnode = stack1.pop();
temp.add(tempnode.val);
if (tempnode.left != null) {
stack2.push(tempnode.left);
}
if (tempnode.right != null) {
stack2.push(tempnode.right);
}
}
} else {
while (!stack2.isEmpty()) {
TreeNode tempnode = stack2.pop();
temp.add(tempnode.val);
if (tempnode.right != null) {
stack1.push(tempnode.right);
}
if (tempnode.left != null) {
stack1.push(tempnode.left);
}
}
}
if (!temp.isEmpty()) {
result.add(temp);
layer++;
}
}
return result;
}
60. 把二叉树打印成多行 – 抽象问题具体化
题目描述
从上到下按层打印二叉树,同一层结点从左至右输出。每一层输出一行。
import java.util.ArrayList;
import java.util.Queue;
import java.util.LinkedList;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
if (pRoot == null) {
return result;
}
ArrayList<Integer> arrayList = new ArrayList<Integer>();
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(pRoot);
int start = 0;
int end = 1;
while (!queue.isEmpty()) {
TreeNode temp = queue.poll();
arrayList.add(temp.val);
start++;
if (temp.left != null) {
queue.offer(temp.left);
}
if (temp.right != null) {
queue.offer(temp.right);
}
if (start == end) {
end = queue.size();
start = 0;
result.add(arrayList);
arrayList = new ArrayList<Integer>();
}
}
return result;
}
}