一、栈
1、什么是栈
栈是一种操作受限的线性表，后进者先出，先进者后出，只允许在一端插入和删除数据
当某个数据集合只涉及在一端插入和删除数据，并且满足后进先出、先进后出的特性，就应该首先栈这种数据结构
栈主要包含两个操作，入栈和出栈，也就是在栈顶插入一个数据和从栈顶删除一个数据
用数组实现的栈叫做顺序栈，用链表实现的栈叫做链式栈
2、栈的代码实现
1）、顺序栈
public class ArrayStack {
private String[] items;//数组
private int count;//栈中元素大小
private int n;//栈的大小
//初始化数组,申请一个大小为n的数组空间
public ArrayStack(int n) {
this.items = new String[n];
this.n = n;
this.count = 0;
}
//入栈操作
public boolean push(String item) {
if (count == n) return false;
items[count] = item;
count++;
return true;
}
//出栈操作
public String pop() {
if (count == 0) return null;
return items[--count];
}
}
2）、链式栈
public class StackBasedOnLinkedList {
private Node top = null;
public void push(int value) {
Node newNode = new Node(value, null);
if (top == null) {
top = newNode;
} else {
newNode.next = top;
top = newNode;
}
}
public int pop() {
if (top == null) return -1;
int value = top.data;
top = top.next;
return value;
}
private static class Node {
private int data;
private Node next;
public Node(int data, Node next) {
this.data = data;
this.next = next;
}
public int getData() {
return data;
}
}
}
3、Stack常用API
public E push(E item)//将item压入栈并返回item
public synchronized E pop()//弹出并返回栈顶的item,如果栈为空会抛出EmptyStackException
public synchronized E peek()//返回栈顶的item,如果栈为空会抛出EmptyStackException
public boolean empty()//栈是否为空
4、栈相关题目
1）、LeetCode20：有效的括号
给定一个只包括(，)，{，}，[，]的字符串，判断字符串是否有效
有效字符串需满足：
- 左括号必须用相同类型的右括号闭合
- 左括号必须以正确的顺序闭合
public boolean isValid(String s) {
Stack<Character> stack = new Stack<>();
char[] charArray = s.toCharArray();
for (char cChar : charArray) {
if (stack.empty()) {
stack.push(cChar);
} else if (check(stack.peek(), cChar)) {
stack.pop();
} else {
stack.push(cChar);
}
}
return stack.empty();
}
public boolean check(char c1, char c2) {
return (c1 == '(' && c2 == ')' || c1 == '[' && c2 == ']' || c1 == '{' && c2 == '}');
}
2）、LeetCode155：最小栈
设计一个支持push，pop，top操作，并能在常数时间内检索到最小元素的栈
push(x) -- 将元素x推入栈中
pop() -- 删除栈顶的元素
top() -- 获取栈顶元素
getMin() -- 检索栈中的最小元素
public class MinStack {
private Stack<Integer> stack;
private Stack<Integer> minStack;
public MinStack() {
stack = new Stack<>();
minStack = new Stack<>();
}
public void push(int x) {
stack.push(x);
if (minStack.isEmpty() || x < minStack.peek()) {
minStack.push(x);
} else {
minStack.push(minStack.peek());
}
}
public void pop() {
stack.pop();
minStack.pop();
}
public int top() {
if (!stack.isEmpty()) {
return stack.peek();
}
throw new RuntimeException("栈中元素为空，此操作非法");
}
public int getMin() {
if (!minStack.isEmpty()) {
return minStack.peek();
}
throw new RuntimeException("栈中元素为空，此操作非法");
}
}
3）、LeetCode84：柱状图中最大的矩形
给定n个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为1
求在该柱状图中，能够勾勒出来的矩形的最大面积
以上是柱状图的示例，其中每个柱子的宽度为1，给定的高度为[2,1,5,6,2,3]
图中阴影部分为所能勾勒出的最大矩形面积，其面积为10个单位
示例：
输入: [2,1,5,6,2,3]
输出: 10
题解：
public int largestRectangleArea(int[] heights) {
Stack<Integer> stack = new Stack<>();
stack.push(-1);
int maxarea = 0;
for (int i = 0; i < heights.length; ++i) {
while (stack.peek() != -1 && heights[stack.peek()] >= heights[i])
maxarea = Math.max(maxarea, heights[stack.pop()] * (i - stack.peek() - 1));
stack.push(i);
}
while (stack.peek() != -1)
maxarea = Math.max(maxarea, heights[stack.pop()] * (heights.length - stack.peek() - 1));
return maxarea;
}
二、队列
1、什么是队列
队列是一种操作受限的线性表，先进者先出，支持最基本的数据操作：入队，放一个数据到队列尾部；出队，从队列头部取一个元素
用数组实现的队列叫作顺序队列，用链表实现的队列叫作链式队列
1）、顺序队列
队列的实现需要两个指针：一个是head指针，指向队头；一个是tail指针，指向队尾
当我们调用两次出队操作，队列中head指针指向下标为2的位置，tail指针仍然指向下标为4的位置
随着不停地进行入队、出队操作，head和tail都会持续往后移动。当tail移动到最右边，即使数组中还有空闲空间，也无法继续往队列中添加数据了。在出队时可以不用搬移数据。如果没有空闲空间了，我们只需要在入队时，再集中触发一次数据的搬移操作
public class ArrayQueue {
private String[] items;
private int n = 0;//数组大小
private int head = 0;//队头下标
private int tail = 0;//队尾下标
public ArrayQueue(int capacity) {
items = new String[capacity];
n = capacity;
}
//入队
public boolean enqueue(String item) {
if (tail == n) {
if (head == 0) return false;
for (int i = head; i < tail; ++i) {
items[i - head] = items[i];
}
tail -= head;
head = 0;
}
items[tail] = item;
++tail;
return true;
}
//出队
public String dequeue() {
if (head == tail) return null;
String ret = items[head];
++head;
return ret;
}
}
当队列的tail指针移动到数组的最右边后，如果有新的数据入队，我们可以将head到tail之间的数据，整体搬移到数组中0到tail-head的位置
2）、链式队列
基于链表的实现，同样需要两个指针：head指针和tail指针。它们分别指向链表的第一个结点和最后一个结点。入队时，tail->next=new_node，tail=tail->next；出队时，head=head->next
public class QueueBasedOnLinkedList {
//队列的队首和队尾
private Node head = null;
private Node tail = null;
//入队
public void enqueue(String value) {
Node newNode = new Node(value, null);
if (tail == null) {
head = newNode;
tail = newNode;
} else {
tail.next = newNode;
tail = tail.next;
}
}
//出队
public String dequeue() {
if (head == null) return null;
String value = head.getData();
head = head.next;
if (head == null) {
tail = null;
}
return value;
}
private static class Node {
private String data;
private Node next;
public Node(String data, Node next) {
this.data = data;
this.next = next;
}
public String getData() {
return data;
}
}
}
3）、循环队列
循环队列就是把数组首尾相连扳成一个环
图中这个队列的大小为8，当前head=4，tail=7。当有一个新的元素a入队时，我们放入下标为7的位置。但这个时候，我们并不把tial更新为8，而是将其在环中后移一位，到下标为0的位置。当再有一个元素b入队时，我们将b放入下标为0的位置，然后tail加1更新为1。所以，在a，b依次入队之后，循环队列中的元素就变成了下面的样子：
通过这样的方法，成功避免了数据搬移操作
循环队列为空的判断条件是head==tail，队列满的条件(tail+1)%n==head
循环队列队列满的表达式推算过程：
在一般情况下，当队列满时，tail+1=head。但是，有个特殊情况，就是tail=n-1，而head=0时，这时候，tail+1=n，而head=0，所以用(tail+1)%n==n%n==0。而且，tail+1最大的情况就是n，不会大于n，这样，tail+1除了最大情况，不然怎么余n都是tail+1本身，也就是head
public class CircularQueue {
private String[] items;
private int n = 0;
//head表示队头下标,tail表示队尾下标
private int head = 0;
private int tail = 0;
//申请一个大小为capacity的数组
public CircularQueue(int capacity) {
items = new String[capacity];
n = capacity;
}
//入队
public boolean enqueue(String item) {
//队列满了
if ((tail + 1) % n == head) return false;
items[tail] = item;
tail = (tail + 1) % n;
return true;
}
//出队
public String dequeue() {
//如果head==tail,表示队列为空
if (head == tail) return null;
String ret = items[head];
head = (head + 1) % n;
return ret;
}
}
三、双向队列ArrayDeque
1、常用API
1）、双向队列操作
插入元素：
public void addFirst(E e)//向队头插入元素
public void addLast(E e)//向队尾插入元素
public boolean offerFirst(E e)
public boolean offerLast(E e)
移除元素：
public E removeFirst()//返回并移除队头元素
public E removeLast()//返回并移除队尾元素
public E pollFirst()
public E pollLast()
获取元素：
public E getFirst()//获取队头元素但不移除,如果队列无元素则抛出异常NoSuchElementException
public E getLast()//获取队尾元素但不移除,如果队列无元素则抛出异常NoSuchElementException
public E peekFirst()//获取队头元素但不移除,如果队列无元素,则返回null
public E peekLast()//获取队尾元素但不移除,如果队列无元素,则返回null
2）、栈操作
//弹出栈中元素,也就是返回并移除队头元素
public E pop() {
return removeFirst();
}
//向栈中压入元素,也就是向队头增加元素
public void push(E e) {
addFirst(e);
}
2、ArrayDeque源码分析
1）重要属性
//存储元素的数组
transient Object[] elements;
//队列头位置的索引
transient int head;
//队列尾位置之后的索引
transient int tail;
//最小初始容量
private static final int MIN_INITIAL_CAPACITY = 8;
2）构造函数
ArrayDeque提供了三个构造函数，一个空参构造函数，默认创建初始容量为16的空双端队列；一个通过传入一个int类型的参数来指定双端队列的初始容量；一个通过传入一个集合（Collection）作为参数初始化ArrayDeque
public ArrayDeque() {
elements = new Object[16];
}
public ArrayDeque(int numElements) {
allocateElements(numElements);
}
public ArrayDeque(Collection<? extends E> c) {
allocateElements(c.size());
addAll(c);
}
ArrayDeque的容量和HashMap一样总是为 2 n 2^n 2n，如果传入的numElements小于8，则双端队列容量为8，否则计算出一个最接近同时大于numElements的 2 n 2^n 2n
private void allocateElements(int numElements) {
elements = new Object[calculateSize(numElements)];
}
private static int calculateSize(int numElements) {
int initialCapacity = MIN_INITIAL_CAPACITY;
if (numElements >= initialCapacity) {
initialCapacity = numElements;
//initialCapacity=(initialCapacity|initialCapacity>>>1)
initialCapacity |= (initialCapacity >>> 1);
initialCapacity |= (initialCapacity >>> 2);
initialCapacity |= (initialCapacity >>> 4);
initialCapacity |= (initialCapacity >>> 8);
initialCapacity |= (initialCapacity >>> 16);
initialCapacity++;
if (initialCapacity < 0)
initialCapacity >>>= 1;
}
return initialCapacity;
}
int类型占4个字节，32位。对于initialCapacity，假设它的位数为n，那么第n位必然为1。第1步计算之后，initialCapacity的第n位和第n-1位必然为1。第2步计算之后，initialCapacity的第n、n-1位和第n-2、n-3位必然为1。以此类推，当计算完第5步时，initialCapacity的第n到0位全部为1。最后进行第6步计算，initialCapacity的第n+1位为1，第n到0位全部为0。此时，initialCapacity的值为 2 ( n + 1 ) 2^{(n+1)} 2(n+1)，是一个2的幂。最后，如果计算出的值是 2 31 2^{31} 231（小于0），那么右移1位，取 2 30 2^{30} 230
3）扩容方法
private void doubleCapacity() {
//assert关键字后面跟一个布尔表达式,如果表达式的值为true,继续执行;如果表达式的值为false,则抛出异常AssertionError
assert head == tail;
int p = head;
int n = elements.length;
int r = n - p; // number of elements to the right of p
//新数组长度为旧数组长度的两倍
int newCapacity = n << 1;
if (newCapacity < 0)
throw new IllegalStateException("Sorry, deque too big");
Object[] a = new Object[newCapacity];
//将旧数组head之后的元素拷贝到新数组中
System.arraycopy(elements, p, a, 0, r);
//将旧数组下标0到head之间的元素拷贝到新数组中
System.arraycopy(elements, 0, a, r, p);
elements = a;
//head指向0,tail指向旧数组长度表示尾位置插入下一个元素的位置
head = 0;
tail = n;
}
4）addFirst(E e)方法
public void addFirst(E e) {
if (e == null)
throw new NullPointerException();
//因为ArrayDeque的容量和HashMap一样总是为2^n,所以elements.length-1就是(2^n-1).当旧head为0时,(head-1)就是-1(在计算机中表示为32位全部为1)。我们知道当1&1时等于1,其它都等于0.所以,当旧head为0时,(head-1)&(elements.length-1)的结果就是(elements.length-1).当旧head大于0时,(head-1)&(elements.length-1)的结果就是(head-1).elements数组的容量为2的幂可以保证任何一个数按位与(&)数组的容量-1的结果一定在0到数组容量-1的范围之内.这就是elements数组的容量总是2的幂的原因
elements[head = (head - 1) & (elements.length - 1)] = e;
//如果head等于tail则进行扩容
if (head == tail)
doubleCapacity();
}
4）addLast(E e)方法
public void addLast(E e) {
if (e == null)
throw new NullPointerException();
elements[tail] = e;
//计算新的tail,(tail+1)&(elements.length-1)保证tail==(elements.length-1)时新的tail=0,如果tail等于head则进行扩容
if ( (tail = (tail + 1) & (elements.length - 1)) == head)
doubleCapacity();
}
5）removeFirst()方法
public E removeFirst() {
E x = pollFirst();
if (x == null)
throw new NoSuchElementException();
return x;
}
public E pollFirst() {
int h = head;
@SuppressWarnings("unchecked")
E result = (E) elements[h];
if (result == null)
return null;
elements[h] = null;
//计算新的head,(head+1)&(elements.length-1)保证head==(elements.length-1)时新的head=0
head = (h + 1) & (elements.length - 1);
return result;
}
6）removeLast()方法
public E removeLast() {
E x = pollLast();
if (x == null)
throw new NoSuchElementException();
return x;
}
public E pollLast() {
int t = (tail - 1) & (elements.length - 1);
@SuppressWarnings("unchecked")
E result = (E) elements[t];
if (result == null)
return null;
elements[t] = null;
tail = t;
return result;
}
四、优先队列PriorityQueue
1、常用API
//小顶堆(最小最优先)
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
//大顶堆
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(11, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
PriorityQueue<Integer> maxHeap2 = new PriorityQueue<>(11, (x, y) -> (y - x));
public boolean offer(E e)//将指定元素插入到优先队列中
public E peek()//获取但不移除此队列的头,如果此队列为空则返回null
public E poll()//获取并移除此队列的头,如果此队列为空则返回null
2、堆
Java中的PriorityQueue是通过堆来实现的
堆：堆是一个完全二叉树，且堆中每一个节点的值都必须大于等于（或小于等于）其子树中每个节点的值
完全二叉树：除了最后一层，其它层的节点个数都是满的，最后一层的节点都靠左排列
对于每个节点的值都大于等于子树中每个节点值的堆，叫作大顶堆。对于每个节点的值都小于等于子树中每个节点值的堆，叫作小顶堆
上图中第1个和第2个是大顶堆，第3个是小顶堆，第4个不是堆
完全二叉树的最后一个非叶子结点的下标是 ( n − 2 ) / 2 (n-2)/2 (n−2)/2
完全二叉树中如果一个非叶子结点的下标是i，则它的父结点下标是 ( i − 1 ) / 2 (i-1)/2 (i−1)/2，它的左孩子下标是 2 ∗ i + 1 2*i+1 2∗i+1，右孩子下标是 2 ∗ i + 2 2*i+2 2∗i+2
3、源码分析
PriorityQueue默认实现是一个小顶堆，接下来的讲解以小顶堆为例进行分析
1）、重要属性
//默认容量11
private static final int DEFAULT_INITIAL_CAPACITY = 11;
//堆的存储结构,存储元素
transient Object[] queue;
//当前存储的元素数量
private int size = 0;
//比较器,确定优先级高低
private final Comparator<? super E> comparator;
2）、 扩容方法
private void grow(int minCapacity) {
//获取当前容量
int oldCapacity = queue.length;
//如果旧容量小于64,则增加旧容量+2的大小
//如果旧容量大于等于64,则增加旧容量的一半大小
int newCapacity = oldCapacity + ((oldCapacity < 64) ?
(oldCapacity + 2) :
(oldCapacity >> 1));
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//复制已存储的数据
queue = Arrays.copyOf(queue, newCapacity);
}
3）、offer(E e)方法
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
modCount++;
//记录当前队列中元素的个数
int i = size;
//如果当前元素个数大于等于队列底层数组的长度,则进行扩容
if (i >= queue.length)
grow(i + 1);
//元素个数+1
size = i + 1;
//如果队列中没有元素,则将元素e直接添加到数组下标为0的位置
if (i == 0)
queue[0] = e;
//新元素都是增加在数组尾部,然后进行上移操作,即构建堆
else
siftUp(i, e);
return true;
}
private void siftUp(int k, E x) {
if (comparator != null)
//采用自定义的比较器
siftUpUsingComparator(k, x);
else
siftUpComparable(k, x);
}
//上移就是不断和父节点比较
private void siftUpComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super E>) x;
while (k > 0) {
//父节点下标
int parent = (k - 1) >>> 1;
Object e = queue[parent];
//如果新增的元素k比其父节点e大,则不需要上移,跳出循环结束
if (key.compareTo((E) e) >= 0)
break;
//x比父节点小,则需要进行上移
//交换元素x和父节点e的位置
queue[k] = e;
//将新插入元素的位置k指向父亲的位置,进行下一层循环
k = parent;
}
queue[k] = key;
}
每次增加元素，都要进行堆化来保证堆序
结合上面的图解，来说明一下二叉堆的添加元素过程：
1）将元素2添加在最后一个位置（队尾）（图2）
2）由于2比其父节点6要小，所以将元素2上移，交换2和6的位置（图3）
3） 然后由于2比5小，继续将2上移，交换2和5的位置（图4），此时2大于其父节点（根节点）1，结束
4）、poll()方法
public E poll() {
if (size == 0)
return null;
//队列元素个数-1
int s = --size;
modCount++;
//队头的元素
E result = (E) queue[0];
//队尾的元素
E x = (E) queue[s];
queue[s] = null;
if (s != 0)
//如果队列中不止队尾一个元素，则进行下移操作
siftDown(0, x);
return result;
}
private void siftDown(int k, E x) {
if (comparator != null)
//采用自定义的比较器
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
private void siftDownComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super E>)x;
//最后一个非叶子节点下标
int half = size >>> 1;
while (k < half) {
//左孩子
int child = (k << 1) + 1;
Object c = queue[child];
//右孩子
int right = child + 1;
//对比左孩子和右孩子取其中更小的节点
if (right < size &&
((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
c = queue[child = right];
//如果队尾元素比左右孩子都要小,则不需下移，结束
if (key.compareTo((E) c) <= 0)
break;
//和左孩子和右孩子中更小的节点交换位置
queue[k] = c;
//将根元素位置k指向最小孩子的位置,进入下层循环
k = child;
}
//找到队尾元素x的合适位置k之后进行赋值
queue[k] = key;
}
结合上面的图解，来说明一下二叉堆的出队过程：
1）将找出队尾的元素8，并将它在队尾位置上删除（图2）
2）此时队尾元素8比根元素1的最小子节点3要大，所以将元素1下移，交换1和3的位置（图3）
3）然后此时队尾元素8比元素1的最小子节点4要大，继续将1下移，交换1和4的位置（图4）
4）然后此时根元素8比元素1的最小子节点9要小，不需要下移，直接将根元素8赋值给此时元素1的位置，1被覆盖则相当于删除（图5），结束
参考：https://www.cnblogs.com/linghu-java/p/9467805.html
五、队列相关题目
1、LeetCode703：数据流中的第K大元素
设计一个找到数据流中第K大元素的类
public class KthLargest {
private PriorityQueue<Integer> queue;
private int k;
public KthLargest(int k, int[] nums) {
//小顶堆
this.queue = new PriorityQueue<Integer>(k);
this.k = k;
for (int i = 0; i < nums.length; ++i) {
add(nums[i]);
}
}
public int add(int val) {
if (queue.size() < k) {
queue.offer(val);
} else if (queue.peek() < val) {
queue.poll();
queue.offer(val);
}
return queue.peek();
}
}
2、LeetCode239：滑动窗口最大值
给定一个数组nums，有一个大小为k的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的k个数字。滑动窗口每次只向右移动一位
返回滑动窗口中的最大值
示例：
输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
题解：
public int[] maxSlidingWindow(int[] nums, int k) {
int n = nums.length;
if (n * k == 0) return new int[0];
if (k == 1) return nums;
//双向队列,保存当前窗口最大值的数组位置,保证队列中数组位置的数按从大到小排序
LinkedList<Integer> list = new LinkedList<>();
int[] result = new int[n - k + 1];
for (int i = 0; i < n; ++i) {
//如果前面的数小于nums[i]弹出
while (!list.isEmpty() && nums[i] >= nums[list.peekLast()]) {
list.pollLast();
}
//添加当前值对应的数组下标
list.addLast(i);
//等到窗口长度为k时,下次移动在删除过期数值
if (list.peek() <= i - k) {
list.poll();
}
//窗口长度为k时,再保存当前窗口中最大值
if (i - k + 1 >= 0) {
result[i - k + 1] = nums[list.peek()];
}
}
return result;
}
常用数据结构的时间、空间复杂度：
https://www.bigocheatsheet.com/
扫一扫
296
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
