implement a stack using queue

Use two queues to implement stack.

q2 is used to make sure the new element is always at the front of the q1.


public class Solution {
    Queue<Integer> q1 = new LinkedList<Integer>();
    Queue<Integer> q2 = new LinkedList<Integer>();
	//pop: dequeue in q1
	public void pop() {
        if (q1.peek() == null) {
        	System.out.println("The stack is empty!");
        } else {
        	int pop = q1.remove();
        	return pop;
        }
	}
    //1.dequeue all the items from q1 to q2
    //2.enqueue the new item in q1 
    //3.dequeue all the items in q2 to q1
	public void push(int data) {
		if (q1.peek() == null) {
			q1.add(data);
		} else {
			for (int i = q1.size(); i > 0; i--) {
				q2.add(q1.remove());
			} 
			q1.add(data);


			for (int j = q2.size(); j > 0; j--) {
				q1.add(q2.remove());
			}
		}


	}


}

To find the shortest path from a given starting node s to any other nodes in the (undirected) graph, we can use Breadth-First Search (BFS) algorithm. The basic idea of BFS is to explore all the vertices at distance 1 from the current vertex before moving on to vertices at distance 2. Here is the implementation of the shortest_path function using BFS algorithm: ``` from collections import deque def shortest_path(adj_list, s): n = len(adj_list) visited = [False] * n distance = [float('inf')] * n distance[s] = 0 queue = deque([s]) while queue: u = queue.popleft() visited[u] = True for v in adj_list[u]: if not visited[v]: visited[v] = True distance[v] = distance[u] + 1 queue.append(v) for i in range(n): if not visited[i]: distance[i] = float('inf') return distance ``` In the above code, we first initialize two lists: visited and distance. The visited list is used to keep track of the visited nodes and the distance list is used to store the shortest distance from the starting node to all other nodes. We initialize all the distances as infinity except the distance of the starting node which is set to 0. We then use a deque (double-ended queue) to implement the BFS algorithm. We start by adding the starting node to the queue. Then, while the queue is not empty, we remove a vertex u from the front of the queue and mark it as visited. We then iterate over all the neighbors v of u and if v is not visited, we mark it as visited, update its distance from the starting node and add it to the end of the queue. Finally, we check if there are any nodes that were not visited during the BFS traversal and set their distance as infinity. We then return the distance list. Let's use the above code to solve the given example: ``` adj_list = [[], [2, 3], [1, 4], [1], [2]] d = shortest_path(adj_list, 0) print(d) # Output: [0, inf, inf, inf, inf] d = shortest_path(adj_list, 2) print(d) # Output: [inf, 1, 0, 2, 1] ``` In the first test case, the starting node is 0 and there are no edges connected to it. Hence, the distance to all other nodes is infinity. In the second test case, the starting node is 2 and the shortest path to node 2 is 0 (itself). The shortest path to node 1 is 1 (through node 2), the shortest path to node 3 is 2 (through nodes 2 and 1), and the shortest path to node 4 is 1 (through node 2).
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值