Java实现数据结构栈stack和队列Queue

Java实现数据结构栈stack和队列Queue

Google后发现大多数文章都是通过LinkedList类实现，当然JDK有自带的Stack类

 

回顾JDK提供的集合类

容器（集合）框架如下： 

集合类存放于java.util包中。集合类存放的都是对象的引用，而非对象本身。

集合类型主要有3种：set(集）、list(列表）和map(映射)。

Collection接口

├List 接口

│├LinkedList 链表

│├ArrayList 顺序结构动态数组类

│└Vector 向量

│ └Stack 栈

Map接口

├Hashtable

├HashMap

└Set接口

 Collection<--Set<--HashSet

 Collection<--Set<--HashSet<--LinkedHashSet

 Collection<--Set<--SortedSet（也是接口）<--TreeSet

 

LinkedList, 查阅JDK

List接口的链表列表实现。实现所有可选的列表操作，并且允许所有元素(包null)

LinkedList类还为在列表的开头及结尾get,remove和insert元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈，队列或双端队列

注意此实现不是同步的

 

JDK本身提供的Stack类

提供了通常的push和pop操作，以及取堆栈顶点的peek方法，测试堆栈是否为空的empty方法，在堆栈中查找项并确定离栈顶的距离，共五个方法。

JDK中实现这个类本身继承自Vector这个类(since JDK1.0)

 

数据结构中 栈的定义及基本运算

栈和队列都属于线性结构，是两种在运算上受到某些限制的特殊线性表，他们比一般线性表更简单。

栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，称为栈顶(top)，另一端为固定的一端，称为栈底

栈顶，栈底，空栈，栈的特性，

退栈，进栈

栈的运算:

初始化栈，进栈push，出栈pop，，取栈顶元素（即是查看下一个要出栈的元素，也叫peek），判断空

 

用LinkedList实现stack

其实主要是实现 进栈push，出栈pop，，取栈顶元素这几个方法

 

package org.simoncook.examtest;

 

import java.util.LinkedList;

 

public class MyStack {

       

        private LinkedList ll = new LinkedList();

       

        public void push(Object obj){

                //将指定元素插入此列表的开头。

                ll.addFirst(obj);

        }

       

        public Object pop(){

                //移除并返回此列表的第一个元素.

                return ll.removeFirst();

        }

       

        public Object peek(){

                // 返回此列表的第一个元素。

                return ll.getFirst();

        }

       

        public boolean empty(){

                return ll.isEmpty();

        }

}

 

数据结构队列

参考

http://blogger.org.cn/blog/more.asp?name=eaglebetter&id=17232

队列（Queue）的定义

队列的特性队列的实例队 列的基本运算
（1） 入队操作：InQueue（q，x）
（2）出队操作：OutQueue（q，x）
（3）读队头元 素：ReadFront（q，x）
（4）显示队列中元素ShowQueue（q）
（5）判队空操作：QEmpty（q）
（6）判 队满操作：QFull（q）
（7）求队列长度Qlen（q）

 

实现代码：
package com.gc.list;
import java.util.*;
public class MyQueue {

 private LinkedList ll=new LinkedList();
//入队操作
 public void put(Object o){
  ll.addLast(o);
 }
 //使用removeFirst()方法，返回队列中第一个数据，然后将它从队列 中删除
//出队操作
 public Object get(){
  return ll.removeFirst();
 }
 
 public boolean empty(){
  return ll.isEmpty();
 }

 

 

Java???u??stackM?CQueue
GoogleZ??jh?Oq?LinkedList???A?MJDK?Stack?

^?JDKX?
e]X^[pUG
X?s_java.util]CX?sO?HAD?HC
X?Dn3Gset(^Blist(C^Mmap(Mg)C
Collectionf
uList f
xuLinkedList ?
xuArrayList ???????
x|Vector Vq
x |Stack ?
Mapf
uHashtable
uHashMap
|Setf
 Collection<--Set<--HashSet
 Collection<--Set<--HashSet<--LinkedHashSet
 Collection<--Set<--SortedSet]]Of^<--TreeSet

LinkedList, d?JDK
Listf?C??C??i?C@A}B?(]null)
LinkedList???bC???get,removeMinsertF?@RWkC?@???C@?A?C??C
`N??OPB

JDKStack?
Fq`pushMpop@AH???peekkA???O_?emptykAb?d?}w??ZA@?kC
JDK??????Vector???(since JDK1.0)

?u? ?w??
?M?C?_??AO?b?WYS?AL?@???C
?(stack)O?JM?ub?P@?@S?C?JM?@A????(top)At@?Tw@A???
??A?A?A?SA
h?A??
??:
l?A??pushAX?popAA??]YOdU@?nX?A]speek^AP?

LinkedList??stack
?DnO?? ??pushAX?popAA???L?k

package org.simoncook.examtest;

import java.util.LinkedList;

public class MyStack {
    
    private LinkedList ll = new LinkedList();
    
    public void push(Object obj){
        //?wJC??C
        ll.addFirst(obj);
    }
    
    public Object pop(){
        //}^C@?.
        return ll.removeFirst();
    }
    
    public Object peek(){
        // ^C@?C
        return ll.getFirst();
    }
    
    public boolean empty(){
        return ll.isEmpty();
    }
}

?u??C
?http://blogger.org.cn/blog/more.asp?name=eaglebetter&id=17232
?C]Queue^w?
?CS?C?? C?
]1^ J?@GInQueue]qAx^
]2^X?@GOutQueue]qAx^
]3^??? GReadFront]qAx^
]4^??CShowQueue]q^
]5^P?@GQEmpty]q^
]6^P ??@GQFull]q^
]7^D?C?Qlen]q^

??N?G
package com.gc.list;
import java.util.*;
public class MyQueue {
 private LinkedList ll=new LinkedList();
//J?@
 public void put(Object o){
  ll.addLast(o);
 }
 //removeFirst()kA^?C@??uAMZ???C ?
//X?@
 public Object get(){
  return ll.removeFirst();
 }
 
 public boolean empty(){
  return ll.isEmpty();
 }