数据结构与算法之表、栈、队列

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

1、表

这里指的表是形如A0、A1......An的一般的表。将大小为0的特殊表称为空表。除空表外的任何表，我们说Ai后继Ai-1并称Ai-1前驱Ai。

表的简单数组实现

设定数组的初始长度为10：int [] arr = new int[10];

扩展数组：

int [] new  Arr = new int(arr.length*2);

许多情况下，数组是表的合适实现，特别是在数组插入后很少修改，查询比较多的情况下。如果要处理删除、插入操作比较多的情况那么需要另外的结构的表：链表。

链表

链表由一系列节点构成，这些节点与数组中的元素不同，不必再内存中相连。每个节点均有后面一个节点的链接。


循环链表：将单链表的首尾相连即成为循环链表。

单链表、双链表比较：

1、单链表增加删除节点简单，缺点是只能从头到尾遍历，只能找到后继，无法找到前驱，也就是只能前进。

2、双链表能够找到前驱和后继，可进可退。

java语言实现数组和链表的操作：arraylist和linkedlist

arraylist实现：

/**
 * 集合arraylist的实现
 */
public class MyArrayList<E> implements Iterable<E> {
    private static final int DEFAULT_CAPACITY = 10;

    private int theSize;
    private E [] theItems;

    public MyArrayList(){
        doClear();
        new ArrayList<E>();
    }

    /**
     * java源码clear的实现
     *
     * protected void removeRange(int fromIndex, int toIndex) {
     *ListIterator<E> it = listIterator(fromIndex);
     *for (int i=0, n=toIndex-fromIndex; i<n; i++) {
     *it.next();
     *it.remove();
     *}
     *}
     */
    private void doClear() {
        theSize = 0;
        //这里的清除数组中元素有错误，ensureCapacity只是将旧的数组的元素赋值给新的数组
        ensureCapacity(DEFAULT_CAPACITY);
    }

    public boolean isEmpty(){
        return theSize==0;
    }

    public void trimToSize(){
        ensureCapacity(size());
    }

    public E get(int idx){
        if(idx<0 || idx>=size()){
            throw new ArrayIndexOutOfBoundsException();
        }
        return theItems[idx];
    }

    public E set(int idx, E newVal){
        if(idx<0||idx>=size()){
            throw new ArrayIndexOutOfBoundsException();
        }

        E old  = theItems[idx];
        theItems[idx] = newVal;
        return old;
    }

    public void ensureCapacity(int capacity) {
        if(capacity<theSize){
            return;
        }
        E [] old = theItems;
        theItems = (E[])new Object[capacity];
        for(int i=0; i<size();i++){
            theItems[i] = old[i];
        }
    }

    public int size(){
        return theSize;
    }

    public void clear(){
        doClear();
    }

    public boolean add(E val){
        add(size(), val);
        return true;
    }

    private void add(int idx, E val){
        //数组中元素满的话扩充数组
        if(theItems.length==size()){
            ensureCapacity(size()*2+1);
        }
        for (int i = theSize; i >idx ; i--) {
            theItems[i] = theItems[i-1];
        }
        theItems[idx] = val;
        theSize++;
    }

    public E remove(int idx){
        if(idx<0||idx>=size()){
            throw  new ArrayIndexOutOfBoundsException();
        }
        
        E removeItems = theItems[idx];
        for(int i=idx;i<size();i++){
            theItems[i] = theItems[i+1];
        }

        theSize--;
        return removeItems;
    }

    @Override
    public Iterator<E> iterator() {
        return new ArrayListIterator();
    }

    private class ArrayListIterator implements Iterator<E> {
        private int current = 0;
        @Override
        public boolean hasNext(){
            return current<size();
        }

        @Override
        public E next() {
            if(!hasNext()){
                throw  new NoSuchElementException();
            }
            return theItems[current++];
        }
        @Override
        public void  remove(){
            MyArrayList.this.remove(--current);
        }
    }
}

linkedList的实现使用双向链表结构：

/**
 * 链表的插入、添加、删除实现
 */
public class MyLinkedList<E> implements Iterable<E> {
    private int theSize;
    private int modCount = 0;
    private Node<E> beginMarker;
    private Node<E> endMarker;

    public int size(){
        return theSize;
    }

    public boolean isEmpty(){
        return theSize==0;
    }

    public boolean add(E ele){
        add(size(), ele);
        return true;
    }

    public E get(int idx){
        return getNode(idx).data;
    }

    public E set(int idx, E newVal){
        //这里应该加上下标是否越界的判断
        Node<E> p = getNode(idx);
        E oldValue = p.data;
        p.data = newVal;
        return oldValue;
    }

    public E remove(int idx){
        return remove(getNode(idx));
    }
    public E remove(Node<E> p ){
        p.nex.pre = p.pre;
        p.pre.nex = p.nex;
        theSize--;
        modCount--;
        return p.data;
    }


    private void add(int idx, E ele) {
        addBefore(getNode(idx,0,size()),ele);
    }

    private void addBefore(Node<E> node, E ele) {
        Node<E> newNode = new Node<E>(ele,node.pre,node);
        newNode.pre.nex = newNode;
        node.pre = newNode;
        theSize++;
        modCount++;
    }

    public Node<E> getNode(int idx){
        return getNode(idx,0,size()-1);
    }
    private Node<E> getNode(int idx, int lower, int upper) {
        Node<E> p = null;
        if(idx<lower || idx>upper){
            throw new IndexOutOfBoundsException();
        }
        //根据下标的位置判断是从链表的前半部分找还是从后半部分找
        if(idx<size()/2){
            p = beginMarker.nex;
            for(int i=0;i<idx;i++){
                p = p.nex;
            }
        }else{
            for (int i = size(); i <idx ; i--) {
                p = p.pre;
            }
        }

        return p;
    }


    @Override
    public Iterator<E> iterator() {
        return new LinkedListIterator();
    }

    private static class Node<E>{

        E data;
        Node<E> pre;
        Node<E> nex;
        public Node(E ele, Node<E> pev, Node<E> next){
            this.data = ele;
            this.pre = pev;
            this.nex = next;
        }
    }

    public MyLinkedList(){
        doClear();
    }

    public void clear(){
        doClear();
    }

    private void doClear(){
        beginMarker = new Node<E>(null,null,null);
        endMarker = new Node<E>(null, beginMarker, null);

        theSize = 0;
        modCount++;
    }

    private class LinkedListIterator implements Iterator<E> {
        private Node<E> current = beginMarker.nex;
        private int expectedModCount = modCount;
        private boolean okToRemove = false;
        @Override
        public boolean hasNext() {
            return current!=endMarker;
        }

        @Override
        public E next() {
            if(modCount!=expectedModCount){
                throw new ConcurrentModificationException();
            }
            if(!hasNext()){
                throw new NoSuchElementException();
            }

            E nextItem = current.data;
            current = current.nex;
            okToRemove = true;
            return nextItem;
        }

        @Override
        public void remove() {

            if(modCount!=expectedModCount){
                throw new ConcurrentModificationException();
            }

            if(!okToRemove){
                throw new IllegalStateException();
            }
            MyLinkedList.this.remove(current.pre);
            expectedModCount++;
            okToRemove = false;
        }
    }
}

2、栈

栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈的顶（top）。对栈的基本操作有push(进栈)和pop（出栈）。

栈的实现一般有两种方法：链式结构、数组。栈的实现是上面的数组和链表实现的简化。


3、队列


队列也是表，使用队列时插入在一端，删除在另一端，也就是先进先出。


队列的基本操作是enqueue(入队)和dequeue(出队)，也就是在表的末端插入一个元素和在取出表的开头的元素。

队列的链表实现

下面的实现是使用双链表实现

/**
 * 队列的实现
 * @param <E>
 */
public class MyQueue<E> {
    private int theSize = 0;
    private Node<E> node;
    private Node<E> beginMarker = null;
    private Node<E> endMarker = null;
    
    public int size(){
        return theSize;
    }
    //队列插入数据
    public boolean enQueue(E ele){
        if(size()==0){
           beginMarker.data = ele;
           beginMarker.next = endMarker;
           endMarker.pre = beginMarker;
        }
        Node<E> newNode = new Node<E>(ele,endMarker,null);
        endMarker.pre.next = newNode;
        newNode.pre = endMarker.pre;
        newNode.next = endMarker;
        endMarker.pre = newNode;
        theSize++;
        return true;
    }

    /**
     * 从队列中取出数据
     * @return
     */
    public E deQueue(){
        Node<E> node = beginMarker.next;
        beginMarker.next = node.next;
        node.next.pre = beginMarker;
        return node.data;
    }
    private static class Node<E> {
        private E data;
        private Node<E> next;
        private Node<E> pre;
        private Node(E ele, Node<E> pre){
            new Node(ele, pre, null);
        }
        private Node(E ele, Node<E> pre, Node<E> next){
            this.data  =ele;
            this.next =next;
            this.pre = pre;
        }
    }
}


淡定-ing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之三讲--表、栈、队列
Areay_GK的博客
02-11 569
关于标题呢。。。就别吐槽我了。。本身文学水平已经豪破天机，各位能看懂的都是大神，看不懂的出门左拐看看眼科。 首先道歉，，阿门，这章的东西本来想跟指针一起讲。奈何废话太多超过篇幅了，但是各位请放心，虽然废话多了点但都是精华。 接下来先讲表。。。。表这个是书上写的  其实应该是链表跟顺序表两样。 先说顺序表： 把他想象成一条很窄的单行线，只能前行不能后退不能并排必须连续（数组）。所以他得形状是
表、栈和队列
weixin_30512089的博客
03-31 76
抽象数据类型（abstract data type， ADT）是带有一组操作的一些对象的集合。对于集合ADT, 可以有像添加（add）、删除（remove）以及包含（contain）这样一些操作。 ArrayList：插入和 删除的花费存在潜在开销。最坏的情况下，在位置0的插入，首先需要将整个数组后移一个位置以空出空间来，而删除第一个元素则需要将表中的所有元素前移一个位置，因此这两种操作最...
表，栈和队列
Bart_G的博客
08-14 846
ADT抽象数据类型　abstract data type,ADT是带有一组操作的一些对象的集合。Java中的Integer,String等就是抽象数据类型。1-表ADT1.1 概念的引入　A0,A1,A2,…,A(N-1)的一般表，我们说这个表的大小是N，我们将为0的表成为空表。1.2 链表链表由一些节点组成，这些节点不必在内存中相连，每个节点均含有表元素和到包含表元素后继节点的链(link)，我们
表、栈、队列
XuDTone的博客
10-10 499
一、抽象数据类型（ADT） 1、抽象数据类型是带有一组操作的一些对象的集合。在ADT的定义中没有地方提到关于这组操作是如何实现的任何解释。诸如表、集合、图以及与它们各自的操作一起形成的这些对象都可以被看作是抽象数据类型。对于集合ADT，可以有像添加、删除以及包含这样一些操作，也可以只要两种操作并和查找。 2、程序中需要对ADT实施操作的任何其他部分可以通过调用适当的方法来进行。 二、表ADT
【数据结构】表、栈和队列
博客
03-15 696
文章目录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​没有前
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
本资源"DataAndAlgorithm_C#数据结构与算法_栈和队列_"专注于这两种基础但关键的数据组织方式：栈和队列，以及它们在C#语言中的实现。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，常被比喻为“堆叠的...
JavaScript数据结构与算法之栈与队列
10-22
JavaScript中的栈和队列是两种基础且重要的数据结构，它们在编程中有着广泛的应用。栈遵循后进先出（LIFO）原则，而...因此，深入理解栈和队列以及其他数据结构与算法，对于提升编程技能和职业发展都有着积极的影响。
C#数据结构与算法揭秘五 栈和队列
09-05
栈和队列是计算机科学中两种基础但极其重要的数据结构，它们在C#编程中也有广泛的应用。本节主要探讨了栈和队列的概念、特点以及在C#中的实现。 首先，栈（Stack）是一种后进先出（LIFO）的数据结构，形象地比喻为...
数据结构：导论、栈与队列
01-20
算法的特征：有穷性（finiteness），确定性（definiteness），输入，输出，有效性/可行性（effectiveness） O表示法表示的是当N->某一值或者无穷大时，斜率的变化。重要的是曲线的形状，而不是具体的曲线的值，因为...
数据结构&算法的栈与队列PPT
04-12
数据结构中的栈与队列是两种基础且重要的抽象数据类型，它们在计算机科学和编程中有着广泛的应用。本篇PPT主要介绍了栈和队列的概念、实现方式以及应用场景。 首先，栈是一种特殊的线性表，它遵循“后进先出”...
数据结构栈和队列（参考代码）
06-18
数据结构栈和队列的课程指导上几实验代码 相抵部分
浅谈表、栈、队列
NameKiller的博客
05-31 439
一、表1.由数组构成的表表可以由简单的数组构成，如：char[A]，每个单元包含着数据内容。                                如果我们需要在表中插入、删除数据时，我们就需要移动整个数组。如我们需要删除A2，删除掉的A2占用了内存，我们就需要把A3，A4往前移，这中操作是很费时的。                            2.链表链表是用结构体把内存块串起...
学习笔记－表、栈和队列
藿香正气的博客
03-10 202
学习资料：《数据结构与算法分析 java语言描述》第三章 表、栈和队列 ADT 抽象数据类型（abstract data type，ADT）是带有一组操作的一些对象的集合。 表ADT 表的简单数据实现 对表的所有操作都可以通过数组来实现。 虽然数组是由固定容量创建的，但在需要的时候可以用双倍的容量创建一个不同的数组。 int[] arr = new int[10]; // 扩大arr int [...
第3章：表、栈和队列
最新发布
weixin_53254469的博客
10-12 541
第三章
数据结构学习笔记：表、栈和队列
Breadcrumb Trails
06-12 949
表、栈和队列 抽象数据类型 概念 抽象数据类型（ Abstract Data Type，ADT）是带有一组操作的一些对象的集合，是数学的抽象。 实例 表、图、集合以及他们各自的操作（添加、删除等）一起形成的对象。 表 ADT 数组实现 连续存储、固定容量 线性时间操作 打印 插入与删除 常数时间操作 查找 链表实现 不连续存储 线性时间操作 查找 打印 常数时间操作 插入...
表、栈、队列 - 数据结构
luoxn28的专栏
10-29 893
1. 链表 记录一下《数据结构与算法分析 - C语言描述》的第3章，表、栈和
数据结构与算法(C++版)：表、栈和队列
日影月痕的博客
06-06 1233
前言本系列博客为学习数据结构与算法过程中的原创笔记，其中代码实现基于C++语言。STL中的向量和表在C++语言的库中包含有公共数据结构的实现，这就是众所周知的标准模版库（Standard Template Library, STL）。表就是STL实现的数据结构之一。 表有两个流行的实现。 vector给出了表的可增长的数组实现。使用vector的优点是长度可自由控制，且在常量的时间里是可索引的。
数据结构之表、栈和队列(一)
yearLittle的博客
04-23 150
本系列博客主要讨论数据结构的一些基本知识，我们先从表、栈和队列入手，进而讨论树结构，以及各种结构在算法中的应用。 介绍抽象数据类型（ADT）的概念； 介绍表ADT和它的一些有效操作； 介绍栈ADT及其实现递归方面的应用； 介绍队列ADT及其在操作系统和算法设计中的应用； 抽象数据类型 在程序设计中，主例程不应超过一页，我们把程序的一些主要逻辑可以切割成不同的模块来实现（module）。每...
线性表、链表、栈、队列的关系
热门推荐
奋斗的程序猿的博客
05-16 1万+
程序员在编程实战操作面前有两个拦路虎，第一个是用递归的思想去解决问题，第二个是数据结构与算法的应用。对于递归，由于其神奇的薄面纱总是然我们觉得难以理解，而大多数递归解法还是需要承担一定的计算负担的，因此我觉得能理解其思想与用法固然好，但是实在无法理解也只能慢慢适应。而对于第二个难题，数据结构与算法基本上每一个程序员都需要了解，因为，算法是解答一个问题的基本逻辑，如果你可以证明这个逻辑是正确的，那接下来的问题就是应该采用什么样的数据结构来保证你的程序能有最高的执行效率，即比较好的时间复杂性，同样内存空间消耗也
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值