1. 动态数组
这里用动态数组实现栈的基本操作
package MyStack;
public class Array<E> {
private E[] data;
private int size; //数组当前存放元素个数,注意当前的最大索引等于size-1
/**
* 构造函数
*
* @param:capacity传入数组的容量
*/
public Array(int capacity) {
data = (E[]) new Object[capacity];
size = 0;
}
/**
* 无参构造,默认容量是10
*/
public Array() {
this(10); //访问本类的构造方法
}
/**
* 获取当前数组中元素的个数
*/
public int getSize() {
return size;
}
/**
* 获取数组的容量
*/
public int getCapacity() {
return data.length;
}
/**
* 判断数组是否为空
*/
public boolean isEmpty() {
return size == 0; //如果当前存放元素个数为0,就是空
}
/**
* 向第index个位置插入元素
*
* @param index
* @param 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++;
}
/**
* 向数组末尾添加元素
*
* @param e
*/
public void addLast(E e) {
add(size, e);
}
/**
* 向数组开始位置添加元素
*
* @param e
*/
public void addFirst(E e) {
add(0, e);
}
/**
* 取出指定索引的元素
*
* @param index
* @return
*/
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);
}
/**
* 判断数组中是否包含指定元素
*
* @param e
* @return
*/
public boolean contains(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) { //这里做了修改
return true;
}
}
return false;
}
/**
* 查找值为e的索引值
*
* @param e
* @return
*/
public int find(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) { //这里做了修改
return i;
}
}
return -1;
}
/**
* 删除指定位置的值
* @param index
* @return
*/
public E remove(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Delete failed. Index illegal");
}
E res = data[index];
if(index < size -1) { //如果不是最后一个元素
for (int i = index; i < size; i++) {
data[i] = data[i + 1];
}
}
size--;
data[size] = null; //垃圾回收,loitering objects
//如果删除后元素数量太少,调整数组大小
if (size == data.length / 4 && data.length/2 != 0) {
resize(data.length / 2);
}
return res;
}
/**
* 删除第一个元素
*
* @return
*/
public E removeFirst() {
return remove(0);
}
/**
* 删除最后一个元素
*
* @return
*/
public E removeLast() {
return remove(size - 1);
}
/**
* 删除第一个e
*
* @param e
* @return
*/
public boolean removeElement(E e) {
int index = find(e);
if (index != -1) {
remove(index);
return true;
}
return false;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(String.format("Array:size = %d, capacity = %d \n", size, data.length));
sb.append("[");
for (int i = 0; i < size; i++) {
sb.append(data[i]);
if (i != size - 1) {
sb.append(", ");
}
}
sb.append("]");
return sb.toString();
}
/**
* 扩容
*
* @param 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;
}
}
2. 实现栈的功能
首先,定义一个Stack接口
public interface Stack<E> {
void push(E e);
E pop();
E peak();
int getSize();
boolean isEmpty();
}
实现栈的功能
import MyStack.Array;
public class ArrayStack<E> implements Stack<E> {
Array<E> array;
public ArrayStack(int capacity){
array = new Array<E>(capacity);
}
public ArrayStack(){
array = new Array<E>();
}
@Override
public void push(E e) {
array.addLast(e);
}
@Override
public E pop() {
return array.removeLast();
}
@Override
public E peak() {
return array.getLast();
}
@Override
public int getSize() {
return array.getSize();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("Stack:");
sb.append("[");
for(int i=0 ; i<array.getSize() ;i++){
sb.append(array.get(i));
if (i != array.getSize()-1) {
sb.append(", ");
}
}
sb.append("] top");
return sb.toString();
}
}
3. 实例演示
输入一个带有括号的字符串,判断括号是否匹配,例如"{([])}","()[]{}","{}[()]“这些类似的都是匹配的,而”{(})[]"这种就是不匹配的。用栈就可以很好的解决这个问题:
package Solution;
import java.util.Stack;
public class Solution {
public static void main(String[] args) {
Solution s = new Solution();
boolean flag = s.isValid("{()}[]");
System.out.println(flag);
}
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 (topChar == '(' && c != ')')
return false;
if (topChar == '[' && c != ']')
return false;
if (topChar == '{' && c!='}')
return false;
}
}
return stack.isEmpty();
}
}