用数组实现线性表、栈、队列：

最新推荐文章于 2022-03-13 12:36:09 发布
最新推荐文章于 2022-03-13 12:36:09 发布
阅读量208 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangpupu320/article/details/88921725
版权

先定义好线性表接口List：
package 动态数组;
/*
java中数组的特点
1.长度一旦确定不能被修改 //扩容
2.存储空间连续而且大小相等时间复杂度 o(1)
3.只有一个数组
*/
//线性表：
public interface List {
public int getSize();//获取列表中元素的个数
public boolean isEmpty();//判断当前链表是否为空
public void add(int index,E e);//在指定角标index处添加元素e
public void addFirst(E e);//在第一个位置添加元素e
public void addLast(E e);//在最后一个第一个位置添加元素e
public E get(int index);//获取列表中指定角标位置的元素
public E getFirst();//获取列表中第一个位置的元素
public E getLast();//获取列表中最后一个位置的元素
public E remove(int index);//删除列表中指定角标位置的元素并返回
public E removeFirst();//删除列表中第一个位置的元素并返回
public E removeLast();//删除列表中最后一个位置的元素并返回
public void set(int index,E e);//修改列表中指定角标index位置的元素为新元素e
public void setFirst(E e);//修改列表中第一个位置的元素为新元素e
public void setLast(E e);//修改列表中指定角标index位置的元素为新元素e
public boolean contains(E e);//判断列表中是否包含指定元素e
public int find(E e);//获取线性表中元素e从头到尾第一次出现位置
public void removeElement(E e);//在列表指定位置上删除元素e
public void clear();
}

栈接口：
public interface stack {
public int getSize();//获取栈中元素的个数
public boolean isEmpty();//判断栈是否为空
public void push(E e);//将指定元素e进栈
public E pop();//出栈一个元素
public E peek(); //获取当前栈顶元素
public void clear();//清空栈
}

队列接口：
public interface queue {
public int getSize(); //获取队列的元素个数
public boolean isEmpty(); //判断队列是否为空
public void enqueue(E e); //将指定元素e入队
public E dequeue(); //出队一个元素
public E getFront(); //获取队首元素
public E getRear(); //获取队尾元素
public void clear();//清空
}

@@@@@@@@@@@@@@@@@@@ArrayList类实现List接口@@@@@@@@@@@@
package 动态数组;
//增删o(n) 改查o(1)
//动态数组实现的线性表–>顺序表
//动态数组实现的线性表->顺序衿

/* List

  • ——ArrayList

  • 增删O(n) 改查O(1)

  • 1.元素是否排序＿没有

  • 2.元素是否允许重复？允访

  • 3.元素是否允许空值？允许

  • 4.元素是否有序？元素的进场顺序和出场顺序一臿

  • /
    public class ArrayList implements List{
    private E[] data; //容器-存储元素 data.length 最大容量
    private int size; //当前列表中元素的个数 有效长度
    private static final int DEFAULT_CAPACITY=10;
    public ArrayList(){ //默认构造函数中创建一个容量为10的列衿
    this(DEFAULT_CAPACITY);
    }
    public ArrayList(int capacity){ //构造函数中创建一个容量为capacity的列衿
    if(capacity<0){
    capacity=DEFAULT_CAPACITY;
    }
    this.data=(E[]) new Object[capacity];
    this.size=0;
    }
    //O(n)
    public void add(int index, E e) {
    if(index<0||index>size){
    throw new IllegalArgumentException(“角标非法！”);
    }
    if(size==data.length){//满了
    resize(data.length    2);//重置容量
    }
    for(int i=size;i>index;i–){//给index位置插入元素时候
    data[i]=data[i-1];
    }
    data[index]=e;
    size++;
    }
    //O(n)
    public void addFirst(E e) {
    add(0,e);
    }
    //O(1)
    public void addLast(E e) {
    add(size,e);
    }
    //O(n)
    public E remove(int index) {//删除
    if(index<0||index>=size){
    throw new IllegalArgumentException(“角标非法”);
    }
    E res=data[index];//将index对应角标先拿出来

      for(int i=index;i<size-1;i++){
  	data[i]=data[i+1];
  }
  size--;
  if(size==data.length/4&&data.length>DEFAULT_CAPACITY){
  	resize(data.length/2);
  }
  return res;

    }
    //O(n)
    public E removeFirst() {
    return remove(0);
    }
    //O(1)
    public E removeLast() {
    return remove(size-1);
    }
    //O(n)
    @Override
    public void removeElement(E e) {
    int index=find(e);//O(n)
    if(index!=-1){
    remove(index);//O(n)
    }
    }
    //O(n)
    private void resize(int newLen) {
    E[] newData=(E[]) new Object[newLen];
    for(int i=0;i<Math.min(data.length,newData.length);i++){
    newData[i]=data[i];
    }
    data=newData;
    }
    //O(1)
    public int getSize() {
    return this.size;
    }
    public boolean isEmpty() {
    return this.size==0;
    }
    //O(1)
    public E get(int index) {
    if(index<0||index>=size){
    throw new IllegalArgumentException(“角标不存在！”);
    }
    return data[index];
    }
    public E getFirst() {
    return get(0);
    }
    public E getLast(){
    return get(size-1);
    }
    //O(1)
    public void set(int index, E e) {
    if(index<0||index>=size){
    throw new IllegalArgumentException(“角标不存在！”);
    }
    data[index]=e;
    }

    public void setFirst(E e) {
    set(0,e);
    }

    public void setLast(E e) {
    set(size-1,e);
    }
    //O(n)
    public int find(E e) {//找元素e并返回角标
    for(int i=0;i<size;i++){
    if(data[i]e){
    return i;
    }
    }
    return -1;
    }
    public boolean contains(E e) {
    return find(e)!=-1;
    }
    public int getCapacity(){
    return data.length;
    }
    public void clear() {
    this.data=(E[]) new Object[DEFAULT_CAPACITY];
    this.size=0;
    }
    public void swap(int i,int j){
    if(i<0||i>=size||j<0||j>=size){
    throw new IllegalArgumentException(“角标非法”);
    }
    E temp=data[i];
    data[i]=data[j];
    data[j]=temp;
    }
    @Override
    public String toString() {
    StringBuilder sb=new StringBuilder();
    if(isEmpty()){
    sb.append(String.format(“ArrayList:[] %d/%d \n”, size,data.length));
    }else{
    sb.append(“ArrayList:[”);
    for(int i=0;i<size;i++){
    if(i    size-1){
    sb.append(data[i]+"]");
    }else{
    sb.append(data[i]+",");
    }
    }
    sb.append(String.format(" %d/%d \n", size,data.length));

      }
  return sb.toString();

    }
    }
    @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

@@@@@@@@@@@@@ArrayStack类实现stack接口@@@@@@@@@@@@@@@@
package 动态数组;
public class ArrayStack implements stack {
private ArrayList list;//对ArrayList进行封装
public ArrayStack(){
this(10);
}
public ArrayStack(int capacity){
list=new ArrayList<>(capacity);
}

@Override
public String toString() {//打印数组
StringBuilder sb=new StringBuilder();
if(isEmpty()){
sb.append(String.format(“ArrayStack:bottom[]top %d/%d \n”,getSize(),getCapacity()));
}else{
sb.append(“ArrayList [”);
for(int i=0;i<list.getSize();i++){
if(ilist.getSize()-1){
sb.append(list.get(i)+"]");
}else{
sb.append(list.get(i)+",");
}
}
sb.append(String.format("%d/%d \n", getSize(),getCapacity()));
}
return sb.toString();
}
private Object getCapacity() {
return list.getCapacity();
}
@Override
public void push(E e) {
list.addLast(e);
}
@Override
public E pop() {
return list.removeLast();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
public int getSize() {
return list.getSize();
}
@Override
public void clear() {
list.clear();
}
public void pop(E e) {
}
@Override
public E peek() {
// TODO Auto-generated method stub
return null;
}
}
@@@@@@@@@@用ArrayStackDoubleEnd实现Stack接口@@@@@@@@@@@@
package 动态数组;
//双端栈
import java.util.Arrays;
public class ArrayStackDoubleEnd implements stack{
private E[] data;
private int left;
private int right;
public static final int L=0;
public static final int R=1;
private int size;
public ArrayStackDoubleEnd() {
this(10);
}
public ArrayStackDoubleEnd(int capacity){
data=(E[]) new Object[capacity];
left=-1;
right=data.length;
size=0;
}
public void push(int which,E e){
//婊?sizedata.length left+1=right
if(sizedata.length){
throw new IllegalArgumentException("");
//resize
}
if(whichL){
data[++left]=e;
}else{
data[–right]=e;
}
size++;
}
public E pop(int which){
if(isEmpty(which)){
throw new IllegalArgumentException("");
}
size–;
//resize
if(whichL){
return data[left–];
}else{
return data[right++];
}
}
public int getCapacity(){
return data.length;
}
public int getSize(int which){
if(whichL){
return left+1;
}else{
return data.length-right;
}
}
public E peek(int which){
if(isEmpty(which)){
throw new IllegalArgumentException("");
}
if(whichL){
return data[left];
}else{
return data[right];
}
}
public boolean isEmpty(int which){
if(whichL){
return left==-1;
}else{
return rightdata.length;
}
}
public void clear(int which){
if(whichL){
left=-1;
}else{
right=data.length;
}
}
public void push(E e) {
if(sizedata.length){
throw new IllegalArgumentException("");
}
if(getSize(L)<=getSize®){
push(L,e);
}else{
push(R,e);
}
}
public E pop() {
if(getSize(L)>=getSize®){
return pop(L);
}else{
return pop®;
}
}
public E peek() {
if(getSize(L)>=getSize®){
return peek(L);
}else{
return peek®;
}
}
public boolean isEmpty() {
return left-1&&rightdata.length&&size0;
}
public int getSize() {
return size;
}
public void clear() {
left=-1;
right=data.length;
size=0;
}
@Override
public String toString() {
return Arrays.toString(data);
}
}
@@@@@@@@@@@ArrayQueenLoop类实现queen接口@@@@@@@@@@@@@@@
package 动态数组;
//循环队列
public class ArrayQueueLoop implements queue {
private E[] data;
private int front;
private int rear;
private int size;
public ArrayQueueLoop() {
this(10);
}
public ArrayQueueLoop(int capacity){
data=(E[]) new Object[capacity+1];
size=0;
front=0;
rear=0;
}
public int getSize() {
return size;
}
public boolean isEmpty() {
return frontrear;
}
public void enqueue(E e) {
if((rear+1)%data.lengthfront){
throw new IllegalArgumentException("");
}
data[rear]=e;
rear=(rear+1)%data.length;
size++;
}
public E dequeue() {
E res=getFront();
front=(front+1)%data.length;
size–;
return res;
}
public E getFront() {
if(isEmpty()){
throw new IllegalArgumentException("");
}
return data[front];
}
public E getRear() {
if(isEmpty()){
throw new IllegalArgumentException("");
}
if(rear0){
return data[data.length-1];
}else{
return data[rear-1];
}
}
public void clear() {
front=0;
rear=0;
size=0;
}
@Override
public String toString() {
if(isEmpty()){
return “[]”;
}
StringBuilder sb=new StringBuilder("[");
for(int i=front;i!=rear;i=(i+1)%data.length){
if((i+1)%data.lengthrear){
sb.append(data[i]+"]");
}else{
sb.append(data[i]+",");
}
}
return sb.toString();
}
}

一只有梦想的咸鱼。
关注
用C语言实现基于数组的线性表
qq_39835949的博客
03-14 555
线性表是计算机科学中的一种基本数据结构，通常用于存储有序的数据元素。线性表具有插入、删除和查询元素的操作，以及动态扩展和缩减容量的能力。线性表的实现方式有很多种，比如数组、链表、栈、队列等等。本文将用C语言实现一个基于数组的线性表，实现元素的插入、删除和查询功能。在指定位置插入元素：O(n)删除指定位置的元素：O(n)查询指定位置的元素：O(1)空间复杂度：O(n)
作业1 - 线性表栈队列数组.pdf
12-07
线性表、栈、队列和数组是计算机科学中基础且重要的数据结构，它们在算法设计和程序实现中起着核心作用。以下是这些概念的详细解释： **线性表**： 线性表是最基本的数据结构之一，它是一个有序的数据序列，可以...
Java-用数组实现栈-队列-线性列表
07-13
Java-用数组实现栈-队列-线性列表（最详细） 有注释 适合java新生 进行数组的练习 3个数据结构的数组实现练习
用数组实现栈和队列
qq_45255031的博客
08-24 168
队列（Queue）：是限定只能在bai表的一端du进行插入和在另一端进行删除操作的线性表zhi； 栈（Stack）：是限定只能在表的一端进dao行插入和删除操作的线性表。 区别如下： 一、规则不同 队列：先进先出（First In First Out）FIFO 栈：先进后出（First In Last Out ）FILO 二、对插入和删除操作的限定不同 队列：只能在表的一端进行插入，并在表的另一端进行删除； 栈：只能在表的一端插入和删除。 三、遍历数据速度不同 队列：基于地址指针进行遍历，而且可以从头部或
数组实现栈和队列
Bruce yang‘s blog
08-23 518
文章目录数组实现栈和队列1.栈和队列1.1使用数组实现栈的流程1.2使用数组实现队列的流程 数组实现栈和队列 1.栈和队列 栈(stack)是一个后进先出(Last in first out,LIFO)的线性表，它要求只在表尾进行删除和插入操作。 a.栈的元素必须后进先出 b.栈的操作只能在这个线性表的表尾进行 c.对于栈来说，这个表尾成为栈的栈顶(top),相应的表头称为栈底(bottom) 1.1使用数组实现栈的流程 首先定义一个变量index和固定大小为size的数组arr，当有数据进入时就压入栈中，
用数组实现堆栈和队列
zzobin的专栏
12-15 887
前期讨论了用链表去实现堆栈和队列，这次使用数组来实现。主要部分还是一样：堆栈对一端ip操作，队列对两端ipHead和ipTail操作。           首先看看堆栈，实现代码如下： public class ArryStack {  private int ip  = 0;  private int [] data = new int [10];    public void pu
数组实现线性表-VS2015.zip_数组实现线性表格
最新发布
09-24
在VS2015（Visual Studio 2015）这样的集成开发环境中，我们可以创建C++项目来实现数组线性表。以下是一些关键步骤和知识点： 1. **声明数组**：首先，我们需要声明一个足够大的数组来存储线性表中的元素。例如，...
线性表栈队列的所有源文件
11-08
5. **源文件分析**：这个压缩包中的源文件很可能是用某种编程语言（如C、C++或Java）编写的，包含了对线性表、栈和队列的各种操作的实现。通过阅读和理解这些源代码，开发者可以深入学习这些数据结构的内部工作机制...
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
线性表操作 栈和队列的应用 多维数组和串
06-28
顺序存储的线性表和运算 链式存储的线性表和运算 顺序栈的实现和运算 链栈的实现和运算 顺序队列的实现和运算 链式队列的实现和运算 循环队列的实现和运算
使用数组实现栈和队列
Pichairen
09-21 1004
一、数组实现栈： 1、使用一个类实现，该类私有成员有m_top、m_size、m_buffer 分别表示数组中栈顶位置、数组初始空间大小、指向该数组的指针。 2、该类的成员函数包括：isEmpty、isFull、push、pop、top、clearStack、stackLength 3、实现思路： 1、构造函数：初始化数组大小，m_top指向0位置，每次push元素都直接装进m_Top位置...
数组实现 栈 和队列
我思故我在
10-26 242
package 算法; /** * 数组实现 */ public class test3 { /** * 数组实现 栈 */ public static class ArrStack{ public int size = 0; public int capacity = 0; public int[] arr =null; //初始化栈容量 public ArrStack(int .
用数组来实现栈和队列的数据结构
超悦人生
09-01 188
用数组来实现栈和队列的数据结构
基于数组实现: 栈 队列
Smartbbbb的博客
03-13 708
* 栈和队列实现: * 1.双向链表实现 * 2.数组实现 * * 基于数组实现 public class StackOrQueueBaseOnArray { /** * 数组实现栈: * 1.只要满了报异常 * 2.没满保证正确性 */ public static class ArrayStack{ private int index; private final...
用数组实现栈和队列，以及栈和队列的相互实现
weixin_44470438的博客
04-13 486
1.用数组实现栈 栈：先进后出 //用数组实现栈 //1.压栈 //2.出栈 //3.判断栈是否为空 public class Stack { //首先需要一个数组以及栈的空间大小 private int[] arr; private int size; private int cur; public Stack(int size) { a...
Java数组实现栈和队列
XuJiangDong
11-21 819
队列实现： package com.example.javabase.test; /** * @author XuJD * @create 2019-11-21 10:11 * 基于数组实现队列 **/ public class Queue3 { /** * 队列 */ private String[] data; /** * 队列最...
使用数组实现栈和循环队列(JAVA语言）
马靖的个人技术博客
11-05 2064
这篇文章将讲述两个问题。一是如何使用数组实现一个栈，栈的大小可以伸缩。二是使用数组实现一个队列，为了充分的利用数组的空间，这里实现一个循环，构成循环队列。 （1）基于数组实现栈 package com.datastructure.stack; import java.util.*; public class MyStack { private Object[] array=nu
用数组结构实现大小固定的栈和队列
BarryLee的博客
03-06 933
用数组结构实现大小固定的栈和队列，这是一个面试的常考题目，也是一个比较简单的题目。1.实现栈结构：栈结构是先进后出的，只需要一个数组和一个记录位置的变量size，当进来一个元素，size就++，出去一个元素size就--。2.实现队列结构：相对栈结构要难搞一些，队列的先进先出的，需要一个数组和三个变量，size记录已经进来了多少个元素，in记录刚进来的元素应该放在哪个位置，out表示用户要求弹出的...
Java高级数据结构详解：数组、线性表、栈与队列操作
Java中提供了多种队列实现，如LinkedList的子类（如Dequeue），只允许在队首和队尾进行添加（enqueue）和移除（dequeue）操作。队列常用于任务调度、消息传递等场景。 掌握这些高级数据结构对于编写高效、可维护的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值