棧和隊列是兩種特殊的線性表，它們的邏輯結構和線性表相同，只是其運算規則較線性表有更多的限制，故又稱它們為運算受限的線性表。
LinkedList數據結構是一種雙向的鏈式結構，每一個對象除了數據本身外，還有兩個引用，分別指向前一個元素和后一個元素，和數組的順序存儲結構（如：ArrayList）相比，插入和刪除比較方便，但速度會慢一些。
棧的定義
??? 棧（Stack）是限制僅在表的一端進行插入和刪除運算的線性表。
(1)通常稱插入、刪除的這一端為棧頂（Top），另一端稱為棧底（Bottom）。
(2)當表中沒有元素時稱為空棧。
(3)棧為后進先出（Last In First Out）的線性表，簡稱為LIFO表。
??? 棧的修改是按后進先出的原則進行。每次刪除（退棧）的總是當前棧中"最新"的元素，即最后插入（進棧）的元素，而最先插入的是被放在棧的底部，要到最后才能刪除。
實現代碼：
package com.gc.list;
import java.util.*;
public class MyStack {
?private LinkedList ll=new LinkedList();
?
?public void push(Object o){
??ll.addFirst(o);
?}
?public Object pop(){
??return ll.removeFirst();
?}
?
?public Object peek(){
??return ll.getFirst();
?}
?
?public boolean empty(){
??return ll.isEmpty();
?}
?
?public static void main(String[] args){
??MyStack ms=new MyStack();
??ms.push("zhangsan");
??ms.push("lisi");
??ms.push("wangwu");
??
??System.out.println(ms.pop());
??System.out.println(ms.peek());
??System.out.println(ms.pop());
??System.out.println(ms.empty());
?}
}
隊列定義
??? 隊列（Queue）是只允許在一端進行插入，而在另一端進行刪除的運算受限的線性表
（1）允許刪除的一端稱為隊頭（Front）。
（2）允許插入的一端稱為隊尾（Rear）。
（3）當隊列中沒有元素時稱為空隊列。
（4）隊列亦稱作先進先出（First In First Out）的線性表，簡稱為FIFO表。
實現代碼：
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();
?}
?
?public static void main(String[] args){
??MyQueue mq=new MyQueue();
??mq.put("zhangsan");
??mq.put("lisi");
??mq.put("wangwu");
??
??System.out.println(mq.get());
??System.out.println(mq.get());
??System.out.println(mq.get());
??System.out.println(mq.empty());
??
?}
}
java 集合類的排序主要是用Collections.sort方法,Collections和Collection是不一樣的,前者是類,后者是接口,在這里,我主要是想說明它的sort方法的幾種類型,
提示：實現接口的方法時，只需要比較兩個數，大的返回1，相等返回0，小于返回-1。簡單的說就是在方法里這樣寫：num>s.num?1:(num==s.num?0:-1); num是被比較的數，s.num是比較的數，
1.Collection.sort(List arg0);
這種是最簡單的一種排序方法，只需要實現他的Comparable 接口及實現public int compareTo(Object arg0)方法即可。
2.Collection.srot(List arg0,Comparator arg1);
這種加入了比較器，具有更大的靈活性，便于管理，比較器可作為內部靜態類的，以便于管理。比較器必須實現Comparator接口，具體可參照下列代碼：
package com.gc.list;
import java.util.*;
public class ArrayListTest {
?
?public static void printElements(Collection c){
??Iterator it=c.iterator();
??while(it.hasNext()){
???System.out.println(it.next());
??}
?}
?public static void main(String[] args){
??ArrayList a1=new ArrayList();
??/*
??a1.add("zhangsan");
??a1.add("lisi");
??a1.add("wangwu");
??*/
??/*
??a1.add(new Point(1,1));
??a1.add(new Point(2,2));
??a1.add(new Point(3,3));
??
??for(int i=0;i<a1.size();i++){
???System.out.println(a1.get(i));
??}
??Object[] objs=a1.toArray();
??for(int i=0;i<objs.length;i++){
???System.out.println(objs[i]);
??}
??
??List l=Arrays.asList(objs);
??System.out.println(l);*/
??//l.add("chuyang");
??//l.set(0,new Point(4,4));
??/*
??Iterator it=a1.iterator();
??while(it.hasNext()){
???System.out.println(it.next());
??}
??*/
??Student s1=new Student(4,"zhangsan");
??Student s2=new Student(2,"lisi");
??Student s3=new Student(3,"wangwu");
??Student s4=new Student(4,"mybole");
??
??a1.add(s1);
??a1.add(s2);
??a1.add(s3);
??a1.add(s4);
??//Collections.sort(a1);
??Collections.sort(a1,new Student.StudentComparator());
??printElements(a1);
??System.out.println(Collections.max(a1));
?}
}
class Point{
?int x, y;
?Point(int x,int y){
??this.x=x;
??this.y=y;
?}
?public String toString(){
??return ("x="+x+","+"y="+y);
?}
}
class Student implements Comparable{
?int num;
?String name;
?Student(int num,String name){
??this.num=num;
??this.name=name;
?}
?static class StudentComparator implements Comparator{
??public int compare(Object o1,Object o2){
???Student s1=(Student) o1;
???Student s2=(Student) o2;
???int result=s1.num>s2.num?1:(s1.num==s2.num?0:-1);
???if (result==0){
????result=s1.name.compareTo(s2.name);
???}
???return result;
??}
?}
?public int compareTo(Object arg0) {
??Student s=(Student) arg0;
??return num>s.num?1:(num==s.num?0:-1);
?}
?public String toString(){
??return "num:"+num+","+"name:"+name;
?}
}
圖是一種復雜的非線形的結構,和樹的遍歷類似，圖的遍歷也是從某個頂點出發，沿著某條搜索路徑對圖中每個頂點各做一次且僅做一次訪問。它是許多圖的算法的基礎。
???
深度優先遍歷和廣度優先遍歷是最為重要的兩種遍歷圖的方法。它們對無向圖和有向圖均適用。
如果把圖的遍歷想成走迷宮的話，那么他們的思路是這樣的：
深度優先遍歷是一種縱向方法,它的思路是：沿著一條路走到頭,直到碰到“臉”，然后在退出來去另尋其他路,直到發現所有的路都以走完為止。
廣度優先遍歷是一種橫向方法，它的思路是：從起點開始，假如我面前有三條路，那么我三條路都走一下，然后看看是不是能走出去，假如不行，那我就從我走的第一條路再去找其他的路子，方法和第一次一樣，找完之后再去第二條路找其他路子，如此反復，就像打仗的步步為營，層層推進一樣，直到最后找完所有的路子。
方法雖然不同，但是效果確實一樣的。