背包、队列和栈

最新推荐文章于 2025-03-31 19:47:07 发布
原创 最新推荐文章于 2025-03-31 19:47:07 发布 · 259 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。

Java中的Iterable与Iterator详解

文章目录


三种数据类型：背包（Bag）、队列（Queue）和栈（Stack）。它们的不同之处就在于删除或者访问对象的顺序不同。

算术表达式求值

E.W.Dijkstra 发明了一个非常简单的算法，用到了两个栈（操作数栈、运算符栈）。具体思路：

  • 将操作数压入（push）操作数栈；
  • 将运算符压入运算符栈；
  • 忽略左括号；
  • 在遇到右括号时，弹出一个运算符，弹出所需数量的操作数，并将运算符和操作数的运算结果压入操作数栈。

在处理完最后一个括号后，操作数栈上就只剩一个表达式的值。运算顺序：

(1 + ((2 + 3) * (4 * 5)))
(1 + (5 * (4 * 5)))
(1 + (5 * 20))
(1 + 100)
101

Dijkstra 的双栈算术表达式求值算法

public class Evaluate {
    public static void main(String[] args) {
        Stack<String> ops = new Stack<>();     // 运算符栈
        Stack<Double> vals = new Stack<>();    // 操作数栈
        while (!StdIn.isEmpty()) {
            // readString() 方法使用了 Scanner.next() 来读取字符串
            String s = StdIn.readString();
            if (s.equals("("));
            else if (s.equals("+")) ops.push(s);
            else if (s.equals("-")) ops.push(s);
            else if (s.equals("*")) ops.push(s);
            else if (s.equals("/")) ops.push(s);
            else if (s.equals("sqrt")) ops.push(s);
            else if (s.equals(")")) {
                String op = ops.pop();
                double val = vals.pop();
                if (op.equals("+")) val = vals.pop() + val;
                else if (op.equals("-")) val = vals.pop() - val;
                else if (op.equals("*")) val = vals.pop() * val;
                else if (op.equals("/")) val = vals.pop() / val;
                else if (op.equals("sqrt")) val = Math.sqrt(val);
                vals.push(val);
            } else vals.push(Double.parseDouble(s));
        }
        StdOut.println(vals.pop());
    }
}
中缀到后缀的转换
假设将中缀表达式
a + b * c + (d * e + f) * g
转换成后缀表达式，答案是
abc*+de*f+g*+
后缀表达式
6523+8*+3+*
2+3=5,5*8=40,40+5=45,45+3=48,48*6=288

迭代

我们知道 foreach 语句可以迭代访问集合中的数据，其实它本质上与 while 语句是等价的，看这两组代码：

Stack<String> collection = new Stack<>();

for (String s : collection)
    StdOut.println(s);

Stack<String> collection = new Stack<>();
Iterator<String> i = collection.iterator();

while (i.hasNext()) {
    String s = i.next();
    StdOut.println(s);
}

可迭代的集合的集合数据类型需要：

实现一个 iterator() 方法并返回一个 Iterator 对象；
Iterator 类必须包含两个方法：hasNext()（返回一个 boolean 值）和 next()（返回一个集合中的泛型元素）。

对与可迭代的数据类型，Java 中定义了所需接口 java.lang.Iterable ：

public interface Iterable<Item> {
    Iterator<Item> iterator();
}

我们使用接口机制来指定一个类所必须实现的方法，所以在一个需要迭代的集合中我们必须实现接口中的 iterator() 方法。

Java容器中，所有的 Collection 子类会实现 Iteratable 接口以实现 foreach 功能，Iteratable 接口的实现又依赖于实现了 Iterator 的内部类(参照 LinkedList 中listIterator() 和 descendingIterator() 的 JDK 源码)。

有的容器类会有多个实现Iterator 接口的内部类，通过返回不同的迭代器实现不同的迭代方式。

栈

能够动态调整数组大小的实现（LIFO）
package DataStructureAndAlgorithms.DataStructure;

import java.util.Iterator;

public class ResizingArrayStack<Item> implements Iterable<Item> {
    private Item[] a = (Item[]) new Object[1];
    private int N = 0;
    public boolean isEmpty(){
        return N == 0;
    }
    public int size(){
        return N;
    }

    /**
     * 将栈移动到一个大小为 max 的新数组
     * @param max
     */
    private void resize(int max){
        Item[] temp = (Item[]) new Object[max];
        for (int i = 0; i < N; i++) {
            temp[i] = a[i];
        }
        a = temp;
    }
    private void push(Item item){
        if (N == a.length) {
            resize(2 * a.length);
        }
        a[N++] = item;
    }
    private Item pop(){
        Item item = a[--N];
        a[N] = null;//避免对象游离
        if (N > 0 && N == a.length/4) {
            resize(a.length / 2);
        }
        return item;
    }

    @Override
    public Iterator<Item> iterator() {
        return new ReverseArrayIterator();
    }
    //嵌套类(非静态的嵌套类也称为内部类)可以访问包含它的类的实例变量
    private class ReverseArrayIterator implements Iterator<Item>{

        //支持后进先出的迭代
        private int i = N;
        @Override
        public boolean hasNext() {
            return i > 0;
        }

        @Override
        public Item next() {
            return a[--i];
        }

        @Override
        public void remove() {

        }

    }

    public static void main(String[] args) {
        ResizingArrayStack<String> r = new ResizingArrayStack<>();
        r.push("1");
        r.push("2");
        r.push("3");
        r.pop();
       r.forEach(e -> System.out.println(e));//2 1
    }
}
对象游离

在上面使用 pop() 方法弹出了一个元素，它就不会再被访问了，但数组中的引用仍可以让它继续存在。像这种保存一个不需要的对象的引用的情况就称之为游离。
为了避免游离，我们只需要将弹出的元素值设置为 null，这会覆盖无用的引用，并使系统在该元素使用完毕后回收它的内存。

链表实现（LIFO）

以下程序中，Node 是一个私有嵌套类，我们必须用 static 来表示它是嵌套的；若无 static，将得到一个内部类，这有时候好，有时候也不好。嵌套类是许多编程语言的典型的类型。

注意，嵌套类可以被设计成 private，这很好，因为此时该嵌套类除能够被外部类 Stack 访问外，其他是不可访问的。更为重要的是，因为嵌套类被认为是外部类的一部分，所以不存在产生不可见问题.

当声明一个内部类时，编译器则添加对外部类对象的一个隐式引用，该对象引起内部类对象 的构造。如果外部类的名字是 Outer，则隐式引用就是 Outer.this。

package DataStructureAndAlgorithms.DataStructure;


import java.util.Iterator;

/**
 * 链表实现 LIFO
 *
 * @param <Item>
 */
public class Stack<Item> implements Iterable<Item>{
    private Node first;
    private int N;


    /**
     * 私有嵌套类的一个特点是只有包含它的类能够直接访问它的实例变量
     */
    private class Node {
        Item item;
        Node next;
    }
    public boolean isEmpty() {
        return first == null;
        //写法二
//        return  N == 0;
    }

    public int size(){
        return N;
   }
    //压栈 向栈顶添加元素
    public void push(Item item){
        Node oldFirst = first;
        first = new Node();
        first.item = item;
        first.next = oldFirst;
        N++;
   }
    //弹栈  从栈顶删除元素
    public Item pop(){
        Item item = first.item;
        first = first.next;
        N--;
        return item;
   }

    /**
     * 集合数据类型必须实现一个 iterator() 方法并返回一个 Iterator 对象
     * Iterator 类必须包含两个方法：hasNext() 和 next() （返回集合中的一个泛型元素）
     * @return
     */

    public Iterator<Item> iterator() {
        return new ListIterator();
    }

    private class ListIterator implements Iterator<Item>{

        private Node current = first;
        public boolean hasNext(){
            return current != null;
        }
        public void remove(){}

        public Item next() {
            Item item = current.item;
            current = current.next;
            return item;
        }
    }

    public static void main(String[] args) {
        Stack<String> s = new Stack<>();
       s.push("abc");
       s.push("jagoh");
       s.pop();
        for (String item : s
             ) {
            System.out.println(item);
        }
        System.out.println("(" + s.size() + " left on stack");
    }
}

在这里插入图片描述

队列

链表实现
package DataStructureAndAlgorithms.DataStructure;

import java.util.Iterator;

/**
 * FIFO 队列
 * @param <Item>
 */
public class Queue<Item> implements Iterable<Item>{
    private Node first;//指向最早添加的结点的链接
    private Node last;//指向最近添加的结点的链接
    private int N;

    private class Node{

        Item item;
        Node next;
    }
    public boolean isEmpty(){
        return first == null;
    }
    public int size(){
        return N;
    }
    /**
     * 向表尾添加元素
     * @param item
     */
    public void enqueue(Item item){
        Node oldLast = last;
        last = new Node();
        last.item = item;
        last.next = null;
        if (isEmpty()){
            first = last;
        }else {
            oldLast.next = last;
        }
        N++;

    }

    /**
     * 从表头删除元素
     */
    public Item dequeue(){
        Item item = first.item;
        first = first.next;
        if (isEmpty()){
            last = null;
        }
        N--;
        return item;
    }
    @Override
    public Iterator<Item> iterator() {
        return new ListIterator();
    }
    private class ListIterator implements Iterator<Item>{

        private Node current = first;
        @Override
        public boolean hasNext() {
            return current != null;
        }

        @Override
        public Item next() {
            Item item = current.item;
            current = current.next;
            return item;
        }

        @Override
        public void remove() {

        }
    }

    public static void main(String[] args) {
        Queue<String> queue = new Queue<>();
        queue.enqueue("algha");
        queue.enqueue("lahg");
        queue.enqueue("lahg");
        queue.dequeue();
        for (String item : queue
             ) {
            System.out.println(item);
        }
    }

}

在这里插入图片描述

数组实现
package DataStructureAndAlgorithms.DataStructure.Queue;

/**
 * 数组实现队列（动态调整数组大小）
 */
public class ArrayQueue<Item> {
    private Item[] a = (Item[]) new Object[1];
    private int N = 0;
    public boolean isEmpty(){
        return N == 0;
    }
    public int size(){
        return N;
    }

    /**
     * 将栈移动到一个大小为 max 的新数组
     * @param max
     */
    private void resize(int max){
        Item[] temp = (Item[]) new Object[max];
        for (int i = 0; i < N; i++) {
            temp[i] = a[i];
        }
        a = temp;
    }
    private void enqueue(Item item){
        if (N == a.length) {
            resize(2 * a.length);
        }
        a[N++] = item;
    }
    private Item dequeue(){
        Item item = a[0];
        if (N > 0 && N == a.length/4) {
            resize(a.length / 2);
        }
        System.arraycopy(a, 1, a, 0, a.length - 1);
            return item;
    }
    public static void main(String[] args) {
        ArrayQueue<String> strings = new ArrayQueue<>();
        strings.enqueue("我");
        strings.enqueue("的");
        strings.enqueue("名字");
        strings.enqueue("叫顶级程序员不穿女装");
        strings.enqueue("微博:https://m.weibo.cn/p/1005056186766482");

        System.out.println(strings.dequeue());
        System.out.println(strings.dequeue());
        System.out.println(strings.dequeue());
        System.out.println(strings.dequeue());
        System.out.println(strings.dequeue());
//      System.out.println(strings.dequeue());
    }

}

背包

package DataStructureAndAlgorithms.DataStructure;

import java.util.Iterator;

/**
 * LIFO
 * 顺序不重要
 */
public class Bag<Item> implements Iterable<Item>{
    private Node first;
    private class Node {
        Item item;
        Node next;
    }

    /**
     * 和Stack的 push() 方法相同
     * @param item
     */
    public void add(Item item){
        Node oldFirst = first;
        first = new Node();
        first.item = item;
        first.next = oldFirst;
    }
    @Override
    public Iterator<Item> iterator() {
        return new ListIterator();
    }
    private class ListIterator implements Iterator<Item>{

        private Node current = first;
        @Override
        public boolean hasNext() {
            return current != null;
        }

        @Override
        public Item next() {
            Item item = current.item;
            current = current.next;
            return item;
        }

        @Override
        public void remove() {

        }
    }

    public static void main(String[] args) {
        Bag<String> bag = new Bag<>();
        bag.add("1");
        bag.add("1");
        bag.add("1");
        for (String b : bag){
            System.out.println(b);
        }

    }
}
算法之Java数据结构：背包、队列和栈的全面解析与实践
wj_rdk的博客
04-01 1564
在编程学习的漫漫长路上，每一次对新知识的深入探索都是成长的宝贵机遇。今天，咱们一同深入研究Java中背包、队列和栈这三种基础数据结构，从它们的链表实现到应用场景，再到与数组的对比，希望能和大家共同进步，提升编程技能！
数据结构与算法(1)：背包、队列和栈的实现
elegant coder
01-20 418
本文将介绍三种数据类型，分别是背包(Bag)、队列(Queue)和栈(Stack)。它们的不同之处在于删除或者访问对象的顺序不同。 其次是介绍【链式数据结构】的重要性，特别是经典数据结构【链表】，有了它们我们才能高效实现背包、队列和栈。 集合结构介绍及API 背包 背包是一种不支持从中删除元素的集合数据类型——它的目的就是帮助用例收集元素并迭代遍历所有收集到的元素（用例也可以检查背包是...
背包，队列和栈
Crazy World
07-22 384
泛型 泛型，也叫做参数化类型。 &amp;amp;lt; type &amp;amp;gt;将type定义为一个类型参数，它是一个象征性的占位符，表示的是用例将会使用的某种具体数据类型。type将会在需要时被替换为任意引用数据类型。 注意：泛型的数据类型必须为引用类型，不可以为原始数据类型（如：int，double）。 自动装箱：自动将一个原始数据类型转换为对应的引用类型。 自动拆箱：自动将原始数据类型对应的引用类型转...
背包、队列、栈（附数据类型实现）
昝昝的博客
07-31 1561
背包、队列和栈背包、队列和栈数据类型都非常基础并且应用广泛。API背包背包是一种不支持从中删除元素的集合数据类型，目的是帮助用例收集元素并迭代所有收集到的元素，也是检查背包是否为空，或者获取背包中元素的数量。队列队列是一种基于先进先出（FIFO）策略的集合类型。在实际应用中使用队列的只要原因是在用集合保存元素的同事保存它们的相对顺序：使他们入列顺序和出列顺序相同。栈下压栈（简称栈）是一种基于先进后出
算法之Java数据结构：背包、队列和栈的全面解析
最新发布
wj_rdk的博客
03-31 1523
在编程的学习道路上，每一次对新知识的探索都是成长的宝贵机会。今天，咱们一起深入研究Java中的背包、队列和栈这三种基础数据结构，希望能和大家共同进步，提升编程技能！
算法之Java数据结构：背包、队列和栈的深度探索
wj_rdk的博客
03-31 1173
在编程的学习道路上，每一次深入钻研新的知识领域都是成长的宝贵契机。今天，咱们一同深入学习Java中背包、队列和栈这三种基础数据结构，希望能和大家携手共进，提升编程技能！
简述背包、队列和栈的基本概念
03-23
背包、队列和栈都是计算机科学中常见的数据结构。 背包是一种不支持从中删除元素的集合数据类型，它只支持添加元素。背包的特点是元素的添加顺序不重要，也不会对元素进行排序。 队列是一种先进先出（FIFO）的数据...
算法（一）——背包、队列和栈
冰与火的青春的博客
11-27 514
1.1 API 对于背包、队列和栈这三种数据结构，我们首先学习其API和用例，然后再讨论数据类型的值的所有可能的表示方法以及各种操作的实现。这种模式会反复出现（且数据结构会越来越复杂）。 表1.1泛型可...
1.3 背包、队列与栈
泽阳Alex的博客
05-14 295
背包、队列与栈 1.API 每个API都含有一个无参数的构造函数、一个向集合中添加单个元素的方法、一个测试集合是否为空的方法和一个返回集合大小的方法。Stack和Queue都含有一个能够删除集合中特定元素的方法。三个API如下： 2.泛型 泛型可以存储任意类型的数据，在上面的API中，<Item>记号将Item定义为一个类型参数，表示一个占位符，指某种具体数据类型。如用栈处...
背包、队列、栈（java）
再见天涯
03-09 219
一、背包 （一）概念 背包是一种不支持从中删除元素的集合数据类型，目的是帮助用例收集元素并迭代所有收集到的元素，也可以检查背包是否为空，或者获取背包中元素的数量。背包里面的元素的顺序不确定。儿时的记忆：要理解背包的概念，可以想象一个喜欢收集弹珠球的人。他将所有的弹珠球都放在一个背包里，一次一个，并且会不时在所有的弹珠球中寻找某一颗； （二）代码实现 package com.sgh.algorithm4.datainfrastructure; import java.util.Iterator; impo
算法(2) 背包、队列和栈
weixin_34387284的博客
11-27 125
许多基础数据类型都和对象的集合有关。具体来说，数据类型的值就是一组对象的集合，所有操作都是关于添加、删除或是访问集合中的对象。在本节中，我们将学习三种这样的数据类型，分别是背包(Bag)、队列(Queue)、和栈(Stack). 他们的不同之处在于删除或者访问对象的顺序不同。 一、背包 API: public class Bag<Item> implements Iterab...
算法#07--背包、队列和栈（链表实现）
tclxspy的博客
06-13 2930
介绍了背包、队列和栈三种数据类型，以及如何通过链表实现。
背包 队列 栈
weixin_42373064的博客
12-03 253
API 每份API都含有 一个无参数的构造函数， 一个向集合中添加单个元素的防范， 一个测试集合是否为空的方法 一个返回集合大小的方法。 另Stack和Queue都含有一个能够删除集合中特定元素的方法。 两种java特性：范型，迭代。    泛型：集合类的抽象数据类型的一个关键特征是我们应该可以用他们储存任意类型的数据，java机制能够做到这一点，它被称为泛型，也叫做参数化类...
数据结构（背包、队列和栈）
li123128的博客
02-05 298
　　阅读目录 　　 　　一.背包 　　 　　二.队列 　　 　　三.栈 　　 　　回到顶部 　　 　　一.背包 　　 　　背包是一种不支持从中删除元素的集合数据类型，目的是帮助用例收集元素并迭代所有收集到的元素，也可以检查背包是否为空，或者获取背包中元素的数量。背包里面的元素的顺序不确定。 　　 　　要理解背包的概念，可以想象一个喜欢收集弹珠球的人。他将所有的弹珠球都放在一个背包里，一次一个，并且...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值