[数据结构]Java 基于链表和泛型的栈结构

大致测试了下 似乎没问题、姑且不管效率问题、仅仅演示逻辑、仅以记录、

package com.study;

import java.util.EmptyStackException;
import java.util.Stack;

class Linked<T> {
    private Linked<T> before = null; // 前驱
    private Linked<T> after = null; // 后继
    private T obj;

    public boolean hasNext() {
        return after != null;
    }

    public boolean hasLast() {
        return null != before;
    }

    public Linked<T> getBefore() {
        return before;
    }

    public void setBefore(Linked<T> before) {
        this.before = before;
    }

    public Linked<T> getAfter() {
        return after;
    }

    public void setAfter(Linked<T> after) {
        this.after = after;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((obj == null) ? 0 : obj.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Linked other = (Linked) obj;
        if (this.obj == null) {
            if (other.obj != null)
                return false;
        } else if (!this.obj.equals(other.obj))
            return false;
        return true;
    }

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }

    public Linked(T obj) {
        this.obj = obj;
    }
}

public class StackDemo2<K> extends Stack<K> {

    private Linked<K> item = null; // 最后一个元素
    private int position = -1;

    @Override
    public K push(K item) {
        // TODO Auto-generated method stub
        if (null == this.item) {
            this.item = new Linked<K>(item);
        } else {
            Linked<K> tmp = new Linked<K>(item);
            this.item.setAfter(tmp);
            tmp.setBefore(this.item);
            this.item = tmp;
        }
        position++;
        return item;
    }

    @Override
    public synchronized K pop() {
        if (this.empty())
            throw new EmptyStackException();
        K item = this.item.getObj();

        this.item.setObj(null);
        this.item = this.item.getBefore();
        this.item.setAfter(null);

        position--;

        return item;
    }

    @Override
    public synchronized K peek() {
        if (this.empty())
            throw new EmptyStackException();

        return this.item.getObj();
    }

    @Override
    public boolean empty() {
        // TODO Auto-generated method stub
        return this.item == null || this.item.getObj() == null;
    }

    @Override
    public synchronized int search(Object o) {
        return getIndex(o, this.item, 0);
    }

    private int getIndex(Object o, Linked<K> L, int inx) {
        if (L.getObj().equals(o))
            return position - inx + 1;

        if (L.hasLast())
            return getIndex(o, L.getBefore(), inx + 1);

        return -1;
    }
}