使用数组的方式实现队列和栈的数据结构
基于上面一篇文章的Array数组类。
Array数组类的实现
package com.soecode.lyf.datastruct.array;
/** 最基本的数据结构 数组
* @author 魏文思
* @date 2019/8/30$ 14:23$
*/
public class Array {
private E[] data;
//假设初始长度
private int size;
public Array(int capcity) {
data = (E[]) new Object[capcity];
size = 0;
}
public Array() {
}
//获取数组的容量
public int getCapacity() {
return data.length;
}
//获取数组中的元素个数
public int getSize() {
return size;
}
// 返回数组是否为空
public boolean isEmpty() {
return size == 0;
}
//向数组指定索引中添加新的元素
public void add(int index, E e) {
if (size == data.length) {
// throw new RuntimeException("容量超出限制");
//对数组进行扩容
resize(2 * data.length);
}
if (index < 0 || index > size) {
throw new RuntimeException("参数输入错误");
}
for (int i = size - 1; i >= index; i--)
//将下标为index右面的数据整体进行右移，然后空出来一个我们需要的空间
data[i + 1] = data[i];
//将数据存储到指定位置
data[index] = e;
size++;
}
// 从数组中删除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; //将最后一位数据置空，防止内存泄漏
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);
}
//在数组的后面追加一个元素
public void addLast(E e) {
add(size, e);
}
//获取index索引位置的元素
public E get(int index) {
if (index < 0 || index >= size)
throw new RuntimeException("数组下标错误");
return data[index];
}
//修改index数索引的元素
public void update(int index, E e) {
if (index < 0 || index >= size)
throw new RuntimeException();
data[index] = e;
}
// 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
public int find(E e){
for(int i = 0 ; i < size ; i ++){
if(data[i] == e)
return i;
}
return -1;
}
//获取数组最后一个数据
public E getLast(){
return get(size - 1);
}
//获取数组第一个数据
public E getFirst(){
return get(0);
}
// 查找数组中是否有元素e
public boolean contains(E e){
for(int i = 0 ; i < size ; i ++){
if(data[i] == e)
return true;
}
return false;
}
@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;
}
}
利用数组实现栈的数据结构
栈的特点
线性存储结构，先进后出，只能在栈顶上进行插入和删除操作
package com.soecode.lyf.datastruct.array;
/** 基于数组实现的栈数据结构
* @author 魏文思
* @date 2019/8/30$ 16:08$
*/
public class ArrayStack {
private Array array;
public ArrayStack(int capacity){
array = new Array<>(capacity);
}
//获取栈的长度
public int getSize(){
return array.getSize();
}
//判断栈的数据是否为空
public boolean isEmpty(){
return array.isEmpty();
}
//获取栈的容量
public int getCapacity(){
return array.getCapacity();
}
//入栈
public void push (E e){
array.addLast(e);
}
//出栈
public E pop(){
return array.removeLast();
}
//获取栈顶的数据
public E peek(){
return array.getLast();
}
@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();
}
public static void main(String[] args) {
ArrayStack stringArrayStack = new ArrayStack<>(5);
stringArrayStack.push("a");
stringArrayStack.push("b");
stringArrayStack.push("c");
stringArrayStack.push("d");
stringArrayStack.push("e");
stringArrayStack.push("f");
stringArrayStack.push("g");
stringArrayStack.push("h");
stringArrayStack.push("i");
stringArrayStack.push("j");
System.out.println("============================栈里全部的数据");
System.out.println(stringArrayStack.toString());
System.out.println("============================数据出栈");
System.out.println(stringArrayStack.pop());
System.out.println("============================栈顶数据");
System.out.println(stringArrayStack.peek());
}
}
数据既然明白了那么栈就很好实现
入栈就相当于将数据放入到数组的最后面，并且只能从后面添加，出栈就相当于将数组的最后一位数据移除并且只能从最后一位移除。定义数组两个删除最后一位数据和添加最后一位的数据的方法，就实现了我们的栈。
简单队列的实现
队列的特点
先进先出
只允许在最前端进行删除操作，在最后面进行添加操作，和栈一样的都是线性结构。
只有最早进入队列的元素才能最先从队列中删除，先进先出（FIFO-first in first out ）
使用数组的方式实现，代码如下：
package com.soecode.lyf.datastruct.array;
public class ArrayQueue {
private Array array;
public ArrayQueue(int capacity){
array = new Array<>(capacity);
}
public ArrayQueue(){
array = new Array<>();
}
public int getSize(){
return array.getSize();
}
public boolean isEmpty(){
return array.isEmpty();
}
public int getCapacity(){
return array.getCapacity();
}
/**
* 入队
* @param e
*/
public void enqueue(E e){
array.addLast(e);
}
/**
* 出队
* @return
*/
public E dequeue(){
return array.removeFirst();
}
/**
* 获取对头元素
* @return
*/
public E getFront(){
return array.getFirst();
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append("Queue: ");
res.append("front [");
for(int i = 0 ; i < array.getSize() ; i ++){
res.append(array.get(i));
if(i != array.getSize() - 1)
res.append(", ");
}
res.append("] tail");
return res.toString();
}
public static void main(String[] args) {
ArrayQueue queue = new ArrayQueue<>(5 );
for(int i = 0 ; i < 10 ; i ++){
queue.enqueue(i);
System.out.println(queue);
if(i % 3 == 2){
queue.dequeue();
System.out.println(queue);
}
}
}
}
入队：在数据最后添加元素
出队：移除第一个元素
执行结果如下：
Queue: front [0] tail
Queue: front [0, 1] tail
Queue: front [0, 1, 2] tail
Queue: front [1, 2] tail
Queue: front [1, 2, 3] tail
Queue: front [1, 2, 3, 4] tail
Queue: front [1, 2, 3, 4, 5] tail
Queue: front [2, 3, 4, 5] tail
Queue: front [2, 3, 4, 5, 6] tail
Queue: front [2, 3, 4, 5, 6, 7] tail
Queue: front [2, 3, 4, 5, 6, 7, 8] tail
Queue: front [3, 4, 5, 6, 7, 8] tail
Queue: front [3, 4, 5, 6, 7, 8, 9] tail