Java鏈表設計

鏈表

1，鏈表的實現

　　在實際開發之中對象數組是一項非常實用的技術，並且利用其可以描述出“多”方的概念，例如：一個人有多本書，則在人的類里面一定要提供有一個對象數組保存書的信息，但是傳統的對象數組依賴於數組的概念，所以數組里面最大的缺點在於：長度是固定的，正是因為如此在實際開發之中，傳統的數組應用是非常有限的（數組的接收與循環處理），如果想要實現靈活的數據保存，那么就必須自己來實現結構。

 

　　傳統的對象數組的開發依賴於腳標（索引）的控制，如果想要實現內容的動態控制，那么難度太高了，而且復雜度攀升，所以現在就可以，對於一成不變的數據可以使用對象數組來實現，但是對於可能隨時變化的數據就必須實現一個可以動態擴充的對象數組。

　　所謂的鏈表實質性的本質是利用引用的邏輯關系來實現類似於數組的數據處理操作，以保存多方數據的數組類似的功能

　　通過分析可得，如果想要實現鏈表處理，那么需要有一個公共的結構，這個結構可以實現數據的保存以及下一個數據的連接的指向，為了描述這樣一個邏輯，可以把每個存儲理解為一個節點類，所以此時應該准備出一個節點類出來，但是這個節點類里面可以保存各種類型類型的數據。

 

　　雖然已經清楚需要使用Node節點進行數據的保存，但是畢竟這里面需要牽扯到節點的引用處理關系，那么這個引用處理關系是由使用者來控制嗎?這樣肯定不可能，所以應該由一個專門的類來進行節點的引用關系的配置。

范例：直接操作node很麻煩

class Node<E>{
    private E data;
    private Node next;
    public Node(E data) {
        this.data = data;
    }
    public E getData() {
        return this.data;
    }
    public void setNext(Node<E> next) {
        this.next = next;
    }
    public Node getNext() {
        return this.next;
    }
}
public class Main {
    public static void main(String[] args) {
        Node<String> n1=new Node<String>("火車頭");
        Node<String> n2=new Node<String>("車廂一");
        Node<String> n3=new Node<String>("車廂二");
        Node<String> n4=new Node<String>("車廂三");
        Node<String> n5=new Node<String>("車廂四");

        n1.setNext(n2);
        n2.setNext(n3);
        n3.setNext(n4);
        n4.setNext(n5);

        print(n1);
//        System.out.println("Hello World!");
    }
    public static void print(Node<?> node){
        if (node!=null){//存在節點
            System.out.println(node.getData());
            print(node.getNext());//遞歸調用
        }
    }
}

 

 這樣肯定不可能，所以應該由專門的類來進行節點的引用關系的配置。因為真實的使用者實際上關心的只是數據的存取與獲取，所以現在應該對Node類進行包裝處理。

  

 

2，數據增加

通過之前的分析可以發現在進行鏈表操作的過程之中為了避免轉型的異常處理應該使用泛型，同時也應該設計一個鏈表的執行標准的接口，同時具體實現該接口的時候還應該通過Node類做出節點的關系描述。

范例：基本結構

interface ILink<E>{
    public void add(E e);
}
class LinkImpl<E> implements ILink<E>{
    private class Node{//保存節點的數據關系，【內部類形式】
        private E data;//保存的數據
        public Node(E data){//有數據的情況下才有意義
            this.data=data;
        }
    }
    //--------------以下為Link類中定義的結構---------
}

 

范例：實現數據增加現在在所定義的Node類之中並沒有出現setter和getter方法，是因為內部類中的私有屬性也方便外部類直接訪問。

interface ILink<E>{
    public void add(E e);
}
class LinkImpl<E> implements ILink<E>{
    private class Node{//保存節點的數據關系，【內部類形式】
        private E data;//保存的數據
        private Node next;
        public Node(E data){//有數據的情況下才有意義
            this.data=data;
        }
        //第一次調用：this = LinkImpl.root;
        //第二次調用：this = LinkImpl.root.next;
        //第三次調用：this = LinkImpl.root.next.next;
        public void addNode(Node newNode){//保存新的node數據
            if(this.next==null){//當前節點的下一個節點為空
                this.next=newNode;//保存當前節點
            }else{
                this.next.addNode(newNode);
            }
        }
    }
    //--------------以下為Link類中定義的成員---------
    private Node root;//保存根元素
    //--------------以下為Link類中定義的方法---------

    @Override
    public void add(E e) {
        if(e==null){//保存的數據為空
            return;
        }
        //數據本身不具有關聯特性的，只有Node類有，那么要想實現關聯處理就必須將數據封裝在Node類中
        Node newNode=new Node(e);
        if(this.root==null){//現在沒有根節點
            this.root=newNode;
        }else {//根節點存在
            this.root.addNode(newNode);//將新節點保存在合適的位置
        }

    }
}
public class Main {
    public static void main(String[] args) {
        ILink<String> all=new LinkImpl<String>();
        all.add("wanyu");
        all.add("hello");
        all.add("world");
        all.add("great");
    }

}

 

 Link類只是負責數據的操作與根節點的處理，而所有后續節點的處理全部都是由Node類負責完成的。

3，獲取集合個數 public int size()

在鏈表中往往需要保存有大量的數據，那么這些數據往往需要進行數據個數的統計操作，所以應該在LinkImpl子類里面追加有數據統計信息，同時增加與刪除時都應該對個數進行修改。

①在ILink接口里追加一個獲取數據個數的方法：

interface ILink<E>{//設置泛型避免安全隱患
    public void add(E e);//增加數據
    public int size();//獲取數據的個數
}

 

②在LinkImpl的子類中追加有一個個數統計的子類

private int count;

 

③在add()的方法里面進行數據個數的追加

@Override
public void add(E e) {
    if(e==null){//保存的數據為空
        return;
    }
    //數據本身不具有關聯特性的，只有Node類有，那么要想實現關聯處理就必須將數據封裝在Node類中
    Node newNode=new Node(e);
    if(this.root==null){//現在沒有根節點
        this.root=newNode;
    }else {//根節點存在
        this.root.addNode(newNode);//將新節點保存在合適的位置
    }
    this.count++;
}

 

④在LinkImpl的子類中里面來返回數據的個數

public int size(){
    return this.count;
}

只是對於數據保存中的一個輔助功能。

范例：完整程序

interface ILink<E>{//設置泛型避免安全隱患
    public void add(E e);//增加數據
    public int size();//獲取數據的個數
}
class LinkImpl<E> implements ILink<E>{
    private class Node{//保存節點的數據關系，【內部類形式】
        private E data;//保存的數據
        private Node next;
        public Node(E data){//有數據的情況下才有意義
            this.data=data;
        }
        //第一次調用：this = LinkImpl.root;
        //第二次調用：this = LinkImpl.root.next;
        //第三次調用：this = LinkImpl.root.next.next;
        public void addNode(Node newNode){//保存新的node數據
            if(this.next==null){//當前節點的下一個節點為空
                this.next=newNode;//保存當前節點
            }else{
                this.next.addNode(newNode);
            }
        }
    }
    //--------------以下為Link類中定義的成員---------
    private Node root;//保存根元素
    private int count;
    //--------------以下為Link類中定義的方法---------
    @Override
    public void add(E e) {
        if(e==null){//保存的數據為空
            return;
        }
        //數據本身不具有關聯特性的，只有Node類有，那么要想實現關聯處理就必須將數據封裝在Node類中
        Node newNode=new Node(e);
        if(this.root==null){//現在沒有根節點
            this.root=newNode;
        }else {//根節點存在
            this.root.addNode(newNode);//將新節點保存在合適的位置
        }
        this.count++;
    }
    public int size(){
        return this.count;
    }
}
public class Main {
    public static void main(String[] args) {
        ILink<String> all=new LinkImpl<String>();
        System.out.println("【增加之前：】數據個數："+all.size());
        all.add("wanyu");
        all.add("hello");
        all.add("world");
        all.add("great");
        System.out.println("【增加之后：】數據個數："+all.size());
    }
}

  

4，空集合判斷public boolean isEmpty()

鏈表里面可以保存有若干個數據，如果說現在鏈表還沒有保存數據，則就表示是一個空集合。

①在ILink接口里面追加有判斷方法：

public boolean isEmpty();//判斷是否為空集合

使用根節點和個數本質一樣。

②在LinkImpl子類里面覆寫此方法；

    public boolean isEmpty(){
//        return this.root==null;
        return this.count==0;
    }

 

5，返回集合數據 public Object[] toArray()

鏈表本身就屬於一個動態對象數組，那么既然屬於一個對象數組，就應該可以把所有的數據以數組的形式返回，那么這個時候就可以定義一個toArray()方法，但是這個時候的方法只能夠返回Object型的數組。

 

 

①在ILink接口里面追加新的處理方法

public Object[] toArray();//將集合元素以數組的形式返回

 

②在LinkImpl子類里面追加有兩個屬性，

private int foo;//描述操作數組的腳標
private Object[] returnData;//返回的數據保存

 

③在Node類中根據遞歸獲取數據

//第一次調用：this=LinkImpl.root
//第二次調用：this=LinkImpl.root.next
//第三次調用：this=LinkImpl.root.next.mext
public void toArrayNode(){
    LinkImpl.this.returnData [foo++]=this.data;
    if (this.next!=null){//還有下一個數據
        this.next.toArrayNode();
    }
}

 

④在進行數據返回的時候一定要首先判斷是否為空集合； 

@Override
public Object[] toArray() {
    if(this.isEmpty()){//空集合
        return null;//現在沒有數據
    }
    this.foo=0;//腳標清零
    this.returnData=new Object[this.count];

    //根據已有的數據長度開辟數組
    this.root.toArrayNode();//利用Node類進行遞歸獲取數據
    return this.returnData;
}

 

 集合的數據一般如果要返回肯定要以對象的形式返回。

6，根據索引取得數據public E get(int index)

鏈表可以向數組一樣處理，所以也應該可以向數組一樣進行索引數據的獲取，再這樣的情況下我們可以使用遞歸的形式來完成。

 

①在ILink接口中追加有新的方法

public E get(int index);//根據索引獲取數據

 

②在Node類里面追加有根據索引獲取數據的處理 

@Override
public E get(int index) {
    if (index>=this.count){//索引應該在指定的范圍之內
        return null;
    }//索引數據的獲取應該由Node類完成
    this.foot=0;//重置索引的下標
    return this.root.getNode(index);
}

 這一特點和數組很相似，但是需要注意，數組獲取一個數據的時間復雜度為1，而鏈表獲取一個數據的時間復雜度為n。

7，鏈表（修改指定索引數據）

現在已經可以根據索引來獲取指定的數據了，但是既然可以獲取數據，那么也可以進行數據的修改。

①在ILink接口中追加新的方法

public void set(int index,E data);//修改索引數據

 

②在Node類之中應該提供有數據修改的處理支持

public void setNode(int index,E data){
    if(LinkImpl.this.foot++==index){//索引相同
        this.data=data;//返回當前數據
    }else{
        this.next.setNode(index,data);
    }
}

 

③在LinkImpl中進行方法覆寫

@Override
public void set(int index, E data) {
    if (index>=this.count){//索引應該在指定的范圍之內
        return ;//方法結束
    }//索引數據的獲取應該由Node類完成
    this.foot=0;//重置索引的下標
    this.root.setNode(index,data);//修改數據
}

 這種操作的時間復雜度也是N，因為也是需要進行數據的遍歷處理

8，鏈表（判斷數據是否存在）public boolean contains(E data)

在一個集合里面往往會保存有大量的數據，有些時候需要判斷某個數據是否存在，這個時候就可以通過對象比較的模型（equals()）進行判斷。

①在ILink接口中追加判斷方法

public boolean contains(E data);//判斷數據是否存在

 

②在Node類中進行依次判斷

public boolean containsNode(E data) {
    if(this.data.equals(data)){//對象比較
        return true;
    }else {
        if(this.next==null){//沒有后續節點了
            return false;//找不到數據
        }else {
            return this.next.containsNode(data);
        }
    }
}

 

③在LinkImpl子類里面實現此方法

@Override
public boolean contains(E data) {
    if(data==null){
        return false;
    }
    return this.root.containsNode(data);//交給Node類判斷
}

 由於整個鏈表沒有null數據的存在，所以整體的程序在判斷的時候直接使用每個節點數據發出的equals()方法調用即可。

9，鏈表（數據刪除）public void remove(E data)

數據的刪除指的是可以從集合里面刪除掉指定的一個數據內容，也就是說此時傳遞的是數據內容，那么如果要實現這種的刪除操作，依然需要對象的比較的支持，但是對於集合數據的刪除需要考慮兩種情況：

·要刪除的是根節點（LinkImpl與根節點有關，所以這個判斷由根節點完成）：

 

·要刪除的不是根節點（由Node類負責）：

 

①在ILink接口中追加新的方法；

public void remove(E e);//數據刪除

 

②在LinkImpl子類里面實現根節點的判斷； 

@Override
public void remove(E data) {
    if(this.contains(data)){//判斷數據是否存在
        if (this.root.data.equals(data)){//根節點為要刪除節點
            this.root=this.root.next;//根的下一個節點
        }
    }
}

 

③如果現在根節點並不是要刪除的節點，那么就需要進行后續節點判斷，但是請一定要記住，此時的根節點已經判斷完成，在判斷應該從下一個節點開始判斷，在Node類中追加刪除處理。

 

public void removeNode(Node previous,E data){
    if(this.data.equals(data)){
        previous.next=this.next;//空出當前節點
    }else {
        if(this.next!=null){//有后續節點
            this.next.removeNode(this,data);//向后繼續刪除
        }
    }
}

 

 

 

④完善LinkImpl子類中的remove方法

 

@Override
public void remove(E data) {
    if(this.contains(data)){//判斷數據是否存在
        if (this.root.data.equals(data)){//根節點為要刪除節點
            this.root=this.root.next;//根的下一個節點
        }else {//交由Node類負責刪除
            this.root.next.removeNode(this.root,data);
        }
        this.count--;
    }
}

 

 

 

 刪除的邏輯依靠的就是引用的改變處理完成的。

10，鏈表（清空數據）public void clean()

有些時候需要進行鏈表的整體清空處理，這個時候就可以直接根據根節點元素來進行控制，只要root設置為null，那么后續節點就都不存在了。

①在ILink接口中里面追加有清空處理方法

public void clean();//清空集合

 

②在LinkImpl的子類里面覆寫方法 

@Override
public void clean() {
    this.root=null;//后續的所有節點都沒了
    this.count=0;//個數清零
}

 

 這些就是鏈表的基本功能，當然這只是一個最簡單、最基礎的單向鏈表

11，綜合實戰：寵物商店

現在假設有一個寵物商店里面可以出售各種寵物，要求可以實現寵物的上架處理、下架處理，也可以根據我們的關鍵字查詢出寵物的信息。

①應該定義出寵物的標准

interface Pet{//定義寵物的標准
    public String getName();//獲得名字
    public String getColor();//獲得顏色
}

 

②寵物商店應該以寵物的標准為主 

class PetShop{//寵物商店
    private ILink<Pet> allPets=new LinkImpl<Pet>();//保存多個寵物信息
    public void add(Pet pet){//追加寵物，商品上架
        this.allPets.add(pet);//集合中保存對象
    }
    public void delete(Pet pet){
        this.allPets.remove(pet);//集合中保存對象
    }
    public ILink<Pet> search(String keyword){
        ILink<Pet> searchResult=new LinkImpl<Pet>();//保存查詢結果
        Object[] result=this.allPets.toArray();//獲取全部數據
        if(result!=null){
            for(Object obj:result){
                Pet pet=(Pet) obj;
                if(pet.getName().contains(keyword)||pet.getColor().contains(keyword)){
                    searchResult.add(pet);//保存查詢結果
                }
            }
        }
        return searchResult;
    }
}

③根據寵物的標准來定義寵物的信息

class Cat implements Pet{//實現寵物標准
    private String name;
    private String color;

    public Cat(String name, String color) {
        this.name = name;
        this.color = color;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getColor() {
        return color;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj==null){
            return false;
        }
        if(!(obj instanceof Cat)){
            return false;
        }
        if (this==obj){
            return true;
        }
        Cat cat=(Cat) obj;
        return this.name.equals(cat.name) && this.color.equals(cat.color);
    }

    @Override
    public String toString() {
        return "【寵物貓】名字："+this.name+",顏色："+this.color;
    }
}

 

④實現寵物商店的操作

public class Main {
    public static void main(String[] args) {
        PetShop shop=new PetShop();//開店
        shop.add((new Dog("黃斑狗","綠色")));
        shop.add((new Cat("小強貓","深綠色")));
        shop.add((new Cat("黃貓","深色")));
        shop.add((new Dog("黃狗","黃色")));
        shop.add((new Dog("斑點狗","灰色")));
        Object[] result=shop.search("黃").toArray();
        if(result!=null){
            for(Object temp:result){
                System.out.println(temp.toString());
            }
        }
    }
}

 

 所有的程序開發都是以接口為標准進行開發的，這樣在進行后期程序處理的時候就可以非常的靈活，只要符合標准的對象都可以保存。

12，綜合實戰：超市實戰

①定義一個商品的標准

interface IGoods{//定義商品的標准
    public String getName();
    public double getPrice();
}

 

 ②定義購物車處理標准

interface IShopCar{//購物車的標准
    public void add(IGoods goods);//添加商品信息
    public void delete(IGoods goods);//添加商品信息
    public Object[] getAll();//獲得購物車中的全部商品信息
}

 

③定義購物車的實現類

class ShopCarImpl implements IShopCar{//購物車
    private ILink<IGoods> allGoodses=new LinkImpl<IGoods>();
    public void add(IGoods goods){
        this.allGoodses.add(goods);
    }
    public void delete(IGoods goods){
        this.allGoodses.remove(goods);
    }
    public Object[] getAll(){
        return this.allGoodses.toArray();
    }
}

 

④定義收銀台 

class Cashier{//收銀台
    private IShopCar shopCar;//駝峰命名法
    public Cashier(IShopCar shopCar) {
        this.shopCar = shopCar;
    }
    public double allPrice(){//計算商品總價
        double money=0.0;
        Object[] result=this.shopCar.getAll();
        if(result!=null){
            for(Object obj:result){
                IGoods goods=(IGoods) obj;
                money +=goods.getPrice();
            }
        }
        return money;
    }
    public int allCount(){//計算商品總個數
        return this.shopCar.getAll().length;
    }
}

 

⑤定義商品信息

class Book implements IGoods{
    private String name;
    private double price;
    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }
    @Override
    public String getName() {
        return this.name;
    }
    @Override
    public double getPrice() {
        return this.price;
    }
    public boolean equals(Object obj){
        if(obj==null){
            return false;
        }
        if(this==obj){
            return true;
        }
        if (!(obj instanceof Book)){
            return false;
        }
        Book book=(Book) obj;
        return this.name.equals(book.name) && price==book.price;
    }
}

 

⑥代碼測試的編寫

public class Main {
    public static void main(String[] args) {
        IShopCar car=new ShopCarImpl();
        car.add(new Book("Java開發",79.8));
        car.add(new Book("MySql開發",40.0));
        car.add(new Book("Spring開發",99.8));
        car.add(new Bag("黑色電腦包",201.0));
        Cashier cashier=new Cashier(car);
        System.out.println("總價格："+cashier.allPrice());
        System.out.println("總數量："+cashier.allCount());
        Object[] result=car.getAll();
        if(result!=null){
            for(Object temp:result){
                System.out.println(temp.toString());
            }
        }
    }
}