1.輸入一個連結串列,從尾到頭列印連結串列每個節點的值。

1. package test3;  
2. import java.util.ArrayList;  
3.  class ListNode {  
4.     int val;  
5.     ListNode next = null;  
6.     ListNode(int val) {  
7.         this.val = val;  
8.     }  
9. }  
10. publicclass printFromTailtoHead {  
11.     publicstatic ArrayList<Integer> printListFromTailToHead(ListNode listNode) {  
12.         ArrayList<Integer> a = new ArrayList<Integer>();  
13.         ListNode temp = listNode;  
14.         while(temp != null){  
15.             a.add(new Integer(temp.val));  
16.             temp = temp.next;  
17.         }  
18.         Integer b ;  
19.         for(int i=0; i<a.size()/2;i++){  
20.             b = a.get(i);  
21.             a.set(i, a.get(a.size()-i-1));  
22.             a.set(a.size()-i-1,b);  
23.         }  
24.         return a;  
25.     }  
26.     publicstaticvoid main(String args[]){  
27.         ListNode a = new ListNode(1);  
28.         a.next = new ListNode(2);  
29.         ArrayList<Integer> b = printListFromTailToHead(a);  
30.         System.out.println(b.get(0)+"----"+b.get(1));  
31.     }  
32. }  

1. public class Solution {  
2.         public TreeNode reConstructBinaryTree(int [] pre,int [] in) {  
3.              return reConstructBinaryTree0(pre, 0, pre.length, in, 0, in.length);  
4.         }  
5.     public TreeNode reConstructBinaryTree0(int [] pre, int preStart, int preEnd, int [] in, int inStart, int inEnd) {  
6.         if (preStart >= preEnd) { // way out  
7.             return null;  
8.         }  
9.         int rootIndex = indexOf(in, inStart, inEnd, pre[preStart]);  
10.         TreeNode root = new TreeNode(pre[preStart]);  
11.         int leftPreStart = preStart + 1;  
12.         int leftPreEnd = leftPreStart + (rootIndex - inStart);  
13.         int leftInStart = inStart;  
14.         int leftInEnd = rootIndex;  
15.                 // 構建左子樹  
16.         root.left = reConstructBinaryTree0(pre, leftPreStart, leftPreEnd, in, leftInStart, leftInEnd);  
17.         int rightPreStart = leftPreEnd;  
18.         int rightPreEnd = preEnd;  
19.         int rightInStart = rootIndex + 1;  
20.         int rightInEnd = inEnd;  
21.                 // 構建右子樹  
22.         root.right = reConstructBinaryTree0(pre, rightPreStart, rightPreEnd, in, rightInStart, rightInEnd);  
23.         return root;  
24.     }  
25.         // 找下標  
26.     public int indexOf(int[] array, int start, int end, int value) {  
27.         for (int i = start; i < end; i++) {  
28.             if (array[i] == value) {  
29.                 return i;  
30.             }  
31.         }  
32.         return -1;  
33.     }  
34. }  

解法：有兩個棧，棧1和棧2.當入棧的時候，我們將它全放進棧1中，當需要出棧的時候，我們將棧1出棧到棧2中，然後再將棧2依次出棧。出完棧之後，再把stack2中的數pop出push到stack1，接受下次的操作。所以入棧的時候，思路很簡單，注意到要將int型別轉為Integer型別，我們使用了new Integer(int);當需要出棧的時候，我們用API提供的方法while(stack1.isEmpty())來將所有棧1的元素壓入棧2中，然後將棧2彈出就可以。這裡又涉及到將Integer的型別轉為int型別的方法Integer.intValue();

1. import java.util.Stack;  
2. publicclass Solution {  
3.     Stack<Integer> stack1 = new Stack<Integer>();  
4.     Stack<Integer> stack2 = new Stack<Integer>();  
5.     publicvoid push(int node) {  
6.         stack1.push(new Integer(node));  
7.     }  
8.     publicint pop() {  
9.         int pop;  
10.         while (!stack1.isEmpty()) {  
11.             stack2.push(stack1.pop());  
12.         }  
13.         pop=stack2.pop().intValue();  
14.         while(!stack2.isEmpty()){  
15.             stack1.push(stack2.pop());  
16.         }  
17.         return pop;  
18.     }  
19. }  

1. public static int minOfShiftedArray(int[] x){  
2.         if(x==null||x.length==0){  
3.             return -1;  
4.         }  
5.         int len=x.length;  
6.         int low=0;  
7.         int high=len-1;  
8.         if(x[low]<x[high]){//if the array is not shifted actually,e.g. {1,2,3,4,5}  
9.             return x[low];  
10.         }  
11.         int mid=0;  
12.         while(low<high){  
13.             mid=(low&high)+(low^high)/2;  
14.             if(mid==low){//if there are only two elements left  
15.                 return x[low]<=x[high]?x[low]:x[high];  
16.             }  
17.             if(x[mid]>=x[low]){  
18.                 low=mid;  
19.             }else{  
20.                 high=mid;  
21.             }  
22.         }  
23.         return x[mid];  
24.     }