栈是先进后出,队列是先进先出。是2种重要的线性数据结构,和线性表相比,他们的插入和删除受到更多的约束与限定,因此称为限定的线性表结构。
栈的实现(数组或者链表、LinkedList)
但是这两种方法都不是线程安全的,如果要实现线程安全,需要对入栈和出栈进行同步操作。
- 数组实现的话,主要是要实现pop和push函数,以及peek查找栈顶,然后push的时候如果容量不够的话,需要扩容。
- 链表实现的话,也是主要实现push和pop函数,以及peek查找栈顶,需要注意的是,push的时候,要把新的数据放在上一个数据前面,这样才能实现先进后出。
数组实现:
import java.util.Arrays;
/**
* 数组实现栈
* @param <T>
*/
class Mystack1<T> {
//实现栈的数组
private Object[] stack;
//数组大小
private int size;
Mystack1() {
stack = new Object[10];//初始容量为10
}
//判断是否为空
public boolean isEmpty() {
return size == 0;
}
//返回栈顶元素
public T peek() {
T t = null;
if (size > 0)
t = (T) stack[size - 1];
return t;
}
public void push(T t) {
expandCapacity(size + 1);
stack[size] = t;
size++;
}
//出栈
public T pop() {
T t = peek();
if (size > 0) {
stack[size - 1] = null;
size--;
}
return t;
}
//扩大容量
public void expandCapacity(int size) {
int len = stack.length;
if (size > len) {
size = size * 3 / 2 + 1;//每次扩大50%
stack = Arrays.copyOf(stack, size);
}
}
}
public class ArrayStack {
public static void main(String[] args) {
Mystack1<String> stack = new Mystack1<>();
System.out.println(stack.peek());
System.out.println(stack.isEmpty());
stack.push("java");
stack.push("is");
stack.push("beautiful");
stack.push("language");
System.out.println(stack.pop());
System.out.println(stack.isEmpty());
System.out.println(stack.peek());
}
}
链表实现:
/**
* 链表实现栈
*
* @param <T>
*/
class Mystack2<T> {
//定义链表
class Node<T> {
private T t;
private Node next;
}
private Node<T> head;
//构造函数初始化头指针
Mystack2() {
head = null;
}
//入栈
public void push(T t) {
if (t == null) {
throw new NullPointerException("参数不能为空");
}
if (head == null) {
head = new Node<T>();
head.t = t;
head.next = null;
} else {
Node<T> temp = head;
head = new Node<>();
head.t = t;
head.next = temp;
}
}
//出栈
public T pop() {
T t = head.t;
head = head.next;
return t;
}
//栈顶元素
public T peek() {
T t = head.t;
return t;
}
//栈空
public boolean isEmpty() {
if (head == null)
return true;
else
return false;
}
}
public class LinkStack {
public static void main(String[] args) {
Mystack2 stack = new Mystack2();
System.out.println(stack.isEmpty());
stack.push("Java");
stack.push("is");
stack.push("beautiful");
System.out.println(stack.peek());
System.out.println(stack.peek());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.isEmpty());
System.out.println(stack.pop());
System.out.println(stack.isEmpty());
}
}
LinkedList实现:
import java.util.LinkedList;
/**
* LinkedList实现栈
*
* @param <T>
*/
class ListStack<T> {
private LinkedList<T> ll = new LinkedList<>();
//入栈
public void push(T t) {
ll.addFirst(t);
}
//出栈
public T pop() {
return ll.removeFirst();
}
//栈顶元素
public T peek() {
T t = null;
//直接取元素会报异常,需要先判断是否为空
if (!ll.isEmpty())
t = ll.getFirst();
return t;
}
//栈空
public boolean isEmpty() {
return ll.isEmpty();
}
}
public class LinkedListStack {
public static void main(String[] args) {
ListStack<String> stack = new ListStack();
System.out.println(stack.isEmpty());
System.out.println(stack.peek());
stack.push("java");
stack.push("is");
stack.push("beautiful");
System.out.println(stack.peek());
System.out.println(stack.pop());
System.out.println(stack.isEmpty());
System.out.println(stack.peek());
}
}
问:如何用O(1)时间复杂度求栈中最小元素,解:如果遍历的话是O(n),需要用空间来换时间,因此,一开始使用两个栈,一个用来存数据,一个用来存最小值,每次入栈时,如果这个元素比之前的最小值还小,那么压栈。最后栈顶就是最小值。
队列的实现(数组和链表、LinkedList)
- 链表实现的话,和栈就不一样了,把新数据放在上一个的后面。需要实现put和pop函数
- 数组实现的话,使用LinkedList,就非常简单,只是需要注意pop函数里面,删除的是第一个元素,不是最后一个
链表实现:
package com.wp.datastruct;
/**
* 利用链表来实现队列
* */
public class MyQueue<E> {
Node head = null; //队列头
Node tail = null; //队列尾
/**
* 入队操作:
* 若该队列尾空,则入队节点既是头结点也是尾节点
* 若队列不为空,则先用tail节点的next指针指向该节点
* 然后将tail节点指向该节点
* */
public void put(Integer data) {
Node newNode = new Node(data); //构造一个新节点
if(head == null && tail == null) { //队列为空
head = newNode;
tail = newNode;
}else {
tail.next = newNode;
tail = newNode;
}
}
/**
* 判断队列是否为空:当头结点等于尾节点的时候该队列就为空
* */
public boolean isEmpty() {
return head == tail;
}
/**
* 出队操作:
* 若队列为空,则返回null
* 否则,返回队列的头结点,并将head节点指向下一个
* */
public Integer pop() {
if(this.isEmpty()) {
return null;
}
int data = head.data;
head = head.next;
return data;
}
public int size() {
int count = 0;
Node tmp = head;
while(tmp != null) {
count++;
tmp = tmp.next;
}
return count;
}
}
LinkedList实现:
public class MyQueue2<E> {
private LinkedList<E> list = new LinkedList<>();
private int size = 0; //用于统计队列的长度
public synchronized void put(E data) { //保证线程安全,实现同步操作
list.add(data);
size++;
}
public synchronized E pop() {
size--;
return list.removeFirst(); //从头取出
}
public synchronized int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
}