java-57-用两个栈实现队列&&用两个队列实现一个栈

转自：http://bylijinnan.iteye.com/blog/1450125

————————————————————————————————————————————

Java代码  

1. import java.util.ArrayList;
2. import java.util.List;
3. import java.util.Stack;
4. /*
5. * Q 57 用两个栈实现队列
6. */
7. public class QueueImplementByTwoStacks {
8. private Stack<Integer> stack1;
9. private Stack<Integer> stack2;
10. QueueImplementByTwoStacks(){
11. stack1=new Stack<Integer>();
12. stack2=new Stack<Integer>();
13. }
14. public Integer poll(){
15. Integer re=null;
16. if(!stack2.empty()){
17. re=stack2.pop();
18. }else{
19. while(!stack1.empty()){//move to stack2 to make stack1 have only one element.Then pop this element.
20. re=stack1.pop();
21. stack2.push(re);
22. }
23. if(!stack2.empty()){
24. re=stack2.pop();
25. }
26. }
27. return re;
28. }
29. public Integer offer(int o){
30. stack1.push(o);
31. return o;
32. }
33. public static void main(String[] args) {
34. QueueImplementByTwoStacks queue=new QueueImplementByTwoStacks();
35. List<Integer> re=new ArrayList<Integer>();
36. queue.offer(1);
37. queue.offer(2);
38. queue.offer(3);
39. re.add(queue.poll());
40. queue.offer(4);
41. re.add(queue.poll());
42. queue.offer(5);
43. re.add(queue.poll());
44. re.add(queue.poll());
45. re.add(queue.poll());
46. System.out.println(re.toString());
47. }
48. }

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

	/*
	 * Q 57 用两个栈实现队列
	 */

public class QueueImplementByTwoStacks {

	private Stack<Integer> stack1;
	private Stack<Integer> stack2;

	QueueImplementByTwoStacks(){
		stack1=new Stack<Integer>();
		stack2=new Stack<Integer>();
	}

	public Integer poll(){
		Integer re=null;
		if(!stack2.empty()){
			re=stack2.pop();
		}else{
			while(!stack1.empty()){//move to stack2 to make stack1 have only one element.Then pop this element.
				re=stack1.pop();
				stack2.push(re);
			}
			if(!stack2.empty()){
				re=stack2.pop();
			}
		}
		return re;
	}
	public Integer offer(int o){
		stack1.push(o);
		return o;
	}

	public static void main(String[] args) {
		QueueImplementByTwoStacks queue=new QueueImplementByTwoStacks();
		List<Integer> re=new ArrayList<Integer>();
		queue.offer(1);
		queue.offer(2);
		queue.offer(3);
		re.add(queue.poll());
		queue.offer(4);
		re.add(queue.poll());
		queue.offer(5);
		re.add(queue.poll());
		re.add(queue.poll());
		re.add(queue.poll());
		System.out.println(re.toString());
	}

}

Java代码  

1. import java.util.LinkedList;
2. /*
3. * Q 57 用两个队列实现一个栈
4. */
5. public class StackImplementByTwoQueues {
6. //use ‘queue1‘ and ‘queue2‘ as a queue.That means only use the method ‘addLast‘ and ‘removeFirst‘.
7. private LinkedList<Integer> queue1;
8. private LinkedList<Integer> queue2;
9. StackImplementByTwoQueues(){
10. queue1=new LinkedList<Integer>();
11. queue2=new LinkedList<Integer>();
12. }
13. public Integer pop(){
14. Integer re=null;
15. if(queue1.size()==0&&queue2.size()==0){
16. return null;
17. }
18. if(queue2.size()==0){
19. while(queue1.size()>0){
20. re=queue1.removeFirst();
21. if(queue1.size()!=0){//do not add the last element of queue1 to queue2
22. queue2.addLast(re);
23. }
24. }
25. }else if (queue1.size()==0){
26. while(queue2.size()>0){
27. re=queue2.removeFirst();
28. if(queue2.size()!=0){//do not add the last element of queue2 to queue1
29. queue1.addLast(re);
30. }
31. }
32. }
33. return re;
34. }
35. public Integer push(Integer o){
36. if(queue1.size()==0&&queue2.size()==0){
37. queue1.addLast(o);//queue2.addLast(o); is also ok
38. }
39. if(queue1.size()!=0){
40. queue1.addLast(o);
41. }else if(queue2.size()!=0){
42. queue2.addLast(o);
43. }
44. return o;
45. }
46. public static void main(String[] args) {
47. StackImplementByTwoQueues stack=new StackImplementByTwoQueues();
48. int tmp=0;
49. stack.push(1);
50. stack.push(2);
51. stack.push(3);
52. tmp=stack.pop();
53. System.out.println(tmp);//3
54. stack.push(4);
55. tmp=stack.pop();
56. System.out.println(tmp);//4
57. tmp=stack.pop();
58. System.out.println(tmp);//2
59. stack.push(5);
60. stack.push(6);
61. tmp=stack.pop();
62. System.out.println(tmp);//6
63. tmp=stack.pop();
64. System.out.println(tmp);//5
65. tmp=stack.pop();
66. System.out.println(tmp);//1
67. }
68. }