算法_栈与队列的Java链表实现

  链表是一个递归的数据结构,它或者为null,或者是指向一个结点的引用,该结点含有一个泛型的元素和指向另一个链表的引用.可以用一个内部类来定义节点的抽象数据类型:

private class Node /*定义节点类*/{
        Item item;
        Node next;
    }

  根据递归的定义,我们只需一个Node类型的变量就能表示一条链表,只要保证它的值是null或者指向另一个Node对象,且该对象的next域指向了另一条链表即可.链表表示的是一列元素,虽然也可以用数组来表示一列元素,但是在链表中插入元素或者从序列中删除元素都十分方便.另外,每个修改链表的操作都需要添加检查是否要修改变量的代码.

  对于链表元素的遍历,可以采用下列方式:

for(Node x=first;x!=null;x=x.next) {
        //处理x.item
}

  对于实现队列和堆栈,上面这种迭代方式是实现迭代器的最基本的方式.实现队列和堆栈通过内部维护一个链表,达到了操作所需的时间总是和集合的大小无关.下面是实现的代码:

import java.util.Iterator;
//链表实现的堆栈
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;
    }
    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;
    }
    @Override
    public Iterator<Item> iterator() {
        return new StackIterator();
    }
    private class StackIterator 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;
        }
    }
}
//链表实现的队列
import java.util.Iterator;
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;}
    public void enquene(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;    //如果列表成为空,那么将尾部元素设为null
        N--;                        //减少元素数目.
        return item;
    }
    @Override
    public Iterator<Item> iterator() {
        return new QueueIterator();
    }
private class QueueIterator 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;
        }
    }
}
时间: 2024-11-08 18:32:46

算法_栈与队列的Java链表实现的相关文章

Java数据结构和算法之栈与队列

二.栈与队列 1.栈的定义 栈(Stack)是限制仅在表的一端进行插入和删除运算的线性表. (1)通常称插入.删除的这一端为栈顶(Top),另一端称为栈底(Bottom). (2)当表中没有元素时称为空栈. (3)栈为后进先出(Last In First Out)的线性表,简称为LIFO表. 栈的修改是按后进先出的原则进行. 每次删除(退栈)的总是当前栈中"最新"的元素,即最后插入(进栈)的元素,而最先插入的是被放在栈的底部,要到最后才能删除. 图1 [示例]元素是以a1,a2,-,a

数据结构之栈和队列及其Java实现

栈和队列是数据结构中非常常见又非常基础的线性表,在某些场合栈和队列使用很多,因此本篇主要介绍栈和队列,并用Java实现基本的栈和队列,同时用两个栈实现队列和用两个队列实现栈. 栈:栈是一种基于"后进先出"策略的线性表.在插入时(入栈),最先插入的元素在栈尾,最后插入的元素在栈顶:在删除时(出栈),最后插入的元素先出栈,最先插入的元素最后出栈.由此可见,对栈的插入和删除操作都是在栈顶位置进行的. 在Java中,提供了一个类Stack<E>来实现栈的这些特性,并提供了一些常用的

栈和队列的Java实现

一.  栈 1.概念 栈是一种特殊的线性表,它只能在栈顶(top)进行插入(push)和删除(pop)操作. 栈的常用操作: 入栈(push):向栈顶插入元素 出栈(pop):从栈顶删除元素 访问栈顶元素(peek):访问栈顶元素 2. 栈的顺序结构的实现 1 public class SequenceStack<T> { 2 3 private Object[] elementData; //数组用于承装元素 4 private int DEFAULT_SIZE = 20; //初始数组默认

数据结构算法(1)--栈与队列

数据结构算法(1)--栈与队列 总结并记录学习数据结构过程中遇到的问题及算法. 一些常见算法: Note: 基础应用. 递归的非递归转化. 阶乘 递归实现: #include <iostream> using namespace std; int F(int n) { if (n == 0 || n == 1) return 1; else return n * F(n - 1); } int main() { int s; cin >> s; int result = F(s);

《啊哈算法》——栈、队列、链表

通过题目我们可以看出这篇文章将介绍什么,栈.队列.链表本质上是数据结构中的东西,通过这章的学习能够给今后数据结构的学习打下一点基础. 队列: 我们通过一个简单的谜题来引入队列的概念,给出一串9位的加密QQ号,对于这串数字,删除第一位数字,然后将第二位数字放到这串数字的最后.反复操作,直到这一串数字的所有数字都被删除.在这个过程中,按照数字删除先后顺序排列的9位数字的便是解密后的QQ号,请问解密后的QQ号是多少? 其实从数学原理的角度,这个问题并没有什么难度,非常好理解,但关键在于,如何通过程序来

用JS描述的数据结构及算法表示——栈和队列(基础版)

前言:找了上课时数据结构的教程来看,但是用的语言是c++,所以具体实现在网上搜大神的博客来看,我看到的大神们的博客都写得特别好,不止讲了最基本的思想和算法实现,更多的是侧重于实例运用,一边看一边在心里隐隐歌颂大神的厉害,然后别人的厉害不是我的,所以到底看得各种受打击+头昏脑涨,写这个系列是希望自己能够总结学到东一块.西一下的知识,因为水平有限+经验不足,所以在此只说最基础的思想,附上我自己的算法实现(肯定还有更优解),如果要想看进阶版的,可以在园里搜“数据结构”,各种语言实现和进阶提升的文章有很

数据结构和算法之栈和队列一:两个栈模拟一个队列以及两个队列模拟一个栈

今天我们需要学习的是关于数据结构里面经常看到的两种结构,栈和队列.可以说我们是一直都在使用栈,比如说在前面递归所使用的的系统的栈,以及在链表倒序输出时介绍的自定义栈类Stack和使用系统的栈进行递归.那么,在这里我们就讲述一下这两个比较具有特色的或者说关系比较紧密的数据结构之间的互相实现问题. 一:两个栈模拟实现一个队列: 栈的特点是先进后出,然而队列的特点是先进先出. public class Queen(Stack s1,Stack s2){ //实现插入的方法 public void ad

浅析栈与队列在java中的基本应用

一.前提 摘自java程序设计教程(华盛顿大学/斯坦福大学著,陈志等译)-机械工业出版社 1.1栈/队列基础 像线性表一样,栈与队列中存储一组有序的值.这类数据结构至少需要支持下面几种操作: 将值放入数据结构中(添加操作): 将值从数据结构中取出(删除操作): 检查数据结构中是否还有值(判断数据结构是否为空). 栈与队列很相似:都是以某种特定的顺序存储元素序列.栈是一种先进先出/LIFO(LAST IN FIRST OUT)的结构,也就是最后保存到结构中的元素会最先被访问.队列则是一种先进先出/

栈,队列,单链表,双向链表

1. 定义头文件 实现栈方法的定义,注意这里用到了全局的静态数组,可以通过这种方式保护数据. main.c,实现存储 队列,创建头文件queue.h 创建queue.c 实现main函数 单链表 在定义头文件的时候,最好使用: #ifndef 变量A #define变量A 函数声明和结构声明等声明 #endif 通过上面的这种方式可以避免重复调用头文件时候产生的负面影响. 定义头文件link.h:(注意加上extern) 定义link.c 编写main.c 4.双向链表 创建link.h头文件