1. 程式人生 > >劍指offer(二)java

劍指offer(二)java

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. }  
2.輸入某二叉樹的前序遍歷和中序遍歷的結果,請重建出該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。例如輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6},則重建二叉樹並返回。
  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. }  
3.用兩個棧來實現一個佇列,完成佇列的Push和Pop操作。 佇列中的元素為int型別。

解法:有兩個棧,棧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. }  
4.把一個數組最開始的若干個元素搬到陣列的末尾,我們稱之為陣列的旋轉。
輸入一個非遞減排序的陣列的一個旋轉,輸出旋轉陣列的最小元素。
例如陣列{3,4,5,1,2}為{1,2,3,4,5}的一個旋轉,該陣列的最小值為1。
NOTE:給出的所有元素都大於0,若陣列大小為0,請返回0。
  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.     }