package com.stack;
public class Array<E> {
private E[] data;
private int size;
// 构造函数,传入数组的容量capacity构造Array
public Array(int capacity){
data = (E[])new Object[capacity];
size = 0;
}
// 无参数的构造函数,默认数组的容量capacity=10
public Array(){
this(10);
}
// 获取数组的容量
public int getCapacity(){
return data.length;
}
// 获取数组中的元素个数
public int getSize(){
return size;
}
// 返回数组是否为空
public boolean isEmpty(){
return size == 0;
}
// 在index索引的位置插入一个新元素e
public void add(int index, E e){
if(index < 0 || index > size)
throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");
if(size == data.length)
resize(2 * data.length);
for(int i = size - 1; i >= index ; i --)
data[i + 1] = data[i];
data[index] = e;
size ++;
}
// 向所有元素后添加一个新元素
public void addLast(E e){
add(size, e);
}
// 在所有元素前添加一个新元素
public void addFirst(E e){
add(0, e);
}
// 获取index索引位置的元素
public E get(int index){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Get failed. Index is illegal.");
return data[index];
}
public E getLast(){
return get(size - 1);
}
public E getFirst(){
return get(0);
}
// 修改index索引位置的元素为e
public void set(int index, E e){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Set failed. Index is illegal.");
data[index] = e;
}
// 查找数组中是否有元素e
public boolean contains(E e){
for(int i = 0 ; i < size ; i ++){
if(data[i].equals(e))
return true;
}
return false;
}
// 查找数组中元素e所在的索引,如果不存在元素e,则返回-1
public int find(E e){
for(int i = 0 ; i < size ; i ++){
if(data[i].equals(e))
return i;
}
return -1;
}
// 从数组中删除index位置的元素, 返回删除的元素
public E remove(int index){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Remove failed. Index is illegal.");
E ret = data[index];
for(int i = index + 1 ; i < size ; i ++)
data[i - 1] = data[i];
size --;
data[size] = null; // loitering objects != memory leak
if(size == data.length / 4 && data.length / 2 != 0)
resize(data.length / 2);
return ret;
}
// 从数组中删除第一个元素, 返回删除的元素
public E removeFirst(){
return remove(0);
}
// 从数组中删除最后一个元素, 返回删除的元素
public E removeLast(){
return remove(size - 1);
}
// 从数组中删除元素e
public void removeElement(E e){
int index = find(e);
if(index != -1)
remove(index);
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
res.append('[');
for(int i = 0 ; i < size ; i ++){
res.append(data[i]);
if(i != size - 1)
res.append(", ");
}
res.append(']');
return res.toString();
}
// 将数组空间的容量变成newCapacity大小
private void resize(int newCapacity){
E[] newData = (E[])new Object[newCapacity];
for(int i = 0 ; i < size ; i ++)
newData[i] = data[i];
data = newData;
}
}
先定义一个动态的数组 数组是关键
栈一般有一下的五种操作
peek() 获得栈顶
pop() 弹栈
push 入栈
getSize() 栈的大小
isEmpty() 栈是否为空
package com.stack;
public interface Stack<E> {
int getSize();
boolean isEmpty();
E pop();
E peek();
void push(E e);
}
package com.stack;
public class ArrayStack<E> implements Stack<E> {
private Array<E> array;//动态数组
public ArrayStack(int capacity) {
array = new Array<>(capacity);
}
public ArrayStack(){
array = new Array<>();
}
@Override
public int getSize() {
return array.getSize();
}
//获得栈的容量的大小
public int getCapactity(){
return array.getCapacity();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
@Override
public E pop() {
return array.removeLast();
}
@Override
public E peek() {
return array.getLast();
}
@Override
public void push(E e) {
array.addLast(e);
}
@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();
}
}
栈的使用场景
你用 word 时候的撤销的操作 ctrl+z的操作
最为经典的是应该是计算机程序中的 程序系统调用栈
function A(){
.....
B()
.....
}
function B(){
....
C()
....
}
function C(){
...
...
...
}
在这里有三个函数
执行函数A 会调用 函数B
这时候会在 程序栈入栈添加执行程序B的栈帧
执行函数B的时候的 又会调用函数C
这时候会在 程序栈入栈添加执行程序C的栈帧
执行C函数的时候未发现 调用函数 一旦C函数执行完成
会把程序栈中的 C的栈帧弹出 继续执行B函数 余下的代码
完成 B 又会弹栈 直到栈为空 函数执行完成
利用栈可以解决那些问题 括号的匹配的问题
package com.stack;
import java.util.Stack;
/**
* {([])} 括号匹配的实现
*/
public class Solution {
public boolean isValid(String s){
Stack<Character> stack = new Stack<Character>();//使用的Java的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();
}
public static void main(String[] args) {
boolean isV = new Solution().isValid("([{({[]})}]");
boolean isV2 = new Solution().isValid("{}()");
System.out.println(isV);
System.out.println(isV2);
}
}