表、栈和队列

最新推荐文章于 2022-10-12 20:25:56 发布
最新推荐文章于 2022-10-12 20:25:56 发布
阅读量343 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java 表 栈 队列 代码实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/super_longyu/article/details/50375039
版权

一、表
表有两种实现方式：数组实现和链表实现。
数组实现：表是通过在高端进行插入操作建成，且建成后主要是对表进行访问（查询）操作，而非插入、删除；
!!ArrayList类提供了可增长数组的实现。其优点：对get和set的调用花费常数时间；缺点：新项的插入和现有项的删除代价昂贵（除非变动在末端）。
链表实现：对表的操作主要是插入和删除，访问操作较少。
!!LinkedList类提供了List ADT的双链表实现。其优点：新项的插入和现有项的删除开销小（假设变动项位置已知）；其缺点：不易于做索引，对get的调用代价昂贵。
补充Java Collections API中表的知识点：
（1）Collection接口扩展了Iterable接口。
实现Iterable接口的类可拥有增强的for循环；
实现Iterable接口的集合必须提供iterator方法（返回Iterator类型的对象）。
如果对正在被迭代的集合进行结构上的改变（除非调用迭代器自己的remove方法），那么迭代器将不再合法。

 public static void removeEvensVer2(List<Integer> lst){
     for(Integer x:lst){
        if(x%2==0)
           lst.remove(x);//抛出异常
     }
 }

（2）如果ArrayList的大小有早期估计，那么ensureCapacity可设置容量为足够大的量，避免后期扩展；再有，trimToSize可在所有的添加操作完成后使用，避免浪费空间。
（3）ListIterator扩展了List的Iterator功能。previous和hasPrevious使得对表从后向前遍历。
1.表的数组实现
1）数组是由固定容量创建的，但在需要时，可以扩展其容量；

  int[] arr = new int[10];
  //扩展数组arr
  int[] newArr = new int[arr.length*2];
  for(int i=0;i<arr.length;i++){
      newArr[i] = arr[i];
  }
  arr = newArr;

2）实现代码

public class MyArrayList<Type> implements Iterable<Type> {

    private static final int DEFAULT_CAPACITY = 10;//默认大小
    private int theSize;
    private Type[] theItems;

    public MyArrayList(){
        clear();
    }
    public int size(){
        return theSize;
    }
    public boolean isEmpty(){
        return theSize==0;
    }
    //初始化
    public void clear(){
        theSize = 0;
        ensureCapacity(DEFAULT_CAPACITY);
    }
    //查找
    public Type get(int id){
        if(id>=theSize || id<0){  //注意判断范围
            throw new ArrayIndexOutOfBoundsException();
        }
        return theItems[id];
    }
    //更新
    public Type set(int id,Type t){ //返回被替换的值
        if(id>=theSize || id<0){  //注意判断范围
            throw new ArrayIndexOutOfBoundsException();
        }
        Type old = theItems[id];
        theItems[id] = t;
        return old;
    }
    //删除
    public Type remove(int id){
        if(id>=theSize || id<0){  //注意判断范围
            throw new ArrayIndexOutOfBoundsException();
        }
        Type old = theItems[id];
        for(int i=id;i<theSize-1;i++){
            theItems[i] = theItems[i+1];
        }
        theSize--;
        return old;
    }
    //添加
    public boolean add(Type t){
        add(theSize,t);
        return true;
    }
    public void add(int id,Type t){
        /*while(id>=theItems.length){  //此处有疑问
            ensureCapacity(2*theItems.length);
        }*/
        if(theItems.length == size()){
            ensureCapacity(2*size()+1);
        }
        for(int i=theSize-1;i>=id;i--){
            theItems[i+1] = theItems[i];
        }
        theItems[id] = t;
        theSize++;
    }
    //设置容量
    public void ensureCapacity(int newCapacity){
        if(newCapacity<theSize){  //注意 判断适用性
            return;
        }
        Type[] old = theItems;
        //theItems = new Type[newCapacity];
        theItems = (Type[]) new Object[newCapacity];  //注意 引用新数组 的创建
        for(int i=0;i<theSize;i++){
            theItems[i] = old[i];
        }
    }
    public java.util.Iterator<Type> iterator(){
        return new ArrayListIterator();
    }
    //内部类（编译器编写使内部类对象和外部类对象相关联所需的附加代码）
    private class ArrayListIterator implements java.util.Iterator<Type>{
        private int current = 0;

        public boolean hasNext(){
            //return current!=theSize;
            return current<size();
        }
        public Type next(){
            if(!hasNext()){   //判断
                throw new java.util.NoSuchElementException();
            }
            return theItems[current++];
        }
        public void remove(){
            MyArrayList.this.remove(--current);
        }
    }
}

2.表的链表实现（双链表）

  public class MyLinkedList<AnyType> implements Iterable<AnyType> {
        //Node类是private的，因此数据成员的可见性是无关紧要的。MyLinkedList外面的类不能访问Node类
    private static class Node<AnyType>{
        public AnyType data;
        public Node<AnyType> prev;
        public Node<AnyType> next;

        public Node(AnyType d,Node<AnyType> p,Node<AnyType> n){
            data = d; prev = p; next = n;
        }
    }

    private int theSize;
    private int modCount = 0;//对链表所做改变的次数(add、remove)
    private Node<AnyType> beginMarker;//头节点
    private Node<AnyType> endMarker;//尾节点

    public MyLinkedList(){
        clear();
    }
    //初始化
    public void clear(){
        theSize = 0;
        modCount++;

        beginMarker = new Node<AnyType>(null,null,null);
        endMarker = new Node<AnyType>(null,beginMarker,null);
        beginMarker.next = endMarker;
        /*endMarker = new Node(null,null,null);
        beginMarker = new Node(null,null,endMarker);
        endMarker.prev = beginMarker;*/
    }
    public int size(){
        return theSize;
    }
    public boolean isEmpty(){
        return theSize == 0;
    }
    //添加
    public boolean add(AnyType x){
        add(theSize,x);
        return true;
    }
    public void add(int idx,AnyType x){
        addBefore(getNode(idx),x);
    }
    //查找
    public AnyType get(int idx){
        return getNode(idx).data;
    }
    //更新
    public AnyType set(int idx,AnyType newVal){
        AnyType old = getNode(idx).data;
        getNode(idx).data = newVal;
        return old;
    }
    //删除
    public AnyType remove(int idx){
        return remove(getNode(idx));
    }

    private void addBefore(Node<AnyType> p,AnyType x){
        if(p.prev==null){
            throw new IndexOutOfBoundsException();
        }
        Node<AnyType> q = new Node<AnyType>(x,p.prev,p);
        //p.prev.next = q;
        q.prev.next = q;
        p.prev = q;
        theSize++;
        modCount++;//添加操作，更改值
    }
    private AnyType remove(Node<AnyType> p){
        p.next.prev = p.prev;
        p.prev.next = p.next;
        theSize--;
        modCount++;//删除操作，更改值
        return p.data;
    }
    private Node<AnyType> getNode(int idx){
        Node<AnyType> p;
        if(idx<0||idx>theSize){   //not (theSize-1).
            throw new IndexOutOfBoundsException();
        }
        if(idx<size()/2){  //由前向后遍历
            p = beginMarker.next;
            for(int i=0;i<idx;i++){
                p = p.next;
            }
        }
        else{  //由后向前遍历
            p = endMarker;
            for(int i=theSize;i>idx;i--){
                p = p.prev;
            }
        }
        return p;
    }
    //迭代器(non-Javadoc)
    public java.util.Iterator<AnyType> iterator(){
        return new LinkedListIterator();
    }
    private class LinkedListIterator implements java.util.Iterator<AnyType>{
        private Node<AnyType> current = beginMarker.next;
        private int expectedModCount = modCount;
        private boolean okToRemove = false;

        public boolean hasNext(){
            return current != endMarker;
        }
        public AnyType next(){
            if(expectedModCount != modCount){
                throw new java.util.ConcurrentModificationException();
            }
            if(!hasNext()){
                throw new java.util.NoSuchElementException();
            }
            AnyType d = current.data;
            current = current.next;
            okToRemove = true;
            return d;
        }
        public void remove(){
            if(expectedModCount != modCount){
                throw new java.util.ConcurrentModificationException();
            }
            if(!okToRemove){
                throw new IllegalStateException();
            }
            MyLinkedList.this.remove(current.prev);
            okToRemove = false;
            expectedModCount++;
        }
    }
  }

二、栈
栈的插入和删除只在一个位置操作；
栈是后进先出表；
1.栈的数组实现

 public class MyArrayStack<Type> {

    private static final int DEFAULT_LENGTH = 10;
    private int topOfStack;//栈顶
    private int theSize;
    private Type[] items;

    public MyArrayStack(){
        clear();
    }
    //初始化
    public void clear(){
        theSize = 0;
        topOfStack = -1;
        //items = new Type[DEFAULT_LENGTH];  //error!!
        //items = (Type[]) new Object[DEFAULT_LENGTH];
        ensureArray(DEFAULT_LENGTH);
    }
    //入栈
    public void push(Type t){
        if(theSize>=DEFAULT_LENGTH){
            ensureArray(2*size()-1);
        }
        items[theSize++] = t;
        topOfStack++;
    }
    //出栈
    public Type pop(){
        if(topOfStack<0){
            throw new ArrayIndexOutOfBoundsException();
        }
        theSize--;
        return items[topOfStack--];
    }
    public void ensureArray(int newLength){
        if(newLength<size()){
            return; 
        }
        /*Type[] old = (Type[]) new Object[newLength];
        for(int i=0;i<theSize;i++){
            old[i] = items[i];
        }
        items = old;*/
        Type[] old = items;
        items = (Type[]) new Object[newLength];
        for(int i=0;i<theSize;i++){
            items[i] = old[i];
        }
    }
    public int size(){
        return theSize;
    }
    public boolean isEmpty(){
        return theSize==0;
    }
   }
   //下面是两个应用：进制转换和符号匹配检测
    /**
     * 进制转换
     * num:十进制数 ；n:进制数
     * @param args
     */
    public String conver(int num,int n){
        MyArrayStack<Integer> stack = new MyArrayStack<Integer>();
        while(num!=0){
            stack.push(num%n);
            num = num/n;
        }
        StringBuilder sb = new StringBuilder();
        while(stack.size()>0){
            sb.append(stack.pop());
        }
        return sb.toString();
    }
    /**
     * 检测 符号 是否匹配：([])
     * @param args
     */
    public boolean isMatch(String str){
        MyArrayStack<Character> test = new MyArrayStack<Character>();
        char[] chs = str.toCharArray();
        for(char ch:chs){
            if(test.size()==0 && (ch=='('||ch=='[')){
                test.push(ch);
            }
            else if(test.size()==0){
                    return false;
            }
            else{
                char temp = test.pop();
                if(temp=='(' && ch==')'){

                }
                else if(temp=='[' && ch==']'){

                }
                else{
                    test.push(temp);
                    test.push(ch);
                }
            }
        }
        return test.isEmpty();
    }

2.栈的链表实现（单链表）

public class MyLinkedStack<Type> {
        //私有内部类
    private class Node<Type>{
        public Type data;
        public Node<Type> next;
        public Node(Type data,Node<Type> next){
            this.data = data;
            this.next = next;
        }
        public Node(){
            data = null;
            next = null;
        }
    }
    //数据域
    private int theSize;
    private Node<Type> begin;
    public MyLinkedStack(){
        theSize = 0;
        begin = new Node<Type>(null,null);
    }

    public int size(){
        return theSize;
    }
    public boolean isEmpty(){
        return theSize==0;
    }
    public void push(Type x){
        Node<Type> p = new Node<Type>(x,begin.next);
        begin.next = p;
        theSize++;
    }
    public Type pop(){
        Type old = begin.next.data;
        begin.next = begin.next.next;
        theSize--;
        return old;
    }
   }

三、队列
队列是一种先入先出表；
队列在队头删除元素，在队尾添加元素。
像栈一样，对于每种操作，链表实现和数组实现都给出快速的O(1)运行时间。
1.队列的链表实现

public class MyLinkedQueue<T> {
        //私有内部类
    private class Node{
        public T data;
        public Node next;
        public Node(){
        }
        public Node(T data,Node next){
            this.data = data;
            this.next = next;
        }
    }

    private Node front;//队头
    private Node rear;//队尾
    private int size = 0;

    public MyLinkedQueue(){
        Node p = new Node(null,null);
        front = rear = p;
    }

    /**
     * 队列入队
     * @param data 待入队元素
     * @author yulong
     */
    public void enqueue(T data){
        Node p = new Node(data,null);
        rear.next = p;
        rear = p;
        size++;
    }
    /**
     * 队列出队
     * @return 出队元素
     */
    public T dequeue(){
        if(rear==front){
            return null;
        }
        else{
            Node p = front.next;
            T x = p.data;
            front.next = p.next;
            if(p.next==null)
                rear = front;
            p = null;
            size--;
            return x;
        }
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
   }

2.队列的循环数组实现

public class MyArrayQueue<Type> {

    private final static int FULL = 10;
    private int rear;
    private int front;
    private int size;
    private Type[] theItems;

    public MyArrayQueue(){
        rear = -1;
        front = -1;
        size = 0;
        theItems = (Type[]) new Object[FULL];
    }

    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    public void enqueue(Type x){
        rear++ ;
        theItems[rear%FULL] = x;
        if(size<10){
            size++;
        }else{
            front++;//覆盖
        }
    }
    public Type dequeue(){
        if(rear==front){
            return null;
        }
        else{
            front++;
            front = front%FULL;
            size--;
            return theItems[front];
        }
    }
    }
super_longyu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈和队列PPT
05-23
栈和队列PPT课件，想要了解栈和队列的同学，可以下载一下。
数据结构--表、栈和队列
CringKong的博客
03-09 377
表、栈和队列几乎是最简单也是最基本的三种数据结构，无论是Java中的集合类对应的List，Queue，Set对应的实现类，还是JVM内存结构中的Java栈，操作数栈，亦或Python中的List，甚至操作系统中的栈区，可以说每一个有意义的程序都或多或少的要使用这几种数据结构。 1.表 表（List）是最基本的线性数据结构，所谓线性表，就是有多个数据特性相同的元素构成的有限的序列 举个简单地例子，
第3章：表、栈和队列
weixin_53254469的博客
10-12 515
第三章
数据结构之三讲--表、栈、队列
Areay_GK的博客
02-11 557
关于标题呢。。。就别吐槽我了。。本身文学水平已经豪破天机，各位能看懂的都是大神，看不懂的出门左拐看看眼科。 首先道歉，，阿门，这章的东西本来想跟指针一起讲。奈何废话太多超过篇幅了，但是各位请放心，虽然废话多了点但都是精华。 接下来先讲表。。。。表这个是书上写的  其实应该是链表跟顺序表两样。 先说顺序表： 把他想象成一条很窄的单行线，只能前行不能后退不能并排必须连续（数组）。所以他得形状是
表、栈、队列
cfz751740465的博客
02-20 191
1. 表 List 1.1 List ADT struct Node; typedef struct Node* PtrToNode; typedef PtrToNode List; // 通常用一个节点来代表一个空表 typedef PtrToNode Position; typedef int ElementType; List MakeEmpty( List L ); int IsEmpty( List L); int IsLast(Position P, List L); Position
【数据结构】表、栈和队列
博客
03-15 686
文章目录1.表1.1 表的顺序存储1.2 表的链式存储2. 栈 1.表 将形如A0A_0A0​，A1A_1A1​，A2A_2A2​，… ,An−1A_{n-1}An−1​的数据结构称为表。这个表的大小是N。将大小为0的特殊的表称为空表( empty list)。 对于除空表外的任何表，可以说AiA_iAi​后继Ai−1A_{i-1}Ai−1​，并称Ai−1A_{i-1}Ai−1​前趋AiA_iAi​。表中的第一个元素是A0A_0A0​，而最后一个元素是An−1A_{n-1}An−1​。A0A_0A0​没有前
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
C语言 表、栈和队列详解及实例代码
01-20
C语言 表、栈和队列详解 表ADT  形如A1,A2,A3…An的表，这个表的大小为n，而大小为0的表称为空表，非空表中，Ai+1后继Ai，Ai-1前驱Ai，表ADT的相关操有PrintList打印表中的元素；CreateEmpty创建一个空表；Find...
数据结构栈和队列
04-08
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
字符串 向量 链表 栈和队列
12-04
数据结构中“字符串 向量 链表 栈和队列”等类型的模板实现
数据结构第三章 栈和表
03-24
线性表（Linear list）是最简单且最常用的一种数据结构。这种结构具有下列特点：存在一个唯一的没有前驱的（头）数据元素；存在一个唯一的没有后继的（尾）数据元素；此外，每一个数据元素均有一个直接前驱和一个直接后继数据元素。通过本章的学习，读者应能掌握线性表的逻辑结构和存储结构，以及线性表的基本运算以及实现算法。
堆、列表、队列和栈
Ethan_Apple的专栏
04-11 1万+
堆(Heap)： 首先来讲一讲堆的结构，以下图为例。从根结点开始，每个结点可以有左、右两个结点，元素优先将每一层按从左到右的方式填满，即父结点最多有两个子结点，有右子结点就一定会有左子结点，同一层的某个结点左边一定是填满的。 接下来，说一说堆中元素摆放的规则。堆分为两种情况，有最大堆和最小堆，最小堆就是根结点元素的值是所有元素中最小的，最大堆则相反，下图是一个最小堆。在一个摆放好元素的最小堆中
栈与队列的异同
热门推荐
Allen Liu
05-26 7万+
栈（Stack）和队列（Queue）是两种操作受限的线性表。 （线性表：线性表是一种线性结构，它是一个含有n≥0个结点的有限序列，同一个线性表中的数据元素数据类型相同并且满足“一对一”的逻辑关系。 “一对一”的逻辑关系指的是对于其中的结点，有且仅有一个开始结点没有前驱但有一个后继结点，有且仅有一个终端结点没有后继但有一个前驱结点，其它的结点都有且仅有一个前驱和一个后继结点。） 这种受限表现在
数据结构学习笔记：表、栈和队列
Breadcrumb Trails
06-12 934
表、栈和队列 抽象数据类型 概念 抽象数据类型（ Abstract Data Type，ADT）是带有一组操作的一些对象的集合，是数学的抽象。 实例 表、图、集合以及他们各自的操作（添加、删除等）一起形成的对象。 表 ADT 数组实现 连续存储、固定容量 线性时间操作 打印 插入与删除 常数时间操作 查找 链表实现 不连续存储 线性时间操作 查找 打印 常数时间操作 插入...
数据结构 - 线性表、栈、队列、串
持续学习中
09-24 5679
作者：谭东 最近把之前学过的数据结构和算法部分都重新研究看完了，整理分享一下。 前言感想：之前遇到有人说不要说重复的东西，网上都有了，书里都有这些概念了。我听到之后很诧异，很感叹这个人或者这些人可能没有真正的去学习或者学懂数据结构吧？数据结构是什么？用来干嘛的？逻辑原理意图是什么？其实很多东西不是一进来就要直接学习多么高难度高深的算法什么的，没有基础知识的支撑、没有真正的学懂其思维逻辑，你......
表，栈和队列
Bart_G的博客
08-14 844
ADT抽象数据类型　abstract data type,ADT是带有一组操作的一些对象的集合。Java中的Integer,String等就是抽象数据类型。1-表ADT1.1 概念的引入　A0,A1,A2,…,A(N-1)的一般表，我们说这个表的大小是N，我们将为0的表成为空表。1.2 链表链表由一些节点组成，这些节点不必在内存中相连，每个节点均含有表元素和到包含表元素后继节点的链(link)，我们
浅谈表、栈、队列
NameKiller的博客
05-31 427
一、表1.由数组构成的表表可以由简单的数组构成，如：char[A]，每个单元包含着数据内容。                                如果我们需要在表中插入、删除数据时，我们就需要移动整个数组。如我们需要删除A2，删除掉的A2占用了内存，我们就需要把A3，A4往前移，这中操作是很费时的。                            2.链表链表是用结构体把内存块串起...
表、栈和队列总结
weixin_41938314的博客
12-30 192
抽象数据类型（abstract data type， ADT）是带有一组操作的一些对象的集合。对于集合ADT, 可以有像添加（add）、删除（remove）以及包含（contain）这样一些操作。 上面是权威解释，个人理解抽象数据类型就是有一堆数据的集合，我们可以对其进行增删改查等操作。 一、表 1.1 java中的表结构 在JAVA的list接口，里面又分为ArrayList和Linke...
数据结构栈和队列实验
最新发布
10-08
数据结构中的栈和队列是两种重要的数据结构。栈（Stack）是一种具有特殊限制的线性数据结构，它遵循LIFO（后进先出）原则，即最后进入的元素首先被访问或删除。栈有两个基本操作：压入（push）和弹出（pop）。队列...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值