剑指Offer笔记—— 用两个栈实现队列 旋转数组的最小数字

面试题7：用两个栈实现队列

题目大致为：

    用两个栈实现队列的两个函数appendTail和deleteHead。

思路：

    栈的特性是：后进先出，而队列的特性是：先进先出。这里使用两个栈实现队列有点负负得正的意思。栈1负责添加，而栈2负责删除。

Java代码：

[java] view plain copy

1. package org.algorithm.pointtooffer;  
2.   
3. import java.util.Stack;  
4.   
5. /** 
6.  * 面试题7：用两个栈实现队列 
7.  *  
8.  * @author dell 
9.  *  
10.  */  
11.   
12. /** 
13.  * 构造一个类 
14.  *  
15.  * @author dell 
16.  *  
17.  * @param <T>泛型 
18.  */  
19. class CQueue<T> {  
20.     // 两个栈  
21.     private Stack<T> stack1;  
22.     private Stack<T> stack2;  
23.   
24.     public CQueue() {  
25.         this.stack1 = new Stack<T>();  
26.         this.stack2 = new Stack<T>();  
27.     }  
28.   
29.     /** 
30.      * 模拟在队列末尾插入 
31.      *  
32.      * @param node 
33.      */  
34.     public void appendTail(T node) {  
35.         stack1.push(node);  
36.     }  
37.   
38.     /** 
39.      * 模拟删除队列的头 
40.      *  
41.      * @return 
42.      */  
43.     public T deleteHead() {  
44.         if (stack2.size() == 0) {  
45.             if (stack1.size() == 0) {  
46.                 try {  
47.                     throw new Exception("队列为空");  
48.                 } catch (Exception e) {  
49.                     // TODO Auto-generated catch block  
50.                     e.printStackTrace();  
51.                 }  
52.             }  
53.             // stack1 不为空，将stack1中的元素放入stack2中  
54.             while (stack1.size() > 0) {  
55.                 stack2.push(stack1.pop());  
56.             }  
57.         }  
58.         return stack2.pop();  
59.     }  
60. }  
61.   
62. public class Item07 {  
63.   
64.     // 测试  
65.     public static void main(String args[]) {  
66.         // 在队列中增加元素  
67.         CQueue<Integer> cq = new CQueue<Integer>();  
68.         for (int i = 0; i < 5; i++) {  
69.             cq.appendTail(i);  
70.         }  
71.         // 依次取出  
72.         for (int i = 0; i < 5; i++) {  
73.             System.out.print(cq.deleteHead() + "、");  
74.         }  
75.         System.out.println();  
76.         // 此时为空，再取一次，看会不会报错  
77.         cq.deleteHead();  
78.     }  
79. }  

面试题8：旋转数组的最小数字

题目大致为：

    一个递增排序的数组的一个旋转(把一个数组最开始的若干元素搬到数组的末尾，称之为数组的旋转)，输出旋转数组的最小元素。

思路：

    其实旋转过后的数组是部分有序的，这样的数组依然可以使用折半查找的思路求解

Java代码：

[java] view plain copy

1. package org.algorithm.pointtooffer;  
2.   
3. /** 
4.  * 面试题8：旋转数组的最小数字 
5.  *  
6.  * @author dell 
7.  *  
8.  */  
9. public class Item08 {  
10.     public static void main(String args[]) {  
11.         int A[] = { 3, 4, 5, 1, 2 };// 数组A是数组{1,2,3,4,5}的旋转数组  
12.         System.out.println(findMin(A));  
13.     }  
14.   
15.     public static int findMin(int array[]) {  
16.         int low = 0;  
17.         int high = array.length - 1;  
18.         int middle = low;  
19.   
20.         while (array[low] >= array[high]) {  
21.             // 数组中就只有两个数，最小的为后者  
22.             if (high - low == 1) {  
23.                 middle = high;  
24.                 break;  
25.             }  
26.             // 查找中间位置  
27.             middle = (high + low) / 2;  
28.             if (array[middle] >= array[low]) {  
29.                 low = middle;  
30.             } else if (array[middle] <= array[high]) {  
31.                 high = middle;  
32.             }  
33.         }  
34.         return array[middle];  
35.     }  
36. }