题目11：数值的整数次方
书中方法：这道题要注意底数为0的情况。double类型的相等判断。乘方的递归算法。
public double power(double base, int exponent){
//指数为0
if(exponent == 0){
return 1.0;
}
//底数为0
if(isEqual(base, 0.0)){
return 0.0;
}
int absExponent = exponent;
if(exponent < 0)absExponent = -absExponent;
double result = unsignedPower(base, absExponent);
if(exponent<0){
result = 1.0/result;
}
return result;
}
private double unsignedPower(double base, int absExponent){
double result = 1.0;
for(int i=1; i<=absExponent; i++){
result *= base;
}
return result;
}
//用递归的方法求乘方
private double unsignedPower2(double base, int absExponent){
if(absExponent == 1)return base;
double result = unsignedPower2(base, absExponent>>1);
result *= result;
if((absExponent & 0x01) == 1){
result *= base;
}
return result;
}
//double类型判断相等
private boolean isEqual(double num1, double num2){
if((num1 - num2)>-0.0000001 && (num1 - num2)<0.0000001){
return true;
}else{
return false;
}
}题目12：打印1 到 最大的n位数。
书中方法：这道题的一个陷阱在于不能用int或者long去存储你要打印的数，然后用打印函数打印，因为这个数可能会很大。如果加1后超出了最大的n位数，就不打印了。用最高位是否进位判断是否结束，打印的时候注意不要打印出前面可能出现的0.
public void print(int n){
if(n<=0){
return;
}
//必须要用字符数组防止大数
char[] c = new char[n];
for(int i=0; i<n; i++){
c[i] = '0';
}
while(!increment(c)){
digitsPrint(c);
}
}
private boolean increment(char[] c){
boolean overflow = false;
//因为是加1，当作从小数进位了1.
int carry = 1;
//从个位开始计算
for(int i=c.length-1; i>=0; i--){
int sum = c[i] - '0' + carry;
//如果进位了
if(sum == 10){
if(i == 0){
overflow = true;
break;
}
carry = 1;
c[i] = '0';
}else{//如果没进位
c[i] = (char)('0' + sum);
break;
}
}
return overflow;
}
private void digitsPrint(char[] c){
int index = 0;
while(c[index] == '0'){
index++;
}
for(int i=index; i<c.length; i++){
System.out.print(c[i]);
}
System.out.println();
}我的方法：看到“所有”和“打印”这样的关键字，很容易想到用回溯的方法去做，因为实质是求出所有组合，上面的方法也是为了能遍历到所有组合。和求字符串的全排列以及组合不同（题目28），这里字符可以重复使用（又联想到了打印n位以内数字不重复整数…）。回想一下我们打印字符串的全排列时，因为每个字符只能使用一次，所以我们得想办法保证每个字符只被选取一次（利用额外的数组或者交换）。现在我们只需要简单地在每个位子上选取可能出现的值，然后递归下去就行了。外层是一个控制长度的循环，内层为每一位选取数字，每一位上都有‘0’-‘9’字符可以选择（第一位除外）。
public void print2(int n){
if(n <= 0)return;
List<String> result = new ArrayList<String>();
String line = "";
//用n控制位数
for(int i=1; i<=n; i++){
find(result, line, 0, i);
}
for(String s : result){
System.out.println(s);
}
}
private void find(List<String> result, String line, int level, int border){
//每一位添加完毕后保存
if(level >= border){
result.add(new String(line));
return;
}
String temp = new String(line);
for(int i=0; i<=9; i++){
//第一位不能为0
if(level == 0 && i == 0){
continue;
}else{
line += i;
find(result, line, level+1, border);
line = temp;
}
}
}题目13：在O(1)时间删除链表节点。
public ListNode delete(ListNode head, ListNode toBeDelete){
//如果头节点为空或者只有一个节点
if(head == null || head.next == null)return null;
//如果要删除的节点在末尾
if(toBeDelete.next == null){
ListNode index = head;
while(index.next!= toBeDelete){
index = index.next;
}
index.next = index.next;
}else{//要删除的节点不在末尾
toBeDelete.val = toBeDelete.next.val;
toBeDelete.next = toBeDelete.next.next;
}
return head;
}题目14：输入整数数组，使所有奇数位于前半部分，所有偶数位于后半部分。
我的方法：想到用两个下标分别表示奇数和偶数的界线，一个在开头，一个在末尾，判断每一个数字的类别，然后将它放入对应的范围内，移动下标，直至两个下标相遇。两个下标，第一个index表示当前要检测的数字以及其左边的数字为奇数（所以当前要检测的数字为奇数的时候，index才会向右移动，否则是even向左移动），even表示其右边的数字为偶数，当index 大于 even的时候分割完毕。这里有个细节，在index表示index左边是奇数，even表示even右边是偶数的前提下 ，如果将while中的“<=”换成“<”（也就是index和even相遇时终止循环，相遇的这个元素无论偶奇不影响分割）也可以完成分割，但此时不知道最后一个元素到底是奇还是偶，如果while中的条件是“<=”（也就是index == even+1时终止循环），我们就可以知道确切的奇偶分界，这一点也可以利用到快速排序中。
public class PartitionInArray {
public void partition(int[] a){
if(a == null || a.length == 0)return;
int index = 0;
int even = a.length - 1;
while(index <= even){
if((a[index] & 0x01) == 1){
index ++;
}else{
exch(a, index, even);
even--;
}
}
}
private void exch(int[] a, int l, int m){
int temp = a[l];
a[l] = a[m];
a[m] = temp;
}
}书中的方法：指针odd（odd左边为奇数）指向开头，指针even（even右边为偶数）指向末尾。同时移动，直到两指针“相遇”(书中是相遇就结束，这里我依旧用odd超过even结束)。
public void partition2(int[] a){
if(a == null || a.length == 0)return;
int odd = 0;
int even = a.length-1;
while(true){
while(odd <= even && isOdd(a[odd])){
odd++;
}
while(odd <= even && !isOdd(a[even])){
even--;
}
if(odd - even == 1){
break;
}
exch(a, odd, even);
}
}
private boolean isOdd(int m){
if((m & 0x01) == 1){
return true;
}
return false;
}联想：这里很自然地就想到了快速排序的分割——将数组分割成小于目标数字和大于等于目标数字两块，只需要把上述上述中的判断条件改了，同时选取一个用于分割的标准元素即可。
题目15：链表中的倒数第k个节点。
书中方法：用两个节点一次遍历求得倒数第k个节点。注意头节点为空，k<=0，k大于节点个数的情况。
public ListNode find(ListNode head, int k){
if(head == null || k <=0){
return null;
}
ListNode first = head, second = head;
for(int i=1; i<=k; i++){
//如果k超出了节点的个数
if(first == null){
return null;
}else{
first = first.next;
}
}
while(first != null){
first = first.next;
second = second.next;
}
return second;
}题目16：输入链表的头节点，反转链表。
书中方法：对于一个链表，我们只能从头往后遍历，如果要反转，我们需要更改当前节点的next域指向前一个节点，此时链表断开，为了能继续修改下一个节点的next域，我们还要维护下一个节点。
public ListNode reverse(ListNode first){
if(first == null)return first;
ListNode last = null;
ListNode now = first;
ListNode next = first.next;
while(now != null){
now.next = last;
last = now;
now = next;
if(now != null){
next = now.next;
}
}
return last;
}方法二：书后面还提到了递归的方法。自己写的逻辑比较不清楚，在网上找了一个版本。这个方法的思路是：递归返回的是当前节点右侧已经反转好的链表的头节点，对于当前的节点，将它连接到已经reverse好的链表的末尾，返回值是添加了该节点的新链表头。先递归后处理，最后的返回值是反转后的节点，每次递归返回的是添加了当前节点的反转后的链表。注意递归出口的处理。
public ListNode reverse2(ListNode first){
if(first == null || first.next == null)return first;
ListNode newHead = reverse2(first.next);
first.next.next = first;
first.next = null;
return newHead;
}题目17：合并两个排序链表。
我的方法：新初始化一个链表头，比较两个链表当前节点的大小，然后连接到该链表中。遍历两个链表直到null为止。
public ListNode merge(ListNode first, ListNode second){
//注意这个细节
ListNode head = new ListNode(0);
ListNode index = head;
while(first != null && second != null){
if(first.val < second.val){
index.next = first;
first = first.next;
}else{
index.next = second;
second = second.next;
}
index = index.next;
}
if(first != null)index.next = first;
else index.next = second;
return head.next;
}书中方法：我们每一次都是找两个链表值中较小的作为结果节点，它的下一个节点依旧会重复一样的过程，这是典型的递归过程，可以得到以下的递归方法。先处理后递归，最后的返回值是头节点，每次递归的返回值是较小的节点。
public ListNode merge2(ListNode first, ListNode second){
if(first == null)return second;
if(second == null)return first;
ListNode nowHead = null;
if(first.val < second.val){
nowHead = first;
nowHead.next = merge2(first.next, second);
}else{
nowHead = second;
nowHead.next = merge2(first, second.next);
}
return nowHead;
}题目18：输入两棵二叉树A和B，判断B是不是A的子结构。（补充下，根据书中的代码来看，子结构的定义并不包括叶子节点下的null，也就是说只要B的存在数字的结构存在于A中就行，那么如果B是null树，那么就不属于A的子结构）
书中方法：书上的方法十分清晰，分为两个步骤，先在A树中找到B树的root.val，然后判断由该点向下是否完全包含B树的结构，直至遍历完A树。
public boolean isChild(TreeNode aRoot, TreeNode bRoot){
//A树没有遍历完而且B树不为空
if(aRoot != null && bRoot != null){
//在当前节点检查结构，或者去遍历当前节点的左节点或右节点。
return isQualified(aRoot, bRoot)
|| isChild(aRoot.left, bRoot)
|| isChild(aRoot.right, bRoot);
}
//A树遍历完了或者B树是个null
return false;
}
private boolean isQualified(TreeNode aRoot, TreeNode bRoot){
//检查到了B的末尾
if(bRoot == null)return true;
//如果在检查完B之前A到了底
if(aRoot == null)return false;
//都不是null且val相等，继续检查
if(aRoot.val == bRoot.val){
return isQualified(aRoot.left, bRoot.left)
&& isQualified(aRoot.right, bRoot.right);
}
//都不是null但是val不等
return false;
}我的方法：开始检查一下B是否为空，空的话返回false（定义）。aRoot和bRoot是两个根节点，且都可能在自己的根节点和子节点之间转换。开头，如果aRoot.val和bRoot.val相等了，那么继续对各自的子节点进行对比；如果不相等则移动aRoot并和bRoot进行比较。
public boolean isChildTree(TreeNode aRoot, TreeNode bRoot){
//定义，如果B树为空，返回false
if(bRoot == null){
return false;
}
return isChild2(aRoot, bRoot);
}
private boolean isChild2(TreeNode aRoot, TreeNode bRoot){
//如果检查到了B的末尾
if(bRoot == null)return true;
//A到了末尾但是B没有
if(aRoot == null)return false;
//如果当前节点相同，进行进一步对比；
//对比的结果可能是false，此时继续向下检查aRoot.left与bRoot、aRoot.right与bRoot
if(aRoot.val == bRoot.val){
return (isChild2(aRoot.left, bRoot.left) && isChild2(aRoot.right, bRoot.right))
|| isChild2(aRoot.left, bRoot)
|| isChild2(aRoot.right, bRoot);
}else{//如果当前节点不同，继续向下检查aRoot.left与bRoot、aRoot.right与bRoot
return isChild2(aRoot.left, bRoot)
|| isChild2(aRoot.right, bRoot);
}
}题目19：二叉树的镜像。
书中方法：这道题目可能拿到手没有思路，我们可以在纸上画出简单的二叉树来找到规律。最后我们发现，镜像的实质是对于二叉树的所有节点，交换其左右子节点。搞清楚获得镜像的方法，这道题实际上就变成了一道二叉树遍历的变形。这里选择前序遍历二叉树。
public void change(TreeNode root){
if(root == null)return;
TreeNode temp = root.left;
root.left = root.right;
root.right = temp;
change(root.left);
change(root.right);
}如果改成循环实现：实际上也就是把递归改成循环前序遍历二叉树。注意null是可以被压入栈（队列、HashMap等）的，栈全部是null元素和栈为空不同。
public void change2(TreeNode root){
if(root == null)return;
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(root);
while(!stack.isEmpty()){
TreeNode now = stack.pop();
if(now.right != null)stack.push(now.right);
if(now.left != null)stack.push(now.left);
TreeNode temp = now.left;
now.left = now.right;
now.right = temp;
}
}题目20：顺时针打印矩阵。
我的方法：遇到这种题最好在纸上画一画打印路线。我利用了4个标志left、top、right、bottom，表示当前需要打印的左界、上届、右界和下界，换句话说这些界线之外的已经打印了，如此一来判断结束的标准也很清晰，top>bottom或者left>right就表示已经没有需要打印的空间。和第14题中确定结束条件类似，明确下标的含义，就能很快判断结束条件。
public void myPrint(int[][] a){
if(a == null || a.length == 0 || (a.length == 1 && a[0].length == 0)){
return;
}
int left = 0;
int right = a[0].length -1;
int top = 0;
int bottom = a.length - 1;
//用于改变方向，分别代表 从左向右打印，从上往下打印，从又往左打印，从下往上打印。
int[] orientations = new int[]{0, 1, 2, 3};
int count = 0;
while(left <= right && top <= bottom){
//按顺序改变方向
switch (orientations[count%orientations.length]) {
case 0:
//从左向右打印一行，打印完后上界下移
for(int i=left; i<=right; i++){
System.out.print(a[top][i]);
}
top++;
count++;
break;
case 1:
//从上到下打印一列，打印完后右界左移
for(int i=top; i<=bottom; i++){
System.out.print(a[i][right]);
}
right--;
count++;
break;
case 2:
//从右到左打印一行，打印完后下界上移
for(int i=right; i>=left; i--){
System.out.print(a[bottom][i]);
}
bottom--;
count++;
break;
case 3:
//从下到上打印一列，打印完后左界右移
for(int i=bottom; i>=top; i--){
System.out.print(a[i][left]);
}
left++;
count++;
break;
default:
break;
}
}
}书中方法：书中的思路是一圈一圈向内打印，既然这样就要找到每一圈的起点和打印的圈。假设我们用count表示已经打印的圈数。起点就是（count, count）；打印的圈是一个矩形条框，矩形可以由一条对角线确定，我们找到矩形条框右下角的点，就能由这个点和起点确定一个需要打印的圈（矩形框）。只要有起点的空间，就继续打印。
public void myPrint2(int[][] a){
if(a == null || a.length == 0 || (a.length == 1 && a[0].length == 0)){
return;
}
int count = 0;
//打印了count次后，如果还留有下一次打印的起始点的位置，继续打印
while(a.length - 2*count > 0 && a[0].length - 2*count > 0){
printRound(a, count);
count++;
}
}打印的范围确定了，剩下就是按顺时针打印每一个圈。
private void printRound(int[][] a, int count){
int endX = a[0].length - 1 - count;
int endY = a.length - 1 - count;
int start = count;
//无论如何第一行都需要打印
for(int i=start; i<=endX; i++){
System.out.print(a[start][i]);
}
//如果不止一行
if(start < endY){
for(int i=start+1; i<=endY; i++){
System.out.print(a[i][endX]);
}
}
if(start < endX && start < endY){
for(int i=endX-1; i>=start; i--){
System.out.print(a[endY][i]);
}
}
if(start < endX && start < endY-1){
for(int i=endY-1; i>start; i--){
System.out.print(a[i][start]);
}
}
}
