【算法编程】数组、栈和队列间的实现

最新推荐文章于 2022-04-22 19:41:48 发布
最新推荐文章于 2022-04-22 19:41:48 发布
阅读量290 收藏
点赞数
分类专栏： 算法编程 文章标签： 算法编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Daycym/article/details/100192150
版权

一、用数组结构实现大小固定的栈

  • 栈：先进后出
    在这里插入图片描述

Java代码：

package day02;

public class Code01_Array2Stack {	
	public static class ArrayStack{
		private Integer[] arr;
		private Integer index;
		
		public ArrayStack(int initSize) {
			if(initSize < 0) {
				throw new IllegalArgumentException("初始化长度小于0");
			}
			
			arr = new Integer[initSize];
			index = 0;
		}
		
		public Integer peek() {
			if(index == 0) {
				return null;
			}
			return arr[index - 1];
		}
		
		public void push(int obj) {
			if(index == arr.length) {
				throw new ArrayIndexOutOfBoundsException("栈满了");
			}
			arr[index++] = obj;
		}
		public Integer pop() {
			if (index == 0) {
				throw new ArrayIndexOutOfBoundsException("栈空了");
			}
			return arr[--index];
		}
	}
	
	public static void main(String[] args) {
		ArrayStack as = new ArrayStack(5);
		as.push(1);
		as.push(2);
		as.push(3);
		as.push(4);
		as.push(5);
		//as.push(5);
		System.out.println(as.peek());
		System.out.println(as.pop());
	}
}

二、用数组结构实现大小固定的队列

  • 队列：先进先出

在这里插入图片描述

Java代码：

package day02;

public class Code02_Array2Queue {
	public static class ArrayQueue{
		private Integer[] arr;
		private Integer size;
		private Integer start;
		private Integer end;
		
		public ArrayQueue(int initSize) {
			if(initSize < 0) {
				throw new IllegalArgumentException("初始化长度小于0");
			}
			arr = new Integer[initSize];
			size = 0;
			start = 0;
			end = 0;
		}
		
		public Integer peek() {
			if(size == 0) {
				return null;
			}
			return arr[start];
		}
		
		public void push(int obj) {
			if(size == arr.length) {
				throw new ArrayIndexOutOfBoundsException("队列满了");
			}
			size++;
			arr[end] = obj;
			end = (end == arr.length) ? 0 : (end + 1);  //设定end
		}
		
		public Integer poll() {
			if(size == 0) {
				throw new ArrayIndexOutOfBoundsException("队列空了");
			}
			size--;
			int tmp = start;
			start = (start == arr.length) ? 0 : start + 1;
			return arr[tmp];
		}
	}

	public static void main(String[] args) {
		ArrayQueue aq = new ArrayQueue(3);
		aq.push(1);
		aq.push(2);
		aq.push(3);
		//aq.push(4);
		System.out.println(aq.peek());
		System.out.println(aq.poll());
	}

}

三、仅用队列结构实现栈结构

在这里插入图片描述
Java代码：

package day02;

import java.util.LinkedList;
import java.util.Queue;

public class Code03_TwoQueues2Stack {
	public static class TwoQueuesStack{
		private Queue<Integer> data;
		private Queue<Integer> help;
		
		//构造函数
		public TwoQueuesStack() {
			data = new LinkedList<Integer>();
			help = new LinkedList<Integer>();
		}
		
		public void push(int obj) {
			data.add(obj);
		}
		
		public int peek() {
			if(data.isEmpty()) {
				throw new RuntimeException("栈空了");
			}
			while(data.size() != 1) {
				help.add(data.poll());
			}
			int res = data.poll();
			help.add(res);
			swap();
			return res;
		}
		
		public int pop() {
			if(data.isEmpty()) {
				throw new RuntimeException("栈空了");
			}
			while(data.size() != 1) {
				help.add(data.poll());
			}
			int res = data.poll();
			swap();
			return res;
		}
		
		private void swap() {
			Queue<Integer> tmp = help;
			help = data;
			data = tmp;
		}
	}

	public static void main(String[] args) {
		TwoQueuesStack tqs = new TwoQueuesStack();
		tqs.push(1);
		tqs.push(2);
		tqs.push(3);
		System.out.println(tqs.peek());
		System.out.println(tqs.pop());
		System.out.println(tqs.pop());
		System.out.println(tqs.pop());
		//tqs.pop();
	}
}

四、仅用栈结构实现队列结构

在这里插入图片描述
Java代码：

package day02;

import java.util.Stack;

public class Code04_TwoStacks2Queue {
	public static class TwoStacksQueue{
		private Stack<Integer> stackPush;
		private Stack<Integer> stackPop;
		
		public TwoStacksQueue() {
			stackPush = new Stack<Integer>();
			stackPop = new Stack<Integer>();
		}
		
		public void push(int obj) {
			stackPush.push(obj);
		}
		
		public int poll() {
			if(stackPop.empty() && stackPush.empty()) {
				throw new RuntimeException("队列空了");
			}else if(stackPop.empty()) {
				while(!stackPush.empty()) {
					stackPop.push(stackPush.pop());
				}
			}
			return stackPop.pop();
		}
		
		public int peek() {
			if(stackPop.empty() && stackPush.empty()) {
				throw new RuntimeException("队列空了");
			}else if(stackPop.empty()) {
				while(!stackPush.empty()) {
					stackPop.push(stackPush.pop());
				}
			}
			return stackPop.peek();
		}
	}

	public static void main(String[] args) {
		TwoStacksQueue twq = new TwoStacksQueue();
		twq.push(1);
		twq.push(2);
		twq.push(3);
		System.out.println(twq.peek());
		System.out.println(twq.poll());
		System.out.println(twq.poll());
		System.out.println(twq.poll());
	}

}

五、练习

1、特殊的栈

实现一个特殊的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作。

  • 要求
    1．pop、push、getMin操作的时间复杂度都是O(1)
    2．设计的栈类型可以使用现成的栈结构

在这里插入图片描述

Java代码：

package day02;

import java.util.Stack;

public class Code05_GetMinStack {
	public static class MyStack{
		private Stack<Integer> stackData;
		private Stack<Integer> stackMin;
		
		public MyStack() {
			this.stackData = new Stack<Integer>();
			this.stackMin = new Stack<Integer>();
		}
		
		public void push(int obj) {
			if(this.stackMin.isEmpty()) {
				this.stackMin.push(obj);
			}else if(obj < this.getmin()) {
				this.stackMin.push(obj);
			}else {
				int newMin = this.stackMin.peek();
				this.stackMin.push(newMin);
			}
			this.stackData.push(obj);
		}
		
		public int pop() {
			if(this.stackData.isEmpty()) {
				throw new RuntimeException("栈空了");
			}
			this.stackMin.pop();
			return this.stackData.pop();
		}
		
		public int getmin() {
			if (this.stackMin.isEmpty()) {
				throw new RuntimeException("栈空了");
			}
			return this.stackMin.peek();
		}
	}

	public static void main(String[] args) {
		MyStack ms = new MyStack();
		ms.push(3);
		ms.push(1);
		ms.push(2);
		System.out.println(ms.getmin());
		System.out.println(ms.pop());
		System.out.println(ms.getmin());
	}
}

在这里插入图片描述
Java代码：

package day02;

import java.util.Stack;

public class Code05_GetMinStack {
	public static class MyStack{
		private Stack<Integer> stackData;
		private Stack<Integer> stackMin;
		
		public MyStack() {
			this.stackData = new Stack<Integer>();
			this.stackMin = new Stack<Integer>();
		}
		
		public void push(int obj) {
			if(this.stackMin.isEmpty()) {
				this.stackMin.push(obj);
			}else if(obj <= this.getmin()) {
				this.stackMin.push(obj);
			}
			this.stackData.push(obj);
		}
		
		public int pop() {
			if(this.stackData.isEmpty()) {
				throw new RuntimeException("栈空了");
			}
			int value = this.stackData.pop();
			if(value == this.getmin()) {
				this.stackMin.pop();
			}
			return value;
		}
		
		public int getmin() {
			if (this.stackMin.isEmpty()) {
				throw new RuntimeException("栈空了");
			}
			return this.stackMin.peek();
		}
	}

	public static void main(String[] args) {
		MyStack ms = new MyStack();
		ms.push(3);
		ms.push(1);
		ms.push(2);
		System.out.println(ms.getmin());
		System.out.println(ms.pop());
		System.out.println(ms.getmin());
	}
}
2、猫狗队列

宠物、狗和猫的类如下：

public class Pet { 
	private String type;
	public Pet(String type) { 
		this.type = type; 
	}
	public String getPetType() {
		return this.type; 
	}
}
public class Dog extends Pet { 
	public Dog() { 
		super("dog"); 
	} 
}
public class Cat extends Pet { 
	public Cat() { 
		super("cat"); 
	} 
}
  • 实现一种狗猫队列的结构，要求如下：
  1. 用户可以调用 add 方法将 cat类 或 dog类 的实例放入队列中；
  2. 用户可以调用 pollAll 方法，将队列中所有的实例按照进队列的先后顺序依次弹出；
  3. 用户可以调用 pollDog 方法，将队列中 dog类 的实例按照进队列的先后顺序依次弹出；
  4. 用户可以调用 pollCat 方法，将队列中 cat类 的实例按照进队列的先后顺序依次弹出；
  5. 用户可以调用 isEmpty 方法，检查队列中是否还有 dog 或 cat 的实例；
  6. 用户可以调用 isDogEmpty 方法，检查队列中是否有 dog类 的实例；
  7. 用户可以调用 isCatEmpty 方法，检查队列中是否有 cat类 的实例

在这里插入图片描述

Java代码：

package day02;

import java.util.LinkedList;
import java.util.Queue;

public class Code06_DogCatQueue {
	//宠物类
	public static class Pet {
		private String type;  //类型（私有变量）

		public Pet(String type) {
			this.type = type;
		}

		public String getPetType() {
			return this.type;
		}
	}
	//狗类继承宠物类
	public static class Dog extends Pet {
		public Dog() {
			super("dog");  //调用父类的有参构造方法
		}
	}
	//猫类继承宠物类
	public static class Cat extends Pet {
		public Cat() {
			super("cat");
		}
	}
	
	//进队列的宠物
	public static class EnterQueuePet {
		private Pet pet;
		private long count;
		//初始化
		public EnterQueuePet(Pet pet, long count) {
			this.pet = pet;
			this.count = count;
		}
		//获取宠物
		public Pet getPet() {
			return this.pet;
		}
		//获取宠物进队列时的标号
		public long getCount() {
			return this.count;
		}
		//获取宠物类型
		public String getPetType() {
			return this.pet.getPetType();
		}
	}
	//狗猫队列类
	public static class DogCatQueue{
		private Queue<EnterQueuePet> dogQ;  //狗队列
		private Queue<EnterQueuePet> catQ;  //猫队列
		private long count;
		//构造函数
		public DogCatQueue() {
			this.dogQ = new LinkedList<EnterQueuePet>();
			this.catQ = new LinkedList<EnterQueuePet>();
			this.count = 0;
		}
		public void add(Pet pet) {
			if(pet.getPetType().equals("dog")) {
				this.dogQ.add(new EnterQueuePet(pet, this.count++));
			}else if(pet.getPetType().equals("cat")) {
				this.catQ.add(new EnterQueuePet(pet, this.count++));
			}else {
				throw new RuntimeException("不是猫或狗");
			}
		}
		
		public Pet pollAll(){
			if(!this.dogQ.isEmpty() && !this.catQ.isEmpty()) {
				if(this.dogQ.peek().getCount() < this.catQ.peek().getCount()) {
					return this.dogQ.poll().getPet();
				}else {
					return this.catQ.poll().getPet();
				}
			}else if(!this.dogQ.isEmpty()) {
				return this.dogQ.poll().getPet();
			}else if(!this.catQ.isEmpty()) {
				return this.catQ.poll().getPet();
			} else {
				throw new RuntimeException("err, queue is empty!");
			}
		}
		
		public Dog pollDog() {
			if (!this.isEmpty()) {
				return (Dog) this.dogQ.poll().getPet();
			} else {
				throw new RuntimeException("狗队列空了");
			}
		}

		public Cat pollCat() {
			if (!this.isCatQueueEmpty()) {
				return (Cat) this.catQ.poll().getPet();
			} else {
				throw new RuntimeException("猫队列空了");
			}
				
		}
		public boolean isEmpty() {
			return this.dogQ.isEmpty() && this.catQ.isEmpty();
		}

		public boolean isDogQueueEmpty() {
			return this.dogQ.isEmpty();
		}

		public boolean isCatQueueEmpty() {
			return this.catQ.isEmpty();
		}
	}

	public static void main(String[] args) {
		DogCatQueue dcq = new DogCatQueue();
		
		Pet dog = new Dog();
		Pet cat = new Cat();
		
		dcq.add(dog);
		dcq.add(cat);
		dcq.add(dog);
		
		if(!dcq.isDogQueueEmpty()) {
			System.out.println(dcq.pollDog().getPetType());
		}
		while (!dcq.isEmpty()) {
			System.out.println(dcq.pollAll().getPetType());
		}
	}
}
Day-yong
关注
专栏目录
C语言实现栈和队列
Sun_student的博客
01-08 3075
一、栈（原理：FILO||LIFO）        实现思想：利用静态顺序表实现栈                      1.定义结构体，包含值和数组还有栈顶成员变量记录栈内元素个数（栈主要就是对栈顶元素的操作）                      2.初始化、销毁（比较简单看代码理解）                      3.增操作：先判断栈是否已满，再在栈顶进行添加；（...
基于数组实现: 栈 队列
Smartbbbb的博客
03-13 711
* 栈和队列实现: * 1.双向链表实现 * 2.数组实现 * * 基于数组实现 public class StackOrQueueBaseOnArray { /** * 数组实现栈: * 1.只要满了报异常 * 2.没满保证正确性 */ public static class ArrayStack{ private int index; private final...
使用数组实现栈和队列
Pichairen
09-21 1010
一、数组实现栈： 1、使用一个类实现，该类私有成员有m_top、m_size、m_buffer 分别表示数组中栈顶位置、数组初始空间大小、指向该数组的指针。 2、该类的成员函数包括：isEmpty、isFull、push、pop、top、clearStack、stackLength 3、实现思路： 1、构造函数：初始化数组大小，m_top指向0位置，每次push元素都直接装进m_Top位置...
如何用数组实现队列和栈？
weixin_43333890的博客
08-22 244
【栈】 栈的特性是先进后出。 pop：把栈顶元素弹出栈 push：把元素压入栈 peek：得到栈顶元素的值 /* 首先建立一个N大小的数组arr[N]，表示这个栈最多有N个元素 用size表示栈中元素的个数，初始size = 0，且表示下一个压栈元素的位置 */ void push(int num){ if(size >= N ){ cout << "栈满" <&lt...
用数组模拟栈和队列
漫磋嗟
08-29 398
继上篇用数组模拟链表，本篇讲一讲如何用数组模拟栈和队列。原因其实也类似，实现方便，可以避免内存泄漏而且方便调试。最重要的效率原因，如果用 new 很容易超时
用数组实现的优先队列（JAVA）
04-10
总之，`PriorityQ.java`文件可能是一个简单的数组实现优先队列的示例，通过分析这个文件，我们可以学习到如何利用数组数据结构实现优先队列，以及理解其核心的插入、删除和查找操作。同时，这也能帮助我们更好地掌握...
易语言数组实现环形队列、栈等
06-03
在易语言中，使用数组实现栈非常直观，只需要一个变量来记录栈顶位置即可。当元素压栈时，栈顶位置加一并将新元素存入对应数组位置；当元素弹栈时，栈顶位置减一并返回该位置的元素。栈在递归、函数调用、表达式求值...
JS使用数组实现的队列功能示例
10-17
在JavaScript中实现队列数据结构主要有两种方式：使用数组和使用对象。本篇文档将探讨如何使用数组来实现一个队列，并展示它的基本操作，如添加元素、删除元素、读取队首和队尾元素等。 ### 队列的概念与特点 队列...
数组模拟栈队列
couchpotatoshy的博客
04-09 556
数组模拟栈和队列
如何用数组模拟一个队列和一个栈？
zcv5and的博客
09-18 329
1、用数组简单模拟一个栈 // 基于数组实现的顺序栈 public class ArrayStack { private String[] items; // 数组 private int count; // 栈中元素个数 private int n; // 栈的大小 // 初始化数组，申请一个大小为 n 的数组空间 public A...
算法 （五）数组模拟栈和队列
PizAn的博客
01-25 404
1、数组模拟栈和队列 数组模拟栈挺简单的，弄一个指针index，压栈就index++，弹栈就 -- index 数组模拟队列有点复杂，要弄三个指针，index、first和last，index防止越界（这里是固定数组，即用户需要给出栈和队列的初始大小），first和last模拟先进先出 ...
c语言 栈和队列的实现
编程爱好者的博客
08-14 6702
前提知识 顺序表 优点：可以随机访问，cpu高速缓存利用率高，不涉及（较少）进行插入和删除操作，应该使用顺序表 一般而言，我们使用顺序表（数组）的形式建立 栈这一数据结构。   栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 其特点是先进后出，模仿c++stl的stack和queue，我...
C语言实现栈和队列【数据结构/初阶】
Man9o
04-22 2580
C语言实现栈和队列
【数据结构】---栈和队列的实现【C语言实现】
mike_jun的博客
07-17 966
1. 栈的实现 栈是一种先进后出的数据结构。 栈（stack）是限定仅在表的一端进行操作的数据结构，只有一个入口和出口，只能从这个口子，进去或者出去。 如图：栈就像一个放球的单管桶，只允许球从桶的开口这一端取出，并且球先放入桶中则后从桶中拿出。 栈的节点的设计 栈分为数组栈和链表栈，其区别是数组栈使用数组进行功能的模拟，实现较为快速和便利， 而链表栈使用链表的思路去设计，实现较为麻烦，但是其稳定不易出错； 在链表栈中又分为静态链表栈和动态链表栈，静态链表栈给定栈的空间大小，不允...
数组模拟栈和队列（图解流程）
阿顾的博客
08-10 5039
  一 数组模拟栈 栈（stack），它是一种运算受限的线性表。这种限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底，向一个栈中插入新元素，我们一般称为入栈或者压栈，从一个栈中删除元素，我们一般称为弹栈或者出栈，即先进后出 入栈过程 首先声明一个固定大小的数组arr，并将索引index指向0位置，压入数据的时候，先给arr[index]赋值，再将inde...
C语言实现栈和队列(栈和队列的基本操作)
热门推荐
Damn_Yang的博客
11-10 11万+
栈： 栈：栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 特点：先进后出 stack.h #pragma once #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;assert.h&gt; #include &lt;...
用数组实现队列和栈
qq_43568109的博客
03-14 387
1.数组实现队列 1.定义队列的接口 public interface MyQueue { int size(); //获取队列的容量大小 boolean isEmpty(); //判断队列是否为空 void offer(Integer value); //将元素从队列尾部加入 int poll(); //将元素从队列头部删除 int peek(); //获取队列头部元素 } 2.设计接口的实现类 首先准备一个数组，一个头指针和一个尾指针，我
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值