单链表实现队列和栈

单链表实现队列很简单，因为队列是先入先出FIFO，所以入队就是在单链表的头插入数据，出队就是在单链表的尾得到数据，然后删除。

队列的接口：

public interface Queue {
    void put(int data);
    int pop();
    void display();
}

接口实现：

public class QueueImpl implements Queue {

    private LinkList linkList = new LinkListImpl();
    @Override
    public void put(int data) {
        linkList.insert(1,data);
    }

    @Override
    public int pop() {
        int data = linkList.get(linkList.getSize());
        linkList.delete(linkList.getSize());
        return data;
    }
    @Override
    public void display(){
        if(linkList.getSize()==0){
            return;
        }else{
            linkList.display();
        }
    }
}

栈的结构是先入后出，所以就是在单链表的头插入数据，在单链表的头取数据，然后删除

接口：

public interface Stack {
    void put(int data);

    int pop();

    boolean isEmpty();
}

public class StackImpl implements Stack {
    private int top;
    private LinkList linkList = new LinkListImpl();

    public StackImpl() {
        top = -1;
    }

    @Override
    public void put(int data) {
        linkList.insert(1, data);
        top++;
    }

    @Override
    public int pop() {
        int data = linkList.get(1);
        linkList.delete(1);
        top--;
        return data;
    }

    public boolean isEmpty() {
        return top == -1;
    }
}

然后是主函数的调用：

        Queue queue = new QueueImpl();
        queue.put(1);
        queue.put(2);
        queue.put(3);
        int q = queue.pop();
        System.out.println(q);
        queue.display();


        Stack stack = new StackImpl();
        stack.put(1);
        stack.put(2);
        stack.put(3);
        stack.put(4);
        System.out.println(stack.pop());

输出：

单链表的定义如下：

public interface LinkList {
    void add(int data);

    void insert(int car, int data);

    void display();

    void delete(int car);

    int get(int curr);

    int getSize();
}

public class LinkListImpl implements LinkList {

    int size;
    private Node head;

//    public LinkListImpl() {
//        this.size = 0;
//        cur = null;
//        head = null;
//    }

    private class Node {
        int data;
        Node next;

        public Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    @Override
    public void add(int data) {
        Node node = new Node(data);
        if (size == 0) {
            head = node;
        } else {
            Node cur = head;
            while(cur.next!=null){
                cur = cur.next;            
            }
            cur.next = node;
        }
        size++;
    }

    @Override
    public int get(int curr) {
        if (curr > size) {
            return -1;
        }
        Node cur = head;
        for (int i = 1; i < curr; i++) {
            cur = cur.next;
        }
        return cur.data;
    }

    @Override
    public void insert(int curr, int data) {
        if (curr == 1) {
            Node node = new Node(data);
            node.next = head;
            head = node;
        } else {
            Node point = head;
            Node node = new Node(data);
            for (int i = 1; i < curr; i++) {
                point = point.next;
            }
            node.next = point.next;
            point.next = node;
        }
        size++;

    }

    @Override
    public void display() {
        if (size == 0) {
            return;
        } else {
            Node point = head;
            for (int i = 0; i < size; i++) {
                System.out.print(point.data);
                point = point.next;
                if (i == size - 1) break;
                else System.out.print("->");
            }
            System.out.println("");
        }


    }

    @Override
    public void delete(int cur) {
        if (cur > size) {
            return;
        } else {
            if (cur == 1) {
                head = head.next;
                size--;
            } else {
                Node prePoint = head;
                Node curPoint = prePoint.next;
                for (int i = 2; i < cur; i++) {
                    prePoint = prePoint.next;
                    curPoint = prePoint.next;
                }
                prePoint.next = curPoint.next;
                size--;
            }

        }
    }

    @Override
    public int getSize() {
        return size;
    }
}

单链表补充：insert时要注意单链表不存在的情况和尾指针的位置。