数据结构-动态数组

最新推荐文章于 2024-05-07 20:00:07 发布
最新推荐文章于 2024-05-07 20:00:07 发布
阅读量132 收藏
点赞数
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59115382/article/details/122499058
版权
本文介绍了动态数组在数据结构中的应用，详细讲解了双端栈、队列的定义及其实现，包括ArrayDoubleEndStack、ArrayQueue、ArrayLoopQueue类的设计。此外，还探讨了队列如何实现栈的功能以及双端队列ArrayDeque的特性。
摘要由CSDN通过智能技术生成

 

目录

1动态数组

1.1双端栈

 1.1.1双端栈的定义

          1.1.2ArrayDoubleEndStack类

1.2队列

         1.2.1队列的定义 

1.2.2Queue队列接口的定义 

1.2.3 ArrayQueue类

1.3队列实现栈

1.3.1QueTostack类

1.4循环队列ArrayLoopQueue 

1.4.1循环队列ArrayLoopQueue的定义

1.4.2ArrayLoopQueue类 

1.5双端队列 

1.5.1双端队列的定义 

1.5.2ArrayDeque类 

1动态数组

1.1双端栈

 1.1.1双端栈的定义

是指将一个线性表的两端当做栈底分别进行入栈和出栈操作 主要利用了栈“栈底位置不变，而栈顶位置动态变化” 的特性。

1.1.2ArrayDoubleEndStack类

package P2.线性结构;
import java.util.Iterator;
//双端栈
public class ArrayDoubleEndStack<E> implements Iterable<E> {
    //左端栈的栈顶
    private int ltop;
    //右端栈的栈顶
    private int rtop;
    //存储元素的容器
    private E[] data;
    //数组容器的默认容量
    private static int DEFAULT_CAPACITY = 10;

    public ArrayDoubleEndStack() {
        data = (E[]) new Object[DEFAULT_CAPACITY];
        ltop = -1;
        rtop = data.length;
    }

    public void pushLeft(E element) {
        if (ltop + 1 == rtop) {
            resize(data.length * 2);
        }
        data[++ltop] = element;
    }

    public void pushRight(E element) {
        if (ltop + 1 == rtop) {
            resize(data.length * 2);
        }
        data[--rtop] = element;
    }

    private void resize(int newLen) {
        E[] newData = (E[]) new Object[newLen];
        //复制左端栈的元素
        for (int i = 0; i <= ltop; i++) {
            newData[i] = data[i];
        }
        //复制右端栈的元素
        int index = rtop;
        for (int i = newLen - sizeRight(); i < newLen; i++) {
            newData[i] = data[index++];
        }
        rtop = newLen - sizeRight();
        data = newData;
    }

    public E popLeft() {
        if (isLeftEmpty()) {
            throw new IllegalArgumentException("left stack is null");
        }
        E ret = data[ltop--];
        if (sizeLeft() + sizeRight() <= data.length / 4 && data.length > DEFAULT_CAPACITY) {
            resize(data.length / 2);
        }
        return ret;
    }

    public E popRight() {
        if (isRightEmpty()) {
            throw new IllegalArgumentException("right stack is null");
        }
        E ret = data[rtop++];
        if (sizeLeft() + sizeRight() <= data.length / 4 && data.length > DEFAULT_CAPACITY) {
            resize(data.length / 2);
        }
        return ret;
    }

    public E peekLeft() {
        if (isLeftEmpty()) {
            throw new IllegalArgumentException("left stack is null");
        }
        return data[ltop];
    }

    public E peekRight() {
        if (isRightEmpty()) {
            throw new IllegalArgumentException("right stack is null");
        }
        return data[rtop];
    }

    public boolean isLeftEmpty() {
        return ltop == -1;
    }

    public boolean isRightEmpty() {
        return rtop == data.length;
    }

    public int sizeLeft() {
        return ltop + 1;
    }

    public int sizeRight() {
        return data.length - rtop;
    }

    @Override
    public String toString() {
        // 1 2 3       7 8 9
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isLeftEmpty() && isRightEmpty()) {
            sb.append(']');
            return sb.toString();
        }
        //先搞左边
        for (int i = 0; i <= ltop; i++) {
            sb.append(data[i]);
            if (i == ltop && isRightEmpty()) {
                sb.append(']');
                return sb.toString();
            } else {
                sb.append(',');
            }
        }
        //后搞右边
        for (int i = rtop; i < data.length; i++) {
            sb.append(data[i]);
            if (i == data.length - 1) {
                sb.append(']');
            } else {
                sb.append(',');
            }
        }
        return sb.toString();
    }

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

    class ArrayDoubleEndStackIterator implements Iterator<E> {
        private ArrayList<E> list;
        private Iterator<E> it;

        public ArrayDoubleEndStackIterator() {
            list = new ArrayList<>();
            for (int i = 0; i <= ltop; i++) {
                list.add(data[i]);
            }
            for (int i = rtop; i < data.length; i++) {
                list.add(data[i]);
            }
            it = list.iterator();
        }

        @Override
        public boolean hasNext() {
            return it.hasNext();
        }

        @Override
        public E next() {
            return it.next();
        }
    }
}

1.2队列

1.2.1队列的定义 

 队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表 我们把允许删除的一端称为队首（front），插入的一端称为队尾（rear） 不含任何数据元素的队列称为空队列 队列是一种先进先出（First In Last Out）的线性表，简称FIFO 队列本身是一个线性表，其数据元素具有线性关系，只不过它是一种特殊的线性表而已 队列的插入操作，叫作入队 队列的删除操作，叫作出队

1.2.2Queue队列接口的定义 

package P1.接口;

    public interface Queue<E> extends Iterable<E> {
        public void offer(E element);   //入队
        public E poll();    //出队
        public E peek();    //查看队首元素
        public boolean isEmpty();
        public void clear();
        public int size();
    }

 

1.2.3 ArrayQueue类

package P2.线性结构;

import P1.接口.Queue;

import java.util.Iterator;

public class ArrayQueue<E> implements Queue<E> {
    private ArrayList<E> list;
    public ArrayQueue() {
        list = new ArrayList<>();
    }

    @Override
    public void offer(E element) {
        list.add(list.size(), element);
    }

    @Override
    public E poll() {
        return list.remove(0);
    }

    @Override
    public E peek() {
        return list.get(0);
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public void clear() {
        list.clear();
    }

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }

    @Override
    public String toString() {
        return list.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (this == o) {
            return true;
        }
        if (o instanceof ArrayQueue) {
            ArrayQueue other = (ArrayQueue) o;
            return list.equals(other.list);
        }
        return false;
    }
}

1.3队列实现栈

1.3.1QueTostack类

package P2.线性结构;
import P1.接口.Stack;
import java.util.Iterator;
public class QueueToStack {
    public static void main(String[] args) {
        StackImplByQueue<Integer> stack = new StackImplByQueue<>();
        System.out.println(stack);
        for (int i = 1; i <= 5; i++) {
            stack.push(i); //队列A
        }
        System.out.println(stack.toString());
        System.out.println(stack.pop());
        System.out.println(stack);  //队列B

    }
}
class StackImplByQueue<E> implements Stack<E> {
    private ArrayQueue<E> queueA;
    private ArrayQueue<E> queueB;

    public StackImplByQueue() {
        queueA = new ArrayQueue<>();
        queueB = new ArrayQueue<>();
    }

    @Override
    public int size() {
        if (queueA.isEmpty() && queueB.isEmpty()) {
            return 0;
        } else if (!queueA.isEmpty()) {
            return queueA.size();
        } else {
            return queueB.size();
        }
    }

    @Override
    public boolean isEmpty() {
        return queueA.isEmpty() && queueB.isEmpty();
    }

    @Override
    public void push(E element) {
        if (queueA.isEmpty() && queueB.isEmpty()) {
            queueA.offer(element);
        } else if (!queueA.isEmpty()) {
            queueA.offer(element);
        } else {
            queueB.offer(element);
        }
    }

    @Override
    public E pop() {
        if (isEmpty()) {
            return null;
        }
        E ret = null;
        if (!queueA.isEmpty()) {
            while (queueA.size() != 1) {
                queueB.offer(queueA.poll());
            }
            ret = queueA.poll();
        } else {
            while (queueB.size() != 1) {
                queueA.offer(queueB.poll());
            }
            ret = queueB.poll();
        }
        return ret;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        E ret = null;
        if (!queueA.isEmpty()) {
            while (queueA.size() != 1) {
                queueB.offer(queueA.poll());
            }
            ret = queueA.poll();
            queueB.offer(ret);
        } else {
            while (queueB.size() != 1) {
                queueA.offer(queueB.poll());
            }
            ret = queueB.poll();
            queueA.offer(ret);
        }
        return ret;
    }

    @Override
    public void clear() {
        queueA.clear();
        queueB.clear();
    }

    @Override
    public Iterator<E> iterator() {
        if (isEmpty()) {
            return queueA.iterator();
        } else if (!queueA.isEmpty()) {
            return queueA.iterator();
        } else {
            return queueB.iterator();
        }
    }
    @Override
    public String toString() {
        if (isEmpty()) {
            return "[]";
        } else if (!queueA.isEmpty()) {
            return queueA.toString();
        } else {
            return queueB.toString();
        }
    }

}

1.4循环队列ArrayLoopQueue 

1.4.1循环队列ArrayLoopQueue的定义

该循环队列的实现思想也是动态数组 但是由于操作元素的特殊性，并不能直接由ArrayList或ArrayQueue实现 所以从头开始定义ArrayLoopQueue 

 

1.4.2ArrayLoopQueue类 

 

package P2.线性结构;

import P1.接口.Queue;
import java.util.Iterator;
//循环队列
public class ArrayLoopQueue<E> implements Queue<E> {
    private E[] data;   //存储数据的容器
    private int front;  //队首指针(实际上就是数组中的索引角标)
    private int rear;   //队尾指针
    private int size;   //元素的个数 (f < r  r-f ; r < f  r+L-f)
    private static int DEFAULT_CAPACITY = 10;   //默认容量
    public ArrayLoopQueue() {
        data = (E[]) new Object[DEFAULT_CAPACITY + 1];
        front = 0;
        rear = 0;
        size = 0;
    }
    @Override
    public void offer(E element) {
        //满了没
        if ((rear + 1) % data.length == front) {
            resize(data.length * 2 - 1);
        }
        data[rear] = element;
        rear = (rear + 1) % data.length;
        size++;
    }
    @Override
    public E poll() {
        //空不空
        if (isEmpty()) {
            throw new IllegalArgumentException("queue is null");
        }
        E ret = data[front];
        front = (front + 1) % data.length;
        size--;
        if (size <= (data.length - 1) / 4 && data.length - 1 > DEFAULT_CAPACITY) {
            resize(data.length / 2 + 1);
        }
        return ret;
    }

    @Override
    public E peek() {
        return null;
    }

    private void resize(int newLen) {
        E[] newData = (E[]) new Object[newLen];
        int index = 0;
        for (int i = front; i != rear; i = (i + 1) % data.length) {
            newData[index++] = data[i];
        }
        data = newData;
        front = 0;
        rear = index;
    }

    @Override
    public boolean isEmpty() {
        return front == rear;
    }

    @Override
    public void clear() {
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
        front = 0;
        rear = 0;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
            return sb.toString();
        }
        for (int i = front; i != rear; i = (i + 1) % data.length) {
            sb.append(data[i]);
            if ((i + 1) % data.length == rear) {
                sb.append(']');
            } else {
                sb.append(',');
                sb.append(' ');
            }
        }
        return sb.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (this == o) {
            return true;
        }
        if (o instanceof ArrayLoopQueue) {
            ArrayLoopQueue<E> other = (ArrayLoopQueue<E>) o;
            if (size != other.size) {
                return false;
            }
            int i = front;
            int j = other.front;
            while (i != rear) {
                if (!data[i].equals(other.data[j])) {
                    return false;
                }
                i = (i + 1) % data.length;
                j = (j + 1) % other.data.length;
            }
            return true;
        }
        return false;
    }

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

    class ArrayLoopQueueIterator implements Iterator<E> {
        private int cur = front;

        @Override
        public boolean hasNext() {
            return cur != rear;
        }

        @Override
        public E next() {
            E ret = data[cur];
            cur = (cur + 1) % data.length;
            return ret;
        }
    }
}

1.5双端队列 

1.5.1双端队列的定义 

双端队列（double ended queue ，deque） 是限定插入和删除操作在表的两端进行的线性表 是一种具有队列和栈的性质的数据结构 

1.5.2ArrayDeque类 

package p2.线性结构;
import p1.接口.Queue;
import java.util.Iterator;

public class ArrayQueue<E> implements Queue<E> {
    private ArrayList<E> list;
    public ArrayQueue() {
        list = new ArrayList<>();
    }

    @Override
    public void offer(E element) {
        list.add(list.size(), element);
    }

    @Override
    public E poll() {
        return list.remove(0);
    }

    @Override
    public E element() {
        return list.get(0);
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public void clear() {
        list.clear();
    }

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }

    @Override
    public String toString() {
        return list.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (this == o) {
            return true;
        }
        if (o instanceof ArrayQueue) {
            ArrayQueue other = (ArrayQueue) o;
            return list.equals(other.list);
        }
        return false;
    }
}

 

阿汤绝不秃头
关注
数据结构--数组和链表
赤兔胭脂小吕布的博客
12-20 656
数据结构主要可以分为两大模块： 线性结构 非线性结构 本文主要开始讲线性结构。 什么是线性结构 线性结构，顾名思义，就是这些数据所有节点都能被一根线(指针)联系起来的一种结构。 线性结构的存储方式： 连续存储：【数组】 离散存储：【链表】 线性结构的常见应用方式： 栈 队列 专题 :【递归】 数组和链表 本小节学习数组和链表，从底层去了解和实现数组与链表，并分析两者对应的优缺点 数组...
数据结构 -- 动态数组
sdjn_lyn的博客
01-30 1358
线性表定义 0个或多个数据元素的有限序列 理解：相同类型的元素之间是有顺序的，第一个元素只有一个后继节点，没有前驱节点，最后一个元素只有一个前驱节点，没有后继节点，其他元素各有一个前驱节点和后继节点 抽象数据类型 ADT 线性表（List） Data 数据元素之间满足线性表的定义 Operation InitList(*L) // 初始化操作，建立一个空的线性表 Lis...
数据结构中的动态数组模版类
04-26
动态数组模版类 拆分了动态数组的各个函数的算法 包含：插入，删除、增加、获取长度、查询、遍历
初学数据结构--动态数组
weixin_34106122的博客
07-30 391
2019独角兽企业重金招聘Python工程师标准>>> ...
数据结构：动态数组
soulmate______的博客
04-08 397
数组 数组的定义：数组是具有一定顺序关系的若干对象组成的集合，组成数组的对象称为数组元素 int[,] a = new int[2, 3]; //定义一个两行散列的数组 //静态数组 int[][] b = new int[2][]; //定义行数，列数可变 数组名表示群体的共性，即具有同一种数据类型 下标表示个体的个性，即各自占有独立的单元 数组的存储 n维数组的定义 ...
数据结构——动态数组
m0_54235152的博客
05-14 405
数据结构 一、数组 简单的时间复杂度分析 O：运行时间和输入数据之间的关系（渐进时间复杂度） O(1)：线性关系 O(n^2)：T=knn+b
【数据结构】动态数组
像雾像雨又像风_的博客
08-18 350
1.头文件DynamicArray.h #ifndef DYNAMIC_ARRAY_H #define DYNAMIC_ARRAY_H #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; #include &lt;string.h&gt; //定义存储int数据类型的动态数组 //首先要有存放数据的地址 int* data //其次要记录当前...
数据结构--数组、单链表和双链表介绍以及双向链表 数组和链表.pdf
04-18
数据结构--数组、单链表和双链表介绍以及双向链表 数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。数组、链表是两种常见的数据结构，下面将对它们进行介绍。 一、数组 数组是数据结构中的一...
数据结构-树状数组的构建示例(C++实现)
11-09
数据结构：树状数组的构建示例，包含构造函数、查询、更新、打印操作，还有调用示例。是用C++实现的。
算法-数据结构- 树状数组.rar
09-16
树状数组，也被称为线段树...总结，树状数组是一种强大的数据结构，尤其在处理动态区间查询和更新的问题时表现出高效性能。了解并掌握树状数组的原理和应用，对于提升编程技能和解决复杂算法问题具有重要意义。
数据结构---动态数组
最新发布
qq_51647149的博客
05-07 977
数据结构之动态数组的实现
数据结构之动态数组
段渣渣推轮子的飙车场
07-11 362
版权声明：未经允许，随意转载，请附上本文链接谢谢（づ￣3￣）づ╭❤～ 数据结构之动态数组 实现动态数组的关键方法是 resize方法 private void resize(int newCapacity) { E[] newData = (E[]) new Object[newCapacity]; for (int i = 0; i &amp;lt;...
数据结构--动态数组ArrayList （一）
九曜
02-25 468
以下是学习恋上数据结构与算法的学习笔记，本篇主要内容是Java实现动态数组 ◼ 数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合。 ◼精心选择的数据结构可以带来更高的运行或者存储效率，所以在实际应用中，往往会根据使用场景来选择最合适的数据结构。 ◼线性表是最基本、最简单、也是最常用的一种数据结构（数组，链表，栈，队列，哈希表等）。 线性表是具有n个相同类...
数据结构与算法 —— 动态数组
05-27 1097
一、基础与细节1. 扩容策略无论是 C++ STL 中的向量 vector 还是 Java Collections 中的 ArrayList，采用的扩容策略是_capacity <<= 1，以保证 O(1)O(1) 的分摊时间复杂度。2. remove(lo, hi)remove(lo, hi)的计算成本，主要消耗于后续元素的前移，线性正比于后缀的长度，而与被删除区间的长度无关（_size 控制最终
数据结构入门——动态数组
SpringWar的专栏
08-05 1362
数组的一大缺点就是长度定义后不能再改变，此程序实现了动态数组，类似于Java中的ArrayList的结构，有增、删、排序、遍历、扩容追加等功能。 动态数组的实现： /* 2013年2月16日19:18:35 此程序将数组中的元素进行追加、删除、排序、遍历输出等操作。 与java中的各方法相同，从而更加深入理解java中的方法。 */ # include # include
数据结构之动态数组(集合)
又是重名了
10-21 487
我看了看慕课网上的视频，对于视频的东西进行一个整理，最开始我们先从最基础的数组开始. 我们知道Java中的数组是只能存储基本类型,我们在这里可以制作一个可以存储对象的数组,其实也就是集合，我们就是自己去写一个集合。 首先，我们要定义我们的集合的底层，我们这个集合的底层就是数组，为了规范我们将底层和数组的大小里面存储的书=数的数量设置为private形式，用户不需要去能够使用到底层的知识，他们也不需...
数据结构-数组深度解析
"数据结构不挂科-4-数组 .pdf" 本文主要讲解了数据结构中的核心概念——数组，包括数组的类型定义、顺序表示和实现，以及稀疏矩阵的压缩存储方法。数组作为一种基础且重要的数据结构，是程序设计中不可或缺的部分。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值