Queue用数组实现,并实现Iterator。

import java.util.Iterator;
public class QueueArrays<Item> implements Iterable{
    Item[] items= (Item[]) new Object[1];
    int N=0;//控制数组下标
    public int size(){
        return N;
    }
    public boolean isEmpty(){
        return N==0;
    }
    public void resize(int max){
        Item[] temps=(Item[])new Object[max];
        for (int i = 0; i < N; i++) {
            temps[i]=items[i];
        }
        items=temps;
    }
    public void enqueue(Item item){
        items[N++]=item;
        if (N==items.length) resize(items.length*2);
    }
    public Item dequeue(){
        Item item=items[0];
        this.dynamicRegulation();
        N--;
        if (N>0&&N<items.length/4) resize(items.length/2);
        return item;
    }
    //每次dequeue调整item的位置
    public void dynamicRegulation(){
        for (int i = 0; i <items.length-1 ; i++) {
            items[i]=items[i+1];
        }
    }

    @Override
    public Iterator iterator() {
        return new QueueIterator();
    }
    private class QueueIterator implements Iterator{
        int i=0;
        @Override
        public boolean hasNext(){
            return i<=N&&items[i]!=null;
        }
        @Override
        public Item next(){
            return items[i++];
        }
        @Override
        public void remove() {

        }
    }
}
//输入示例
public class TestQueue {
    public static void main(String[] args) {
        QueueArrays qa = new QueueArrays();
        String[] s = {"to", "be", "or", "not", "to", "-", "be", "-", "-", "that", "-", "-", "-", "is"};
        for (String a : s) {
            if (!a.equals("-")) {
                qa.enqueue(a);
            } else if (!qa.isEmpty()) {
                System.out.print(qa.dequeue() + " ");
            }
        }
        System.out.println("(" + qa.size() + "left on queue)");
    }
}

结果为
在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是深度优先搜索和广度优先搜索在 Java 中的实现代码: 深度优先搜索: ```java import java.util.*; public class Graph { private int V; // 节点个数 private LinkedList<Integer>[] adj; // 邻接表 public Graph(int v) { V = v; adj = new LinkedList[V]; for (int i = 0; i < V; ++i) { adj[i] = new LinkedList<Integer>(); } } public void addEdge(int v, int w) { adj[v].add(w); } public void DFS(int v, boolean[] visited) { visited[v] = true; System.out.print(v + " "); Iterator<Integer> i = adj[v].listIterator(); while (i.hasNext()) { int n = i.next(); if (!visited[n]) { DFS(n, visited); } } } public void DFS(int v) { boolean[] visited = new boolean[V]; DFS(v, visited); } public static void main(String[] args) { Graph g = new Graph(4); g.addEdge(0, 1); g.addEdge(0, 2); g.addEdge(1, 2); g.addEdge(2, 0); g.addEdge(2, 3); g.addEdge(3, 3); g.DFS(2); } } ``` 广度优先搜索: ```java import java.util.*; public class Graph { private int V; // 节点个数 private LinkedList<Integer>[] adj; // 邻接表 public Graph(int v) { V = v; adj = new LinkedList[V]; for (int i = 0; i < V; ++i) { adj[i] = new LinkedList<Integer>(); } } public void addEdge(int v, int w) { adj[v].add(w); } public void BFS(int v) { boolean[] visited = new boolean[V]; LinkedList<Integer> queue = new LinkedList<Integer>(); visited[v] = true; queue.add(v); while (queue.size() != 0) { v = queue.poll(); System.out.print(v + " "); Iterator<Integer> i = adj[v].listIterator(); while (i.hasNext()) { int n = i.next(); if (!visited[n]) { visited[n] = true; queue.add(n); } } } } public static void main(String[] args) { Graph g = new Graph(4); g.addEdge(0, 1); g.addEdge(0, 2); g.addEdge(1, 2); g.addEdge(2, 0); g.addEdge(2, 3); g.addEdge(3, 3); g.BFS(2); } } ``` 在上面的代码中,我们使用邻接表来表示有向图,其中 `V` 表示节点个数,`adj` 是一个数组,每个元素 `adj[i]` 是一个链表,表示从节点 `i` 出发可以到达的节点。在深度优先搜索中,我们使用递归来实现,同时需要记录哪些节点已经被访问过,从而避免重复访问。在广度优先搜索中,我们使用队列实现,同样需要记录哪些节点已经被访问过。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值