数据结构之栈和队列
数组和链表是线性表的物理存储结构:即顺序存储和链式存储,栈和队列都属于线性表的逻辑存储结构。
上面这句话啥意思?
我们知道常见的数据结构中有一个线性表,线性表包括:数组、链表、栈、队列。
物理存储结构:数据在物理存储空间上选择集中存放还是分散存放,如数组(顺序存储结构)、链表(链式存储结构)。
逻辑存储结构:数据之间的逻辑关系,需要借助物理存储结构进行设计以体现出数据之间的逻辑关系。如:栈、队列、树、图。
上面的那些不利于理解的话我们可以简单理解为:物理存储结构就是数据怎么存,是放在一起连续的存,还是分散的存,而逻辑存储就是数据之间的逻辑关系,这些关系存在于口头语言上,比如树、他能直接实现吗?不能,树提出的只是一个抽象的慨念,只能借助数组或者链表去实现他所描述的逻辑关系。
1、栈
栈(stack)是一种线性数据结构,栈中的元素只能先入后出(First In Last Out,简称FILO)。
最早进入的元素存放的位置叫作栈底(bottom),最后进入的元素存放的位置叫作栈顶 (top)。
存储原理
栈既可以用数组来实现,也可以用链表来实现
栈的数组实现如下图:
数组实现的栈也叫顺序栈或静态栈
栈的链表实现如下图:
链表实现的栈也叫做链式栈或动态栈
代码实现:
数组方式
/**
* 线性表之栈 使用数组简单模拟栈
* TODO WJH
*/
public class ArrayStack<T> {
private T[] arr;
private int count;
public ArrayStack() {
//创建泛型数组
this.arr = (T[]) new Object[1 << 4];
}
/**
* 入栈操作
* @param element
* @return
*/
public boolean push(T element) {
//数组扩容
if(count >= arr.length) {
T[] newArr = (T[]) new Object[arr.length * 2];
System.arraycopy(arr, 0 ,newArr, 0 , arr.length);
this.arr = newArr;
}
arr[count++] = element;
return true;
}
/**
* 出栈操作
* @return
*/
public T pop() {
return count == 0 ? null : arr[--count];
}
}
/**
* 测试类
*/
class ArrayStackTest {
public static void main(String[] args) {
ArrayStack<String> stack = new ArrayStack<String>();
stack.push("我");
stack.push("是");
stack.push("猪");
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}
链表方式
/**
* 线性表之栈 使用链表简单模拟栈
* TODO WJH
*/
public class LinkedStack<T> {
private Node<T> head;
private int count;
public LinkedStack() {
head = null;
count = 0;
}
/**
* 入栈
* @param element
* @return
*/
public boolean push(T element) {
Node<T> node = new Node<>(element);
if (head != null) {
node.next = head;
}
head = node;
count++;
return true;
}
/**
* 出栈
* @return
*/
public T pop() {
if(count > 0) {
Node<T> oldHead = head;
head = head.next;
count--;
return oldHead.element;
} else {
return null;
}
}
class Node<T> {
private T element;
private Node<T> next;
public Node(T element) {
this.element = element;
}
}
}
/**
* 测试类
*/
class LinkedStackTest {
public static void main(String[] args) {
LinkedStack<String> stack = new LinkedStack<>();
for (int i = 0; i < 5; i++) {
stack.push(i + "");
}
for (int i = 0; i < 5; i++) {
System.out.println(stack.pop());
}
}
}
2、队列
概念
队列(queue)是一种线性数据结构,队列中的元素只能先入先出(First In First Out,简称 FIFO)。
队列的出口端叫作队头(front),队列的入口端叫作队尾(rear)。
存储原理
队列这种数据结构既可以用数组来实现,也可以用链表来实现。
- 数组实现
用数组实现时,为了入队操作的方便,出队操作的判断方便、把队尾位置规定为最后入队元素的下一个位置。
- 链表实现
代码实现:
数组实现
/**
* 线性表之队列 使用数组简单模拟队列
* TODO WJH
* @param <T>
*/
public class ArrayQueue<T> {
private T[] arr;
public int head; //队头下标
public int tail; //队尾下标
public ArrayQueue() {
this.arr = (T[]) new Object[1 << 4];
head = 0;
tail = 0;
}
/**
* 入队操作
* @param element
* @return
*/
public boolean enqueue(T element) {
//数组扩容
if (tail >= arr.length) {
T[] newArr = (T[]) new Object[arr.length * 2];
System.arraycopy(arr, 0, newArr, 0, arr.length);
this.arr = newArr;
}
arr[tail++] = element;
return true;
}
/**
* 出队操作
* @return
*/
public T dequeue() {
return head == tail ? null : arr[head++];
}
}
class ArrayQueueTest {
public static void main(String[] args) {
ArrayQueue<Integer> queue = new ArrayQueue<>();
for (int i = 0; i < 10; i++) {
System.out.println(queue.dequeue());
}
}
}
链表实现
/**
* 线性表之队列 用单向链表简单模拟队列
* TODO WJH
* @param <T>
*/
public class LinkedQueue<T> {
Node<T> head;
Node<T> tail;
int count;
/**
* 入队
* @param element
* @return
*/
public boolean enqueue(T element) {
Node<T> node = new Node<>(element);
if(head == null && tail == null && count == 0) {
head = node;
tail = node;
} else {
tail.next = node;
tail = node;
}
count++;
return true;
}
/**
* 出队
* @return
*/
public T dequeue() {
if(head == null && tail == null && count == 0) {
return null;
}
Node<T> tmp = head;
//选举新的队头
head = head.next;
//把旧的队头下一个节点执行null,让gc回收,注意这行代码和上行代码不可交换,会报NullPointerException
tmp.next = null;
//最后一个元素了,这个时候head和tail指向同一个元素,干掉head后,tail也没存在的必要了,变为空队列
if(head == null) {
tail = null;
}
count--;
return tmp.element;
}
class Node<T> {
T element;
Node<T> next;
public Node(T element) {
this.element = element;
}
}
}
class LinkedQueueTest {
public static void main(String[] args) {
LinkedQueue<Integer> queue = new LinkedQueue<>();
for (int i = 0; i < 10; i++) {
queue.enqueue(i);
}
for (int i = 0; i < 10; i++) {
System.out.println(queue.dequeue());
}
}
}