数据结构——栈

  之前写了很多数据结构的算法，这里就不过多解释，直接上代码。

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)