之前写了很多数据结构的算法,这里就不过多解释,直接上代码。
Stack
package com.lyc.linearTable.stack;
import com.lyc.util.ObjectHolder;
/**
* 这里是栈运算
*/
public interface Stack {
/**
* 初始化一个空栈
* @param size
*/
void initStack(int size);
/**
* 销毁栈
*/
void destroyList();
/**
* 清空栈
*/
void cleanStack();
/**
* 栈判空
*/
boolean stackEmpty();
/**
* 栈判满
*/
boolean stackFull();
/**
* 栈长
*/
int stackLength();
/**
* 入栈
*/
boolean push(Object ele);
/**
* 出栈
*/
boolean pop(ObjectHolder ele);
/**
* 栈遍历
*/
void stackTraverse();
}
StackImpl
package com.lyc.linearTable.stack;
import com.lyc.util.ObjectHolder;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class StackImpl implements Stack{
//栈初始化长度
private int m_Size = 0;
//栈列表
private Object[] m_pList = null;
//栈中元素的长度
private int m_iTop = 0;
/**
* 初始化一个空栈
* @param size
* @return
*/
public void initStack(int size) {
this.m_Size = size;
this.m_pList = new Object[size];
this.m_iTop = 0;
}
/**
* 销毁栈
*/
public void destroyList() {
this.m_pList = null;
this.m_Size = 0;
this.m_iTop = 0;
}
/**
* 清空栈
*/
public void cleanStack() {
this.m_iTop = 0;
}
/**
* 栈判空
*/
public boolean stackEmpty() {
//如果栈顶为0,则默认为栈底位置
if(this.m_iTop == 0){
return true;
}
return false;
}
/**
* 栈判满
*/
public boolean stackFull() {
//如果栈顶长等于栈长度,则默认为栈满
if(this.m_iTop == this.m_Size){
return true;
}
return false;
}
/**
* 栈长
* @return
*/
public int stackLength() {
return this.m_iTop;
}
/**
* 入栈
* @param ele
* @return
*/
public boolean push(Object ele) {
//如果栈满,则不再在其中放入元素,直接返回false,也就是说元素入栈失败
if(this.stackFull()){
return false;
}
//将元素入栈
this.m_pList[this.m_iTop] = ele;
//当元素入栈之后,将栈顶指针上移
this.m_iTop ++;
//入栈成功后,返回true
return true;
}
/**
* 出栈
* @param ele
* @return
*/
public boolean pop(ObjectHolder ele) {
//如果栈为空,则元素出栈失败,返回false
if(this.stackEmpty()){
return false;
}
this.m_iTop --;
ele.object = this.m_pList[this.m_iTop];
return true;
}
/**
* 栈遍历
*/
public void stackTraverse() {
//如果栈不为空,则开始进行遍历操作
for(int i = 0;i < this.m_iTop;i ++){
log.info(this.m_pList[i].toString());
}
}
}
ObjectHolder
package com.lyc.util;
import lombok.Getter;
import lombok.Setter;
/**
* Created by HP on 2017/9/6.
*/
@Getter
@Setter
public class ObjectHolder {
public Object object;
}
Person
package com.lyc.linearTable.entity;
import lombok.*;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Person {
private int id;
private String name;
private int age;
}
StackTest
package com.lyc.linearTable.stack;
import com.lyc.linearTable.entity.Person;
import com.lyc.util.ObjectHolder;
import lombok.extern.slf4j.Slf4j;
import org.junit.Before;
import org.junit.Test;
@Slf4j
public class StackTest {
private Stack stack = null;
/**
* 完成栈的初始化
*/
@Before
public void testInsert(){
//创建栈
stack = new StackImpl();
//初始化栈长度
stack.initStack(10);
Person person1 = Person.builder()
.id(1)
.name("zhangsan")
.age(11)
.build();
Person person2 = Person.builder()
.id(2)
.name("lisi")
.age(22)
.build();
Person person3 = Person.builder()
.id(3)
.name("wangwu")
.age(33)
.build();
stack.push(person1);
stack.push(person2);
stack.push(person3);
}
/**
* 打印栈中的元素
*/
@Test
public void testTravers(){
//如果栈不为空,则循环遍历栈中元素
while (!stack.stackEmpty()){
ObjectHolder objectHolder = new ObjectHolder();
stack.pop(objectHolder);
Person person = (Person) objectHolder.object;
log.info(person.toString());
}
}
}
运行结果:
2018-04-08 15:07:53 INFO main com.lyc.linearTable.stack.StackTest.testTravers(StackTest.java:53) - Person(id=3, name=wangwu, age=33)
2018-04-08 15:07:53 INFO main com.lyc.linearTable.stack.StackTest.testTravers(StackTest.java:53) - Person(id=2, name=lisi, age=22)
2018-04-08 15:07:53 INFO main com.lyc.linearTable.stack.StackTest.testTravers(StackTest.java:53) - Person(id=1, name=zhangsan, age=11)