如何实现栈和队列？[数据结构与算法]

于 2020-04-05 22:15:29 发布
阅读量191 收藏 1
点赞数
分类专栏： Java 文章标签： 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JIFAQO/article/details/105334863
版权

title: 如何实现栈和队列？[数据结构与算法]
date: 2020-04-05 10:33:43
author: JF
blog：https://www.huqifa.com/
summary: 栈和队列
tags:
- Java
- 数据结构与算法
categories:
- 数据结构与算法

栈 Stack

  • 栈也是一种线性结构

  • 相比数组，栈相应的操作是数组的子集

  • 只能从一端添加元素，也只能从一端取出元素

    这一端称为栈顶

  • 栈是一种后进先出的数据结构

无处不在的Undo操作（撤销）

栈的应用

  • 程序调用的系统栈

系统调用A，B，C三个函数，调用时依次让A,B,C入栈。开始让A入栈然后中断，开始执行B；指向函数C时，B函数中断，C开始执行

程序调用的系统栈

栈的实现

Interface Stack<E> ArrayStack<E>

  • Void push(E)（添加元素） (implement)
  • E pop()（取出元素）
  • E peek()（查看栈顶元素）
  • int getSize() （查看多少元素）
  • boolean isEmpty() （查看是否为空）
  1. 从用户的角度看，支持这些操作就好
  2. 具体底层实现，用户不关心
  3. 实际底层有多种实现方式

我们在动态数组的基础上实现一个栈：

不要小瞧数组！[数据机构与算法]

//在动态数组条件下，我们实现一个栈非常方便了
package cn.shuzu;

public interface Stack<E> {

		int getSize();
		boolean isEmpty();
		void push(E e);
		E pop();
		E peek();
}

package cn.shuzu;

public class ArrayStack<E> implements Stack<E> {
		
	Array<E> array;
	public ArrayStack(int capacity) {
		array = new Array<>(capacity);
	}
	
	public ArrayStack() {
		array = new Array<>();
	}
	
	@Override
	public int getSize() {
		return array.getsize();
	}
	
	@Override
	public boolean isEmpty() {
		return array.isEmpty();
	}
	
	public int getCapacity() {
		return array.getCapacity();
	}
	
	@Override
	public void push(E e) {
		array.addLast(e);
	}
	
	@Override
	public E pop() {
		return array.removeLast();
	}
	
	@Override
	public E peek() {
		return array.getLast();
	}
	
	@Override
	public String toString() {
		StringBuilder res = new StringBuilder();
		res.append("Stack: ");
		res.append('[');
		for (int i = 0; i < array.getsize(); i++) {
			res.append(array.get(i));
			if (i != array.getsize() - 1) {
				res.append(",");
			}
		}
		res.append("] top");
		return res.toString();
	}
	//Main函数
	public static void main(String[] args) {
		
		ArrayStack<Integer> stack = new ArrayStack<>();
		
		for (int i = 0; i < 5; i++) {
			stack.push(i);
			System.out.println(stack);
		}
		
		stack.pop();
		System.out.println(stack);
	}
}


//我们的输出：
Stack: [0] top
Stack: [0,1] top
Stack: [0,1,2] top
Stack: [0,1,2,3] top
Stack: [0,1,2,3,4] top
Stack: [0,1,2,3] top

栈的复杂度分析

栈的另一个应用：括号匹配

  • 括号匹配 - 编译器

在这里插入图片描述

package cn.shuzu;
import	 java.util.Stack;

class Solution {

	public boolean isValid(String s) {
		Stack<Character> stack = new Stack<>();
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (c == '(' || c == '[' || c == '{') 
				stack.push(c);
			else {
				if (stack.isEmpty()) 
					return false;
					
					char topChar = stack.pop();
					if (c == ')' && topChar != '(') {
						return false;
					}
					
					if (c == ']' && topChar != '[') {
						return false;
					}
					
					if (c == '}' && topChar != '{') {
						return false;
					}
				}
			}
		return stack.isEmpty();
	}
}

队列 Queue

  • 队列也是一种线性结构
  • 相比数组，队列对应的操作是数组的子集
  • 只能从一端（队尾）添加元素，只能从另一端（队首）取出元素
  • 队列是一种先进先出的数据结构（先到先得）

Queue<E>

  • void enqueue(E) （入队）
  • E dequeue() （出队）
  • E getFront()（查看队首元素）
  • int getSize() （查看多少元素）
  • boolean isEmpty() （是否为空）
package cn.shuzu;

public interface Queue<E> {

		int getSize();
		boolean isEmpty();
		void enqueue(E e);
		E	dequeue();
		E	getFront();
}

package cn.shuzu;

public class ArrayQueue<E>  implements Queue<E>{

	private Array<E> array;
	
	public ArrayQueue(int capacity) {
		// TODO Auto-generated constructor stub
		array = new Array<>(capacity);
	}

	public ArrayQueue() {
		array = new Array<>();
	}
	
	@Override
	public int getSize() {
		return array.getsize();
	}
	
	@Override
	public boolean isEmpty() {
		return array.isEmpty();
	}
	
	public int getCapacity() {
		return array.getCapacity();
	}
	
	@Override
	public void enqueue(E e) {
		array.addLast(e);
	}
	
	@Override
	public E dequeue() {
		return array.removeFirst();
	}
	
	@Override
	public E getFront() {
		return array.getFirst();
	}
	
	@Override
	public String toString() {
		StringBuilder  res = new StringBuilder();
		res.append("Queue: ");
		res.append("front [");
		for (int i = 0; i < array.getsize(); i++) {
			res.append(array.get(i));
			if (i != array.getsize() -1) {
				res.append(",");
			}
		}
		res.append("] tail");
		return res.toString();
	}
	
	public static void main(String[] args) {
		
		ArrayQueue<Integer> queue = new ArrayQueue<Integer>();
		for (int i = 0; i < 10; i++) {
			queue.enqueue(i);
			System.out.println(queue);
			
			if (i % 3 == 2) {
				queue.dequeue();
				System.out.println(queue);
			}
		}
	}
}

数组队列的复杂度分析

循环队列的实现

  • front == tail 队列为空
  • (tail + 1) % capacity == front 队列满
package cn.shuzu;

public class LoopQueue<E> implements Queue<E> {

	private E[] data;
	private int front,tail;
	private int size;
			
	public LoopQueue(int capacity) {
		// TODO Auto-generated constructor stub
			data = (E[])new Object[capacity + 1];
			front = 0;
			tail = 0;
			size = 0;
	}
	
	public LoopQueue() {
		this(10);
	}
	
	public int getCapacity() {
		return data.length - 1;
	}
	
	@Override
	public boolean isEmpty() {
		return front == tail;
	}
	
	@Override
	public int getSize() {
		return size;
	}

	@Override
	public void enqueue(E e) {
		
		if ((tail+ 1) % data.length == front) {
			resize(getCapacity() * 2);
		}
		
		data[tail] = e;
		tail = (tail + 1) % data.length;
		size ++;
	}
	
	@Override
	public E dequeue() {
		
		if(isEmpty())
			throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
	
		E ret = data[front];
		data[front] = null;
		front = (front + 1) % data.length;
		size --;
		
		if (size == getCapacity() / 4 && getCapacity() / 2 != 0 ) {
			resize(getCapacity() / 2);
		}
		return ret;
	}
	
	@Override
	public E getFront() {
		if (isEmpty()) {
			throw new IllegalArgumentException("Queue is empty.");
		}
		return data[front];
	}
	
	@Override
	public String toString() {
		StringBuilder  res = new StringBuilder();
		res.append(String.format("Queue: size = %d, capacity = %d\n", size,getCapacity()));
		res.append("front [");
		for (int i = front; i != tail ; i = (i + 1) % data.length ) {
			res.append(data[i]);
			if ((i + 1) % data.length != data.length) {
				res.append(",");
			}
		}
		res.append("] tail");
		return res.toString();
	}
	
	private void resize(int  newCapacity) {
		
		E[] newData = (E[])new Object[newCapacity + 1];
		for (int i = 0; i < size; i++) {
			newData[i] = data[(i + front) % data.length];
		}
		
		data = newData;
		front = 0;
		tail = size;
	}
	
	public static void main(String[] args) {
		
		LoopQueue<Integer> queue = new LoopQueue<Integer>();
		for (int i = 0; i < 10; i++) {
			queue.enqueue(i);
			System.out.println(queue);
			
			if (i % 3 == 2) {
				queue.dequeue();
				System.out.println(queue);
			}
		}
	}
	
}

//打印输出
Queue: size = 1, capacity = 10
front [0,] tail
Queue: size = 2, capacity = 10
front [0,1,] tail
Queue: size = 3, capacity = 10
front [0,1,2,] tail
Queue: size = 2, capacity = 5
front [1,2,] tail
Queue: size = 3, capacity = 5
front [1,2,3,] tail
Queue: size = 4, capacity = 5
front [1,2,3,4,] tail
Queue: size = 5, capacity = 5
front [1,2,3,4,5,] tail
Queue: size = 4, capacity = 5
front [2,3,4,5,] tail
Queue: size = 5, capacity = 5
front [2,3,4,5,6,] tail
Queue: size = 6, capacity = 10
front [2,3,4,5,6,7,] tail
Queue: size = 7, capacity = 10
front [2,3,4,5,6,7,8,] tail
Queue: size = 6, capacity = 10
front [3,4,5,6,7,8,] tail
Queue: size = 7, capacity = 10
front [3,4,5,6,7,8,9,] tail

循环队列的复杂度分析

循环队列和数组队列的比较

我们用十万次入队和出队操作的时间进行比较

package cn.shuzu;

import java.util.Random;

public class Main01 {

	//测试使用q运行opcount个enqueue和dequeue操作所需要的时间，单位：秒
	private static double testQueue(Queue<Integer> q,int opCount) {
		
		long startTime = System.nanoTime();
		
		Random random = new Random();
		for (int i = 0; i < opCount; i++) {
			q.enqueue(random.nextInt(Integer.MAX_VALUE));
		}
		for (int i = 0; i < opCount; i++) {
			q.dequeue();
		}
		
		long endTime = System.nanoTime();
		
		return (endTime - startTime) / 1000000000.0;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int opCount = 100000;
		
		ArrayQueue<Integer> arrayQueue = new ArrayQueue<Integer>();
		double time1 = testQueue(arrayQueue, opCount);
		System.out.println("ArrayQueue,time : " + time1 + "s");
		
		LoopQueue<Integer> LoopQueue = new LoopQueue<Integer>();
		double time2 = testQueue(arrayQueue, opCount);
		System.out.println("LoopQueue,time : " + time2 + "s");
		
	}
}

十万次入队出队的时间比较

Ashura78
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值