链表实现stack和queue,java实现（ADT思想）

第一部分：

链表实现Stack

package com.liu.Link;

//栈处理类
public class LinkStack3 {
    private LinkList3 theList;
    //构造函数防止空指针异常错误
    public LinkStack3()
    {
        theList = new LinkList3();
    }
    public void push(long d)
    {
        theList.insertFirst(d);
    }
    public long pop()
    {
        return theList.deleteFirst();
    }
    public boolean isEmpty()
    {
        return theList.isEmpty();
    }
    public void display()
    {
        System.out.print("Stack (top-->bottom):");
        theList.displayStack();
    }
}

class LinkStackApp
{
    public static void main(String[] args)
    {
        LinkStack3 theStack = new LinkStack3();
        theStack.push(1111);
        theStack.push(40);
        theStack.display();
        
        theStack.push(60);
        theStack.push(80);
        theStack.display();
        
        theStack.pop();
        theStack.pop();
        theStack.display();
        
    }
}


//链表处理类
class LinkList3
{
    private Link3 first;
    public LinkList3()
    {
        first = null;
    }
    public boolean isEmpty()
    {
        return (first == null);
    }
    public void insertFirst(long dd)
    {
        Link3 newLink = new Link3(dd);
        newLink.next = first;
        first = newLink;
    }
    public long deleteFirst()
    {
        Link3 temp = first;
        first = first.next;
        return temp.dData;
    }
    public void displayStack()
    {
        Link3 current = first;
        while(current!=null)
        {
            //System.out.print(current.dData+" ");
            current.displayLink();
            current = current.next;
        }
        System.out.println("");
    }
}


//数据类型类
class Link3
{
    public long dData;
    public Link3 next;
    public Link3(long dd)
    {
        dData = dd;
    }
    public void displayLink()
    {
        System.out.print(dData+" ");
    }
}

第二部分：

链表实现Queue

package com.liu.Link;

class LinkQueueApp
{
    public static void main(String[] args)
    {
        LinkQueue theQueue = new LinkQueue();
        theQueue.insert(10);
        theQueue.insert(20);
        theQueue.displayQueue();
        
        theQueue.insert(30);
        theQueue.insert(40);
        theQueue.insert(50);
        theQueue.displayQueue();
        
        theQueue.remove();
        theQueue.remove();
        theQueue.displayQueue();
    }
}


public class LinkQueue {
    private LinkList4 theList;
    public LinkQueue()
    {
        theList = new LinkList4();
        
    }
    public boolean isEmpty()
    {
        return theList.isEmpty();
    }
    public void insert(long d)
    {
        theList.insertLast(d);
    }
    public long remove()
    {
        return theList.deleteFirst();
    }
    public void displayQueue()
    {
        System.out.print("Queue (front-->rear):");
        theList.displayList();
    }
}

class LinkList4
{
    private Link4 first;
    private Link4 last;
    public LinkList4()
    {
        first = null;
        last = null;
    }
    public boolean isEmpty()
    {
        return first == null;
    }
    public void insertLast(long d)
    {
        Link4 newLink = new Link4(d);
        if(isEmpty())
            first = newLink;
        else
            last.next = newLink;
        last = newLink;
    }
    
    public long deleteFirst()
    {
        long temp = first.dData;
        //这种情况为只有一个元素的情况，要注意尾指针的位置
        if(first.next == null)
        {
            last = null;
        }
        first = first.next;
        return temp;
    }
    
    public void displayList()
    {
        Link4 current = first;
        while(current!=null)
        {
            current.displayLink();
            current = current.next;
        }
        System.out.println("");
    }
}

//链表类
class Link4
{
    public long dData;
    public Link4 next;
    public Link4(long d)
    {
        dData = d;
    }
    public void displayLink()
    {
        System.out.print(dData+" ");
    }
}