數據結構之鏈表(LinkedList)(一)

鏈表(Linked List)介紹

鏈表是有序的列表，但是它在內存中是存儲如下

1）鏈表是以節點方式存儲的，是鏈式存儲

2）每個節點包含data域（value），next域，指向下一個節點

3）各個節點不一定連續存儲，如上圖

4）鏈表分 帶頭節點的鏈表和 不帶頭節點的鏈表，根據實際需求確定

單鏈表介紹

單鏈表(帶頭結點) 邏輯結構示意圖如下

應用實例

使用帶head頭的單向鏈表實現 –學生成績錄入管理   {學號，姓名，分數}

1.完成學生成績的增刪改查操作

2.第一種方法在添加英雄時，直接添加到鏈表的尾部

3.第二種方式在添加學生時，根據學號排序，將學生插入指定位置

第一種實現思路：

添加（創建）

1. 先創建一個head 頭節點， 作用就是表示單鏈表的頭

2. 后面我們每添加一個節點，就直接加入到 鏈表的最后

遍歷：

1. 通過一個輔助變量遍歷，幫助遍歷整個鏈表

示意圖：

 

代碼實例:

package com.linkedList;

import java.util.Stack;

public class SingleLinkedListDemo {

    public static void main(String[] args) {
        //進行測試
        //先創建節點
        StuNode hero1 = new StuNode(1, "張三", "85");
        StuNode hero2 = new StuNode(2, "李四", "87");
        StuNode hero3 = new StuNode(3, "小明", "70");
        StuNode hero4 = new StuNode(4, "小紅", "90");

        //創建要給鏈表
        SingleLinkedList singleLinkedList = new SingleLinkedList();


        //加入
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero4);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);

        // 測試一下單鏈表的反轉功能
        System.out.println("原來鏈表的情況");
        singleLinkedList.list();
    }
}
//定義SingleLinkedList 管理我們的學員
class SingleLinkedList {
    //先初始化一個頭節點, 頭節點不要動, 不存放具體的數據
    private StuNode head = new StuNode(0, "", "");


    //返回頭節點
    public StuNode getHead() {
        return head;
    }

    //添加節點到單向鏈表
    //思路，當不考慮編號順序時
    //1. 找到當前鏈表的最后節點
    //2. 將最后這個節點的next 指向 新的節點
    public void add(StuNode stuNode) {

        //因為head節點不能動，因此我們需要一個輔助遍歷 temp
        StuNode temp = head;
        //遍歷鏈表，找到最后
        while(true) {
            //找到鏈表的最后
            if(temp.next == null) {//
                break;
            }
            //如果沒有找到最后, 將將temp后移
            temp = temp.next;
        }
        //當退出while循環時，temp就指向了鏈表的最后
        //將最后這個節點的next 指向 新的節點
        temp.next = stuNode;
    }

    //顯示鏈表[遍歷]
    public void list() {
        //判斷鏈表是否為空
        if(head.next == null) {
            System.out.println("鏈表為空");
            return;
        }
        //因為頭節點，不能動，因此我們需要一個輔助變量來遍歷
        StuNode temp = head.next;
        while(true) {
            //判斷是否到鏈表最后
            if(temp == null) {
                break;
            }
            //輸出節點的信息
            System.out.println(temp);
            //將temp后移， 一定小心
            temp = temp.next;
        }
    }
}
//定義StuNode ， 定義StuNode 對象就是一個節點
class StuNode {
    public int stuNo;
    public String name;
    public String mark;
    public StuNode next; //指向下一個節點
    //構造器
    public StuNode(int stuNo, String name, String mark) {
        this.stuNo = stuNo;
        this.name = name;
        this.mark = mark;
    }
    //為了顯示方法，我們重新toString
    @Override
    public String toString() {
        return "StuNode [stuNo=" + stuNo + ", name=" + name + ", mark=" + mark + "]";
    }
}

代碼

 輸出：

原來鏈表的情況
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=4, name=小紅, mark=90]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=3, name=小明, mark=70]

 從上面可以看出鏈表存儲是根據先后錄入順序的，那么我們想要根據stuNo存儲呢。

第二種方式在添加學生時，根據學號排序，將學生插入指定位置

實現思路：

需要按照學號的順序添加

1. 首先找到新添加的節點的位置, 是通過輔助變量(指針), 通過遍歷來搞定

2. 新的節點.next = temp.next

3. 將temp.next = 新的節點

示意圖：

實現代碼：

將代碼加入SingleLinkedList中

//第二種方式在添加學生時，根據學號將學生插入到指定位置
    //(如果有這個學號，則添加失敗，並給出提示)
    public void addByOrder(StuNode stuNode) {
        //因為頭節點不能動，因此我們仍然通過一個輔助指針(變量)來幫助找到添加的位置
        //因為單鏈表，因為我們找的temp 是位於 添加位置的前一個節點，否則插入不了
        StuNode temp = head;
        boolean flag = false; // flag標志添加的編號是否存在，默認為false
        while(true) {
            if(temp.next == null) {//說明temp已經在鏈表的最后
                break; //
            }
            if(temp.next.stuNo > stuNode.stuNo) { //位置找到，就在temp的后面插入
                break;
            } else if (temp.next.stuNo == stuNode.stuNo) {//說明希望添加的stuNode的學號已然存在

                flag = true; //說明學號存在
                break;
            }
            temp = temp.next; //后移，遍歷當前鏈表
        }
        //判斷flag 的值
        if(flag) { //不能添加，說明學號存在
            System.out.printf("准備插入的學生 %d 已經存在了, 不能加入\n", stuNode.stuNo);
        } else {
            //插入到鏈表中, temp的后面
            stuNode.next = temp.next;
            temp.next = stuNode;
        }
    }

public static void main(String[] args) {
        //進行測試
        //先創建節點
        StuNode hero1 = new StuNode(1, "張三", "85");
        StuNode hero2 = new StuNode(2, "李四", "87");
        StuNode hero3 = new StuNode(3, "小明", "70");
        StuNode hero4 = new StuNode(4, "小紅", "90");

        //創建要給鏈表
        SingleLinkedList singleLinkedList = new SingleLinkedList();


        //加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        // 測試一下單鏈表的反轉功能
        System.out.println("原來鏈表的情況");
        singleLinkedList.list();
    }

原來鏈表的情況
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=4, name=小紅, mark=90]

 鏈表修改：

實現思路：

1.修改節點的信息, 根據stuNo來修改，即stuNo不能改

2.將修改的值替換

實現代碼:

//修改節點的信息, 根據stuNo來修改，即stuNo不能改.
    //說明
    //1. 根據 newStuNode 的 stuNo 來修改即可
    public void update(StuNode newStuNode) {
        //判斷是否空
        if(head.next == null) {
            System.out.println("鏈表為空~");
            return;
        }
        //找到需要修改的節點, 根據stuNo
        //定義一個輔助變量
        StuNode temp = head.next;
        boolean flag = false; //表示是否找到該節點
        while(true) {
            if (temp == null) {
                break; //已經遍歷完鏈表
            }
            if(temp.stuNo == newStuNode.stuNo) {
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根據flag 判斷是否找到要修改的節點
        if(flag) {
            temp.name = newStuNode.name;
            temp.mark = newStuNode.mark;
        } else { //沒有找到
            System.out.printf("沒有找到 學號 %d 的節點，不能修改\n", newStuNode.stuNo);
        }
    }

public static void main(String[] args) {
        //進行測試
        //先創建節點
        StuNode hero1 = new StuNode(1, "張三", "85");
        StuNode hero2 = new StuNode(2, "李四", "87");
        StuNode hero3 = new StuNode(3, "小明", "70");
        StuNode hero4 = new StuNode(4, "小紅", "90");

        //創建要給鏈表
        SingleLinkedList singleLinkedList = new SingleLinkedList();


        //加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        // 測試一下單鏈表的反轉功能
        System.out.println("原來鏈表的情況");
        singleLinkedList.list();

        StuNode newStu = new StuNode(3,"王五","99");
        singleLinkedList.update(newStu);

        System.out.println("修改之后的鏈表");
        singleLinkedList.list();

    }

原來鏈表的情況
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=4, name=小紅, mark=90]
修改之后的鏈表
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=3, name=王五, mark=99]
StuNode [stuNo=4, name=小紅, mark=90]

鏈表刪除：

實現思路：

1. 我們先找到 需要刪除的這個節點的前一個節點 temp

2. temp.next = temp.next.next(待刪除節點的上一個節點next直接指向待刪除節點的下一個節點)

3. 被刪除的節點，將不會有其它引用指向，會被垃圾回收機制回收

示意圖:

實現代碼：

//刪除節點
    //思路
    //1. head 不能動，因此我們需要一個temp輔助節點找到待刪除節點的前一個節點
    //2. 說明我們在比較時，是temp.next.stuNo 和  需要刪除的節點的stuNo比較
    public void del(int stuNo){
        StuNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next==null){
                break;
            }
            if(temp.next.stuNo==stuNo){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            temp.next=temp.next.next;
        }else {
            System.out.printf("要刪除的 %d 學號節點不存在",stuNo);
        }

    }

public static void main(String[] args) {
        //進行測試
        //先創建節點
        StuNode hero1 = new StuNode(1, "張三", "85");
        StuNode hero2 = new StuNode(2, "李四", "87");
        StuNode hero3 = new StuNode(3, "小明", "70");
        StuNode hero4 = new StuNode(4, "小紅", "90");

        //創建要給鏈表
        SingleLinkedList singleLinkedList = new SingleLinkedList();


        //加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        // 測試一下單鏈表的反轉功能
        System.out.println("原來鏈表的情況");
        singleLinkedList.list();

        singleLinkedList.del(2);
        System.out.println("刪除之后的鏈表");
        singleLinkedList.list();

    }

原來鏈表的情況
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=4, name=小紅, mark=90]
刪除之后的鏈表
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=4, name=小紅, mark=90]

下面我們看幾道關於單鏈表的面試題。

1.求單鏈表中有效節點的個數

2.查找單鏈表中的倒數第k個結點 【新浪面試題】

3.單鏈表的反轉【騰訊面試題，有點難度】

4.從尾到頭打印單鏈表 【百度，要求方式1：反向遍歷 。 方式2：Stack棧】

第一題思路，只要遍歷該鏈表就可得出有效節點的個數

實現代碼：

//方法：獲取到單鏈表的節點的個數(如果是帶頭結點的鏈表，需求不統計頭節點)
    /**
     *
     * @param head 鏈表的頭節點
     * @return 返回的就是有效節點的個數
     */
    public static int getLength(StuNode head) {
        if(head.next == null) { //空鏈表
            return 0;
        }
        int length = 0;
        //定義一個輔助的變量, 這里我們沒有統計頭節點
        StuNode cur = head.next;
        while(cur != null) {
            length++;
            cur = cur.next; //遍歷
        }
        return length;
    }

public static void main(String[] args) {
        //進行測試
        //先創建節點
        StuNode hero1 = new StuNode(1, "張三", "85");
        StuNode hero2 = new StuNode(2, "李四", "87");
        StuNode hero3 = new StuNode(3, "小明", "70");
        StuNode hero4 = new StuNode(4, "小紅", "90");

        //創建要給鏈表
        SingleLinkedList singleLinkedList = new SingleLinkedList();


        //加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        // 測試一下單鏈表的反轉功能
        System.out.println("原來鏈表的情況");
        singleLinkedList.list();

        singleLinkedList.del(2);
        System.out.println("刪除之后的鏈表");
        singleLinkedList.list();

        System.out.println("有效節點個數="+getLength(singleLinkedList.getHead()));


    }

原來鏈表的情況
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=4, name=小紅, mark=90]
刪除之后的鏈表
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=4, name=小紅, mark=90]
有效節點個數=3

第二題思路，先遍歷出鏈表有效節點數size，在第size-k個就是倒數k個節點

實現代碼：

//查找單鏈表中的倒數第k個結點 【新浪面試題】
    //思路
    //1. 編寫一個方法，接收head節點，同時接收一個index 
    //2. index 表示是倒數第index個節點
    //3. 先把鏈表從頭到尾遍歷，得到鏈表的總的長度 getLength
    //4. 得到size 后，我們從鏈表的第一個開始遍歷 (size-index)個，就可以得到
    //5. 如果找到了，則返回該節點，否則返回nulll
    public static StuNode findLastIndexNode(StuNode head, int index) {
        //判斷如果鏈表為空，返回null
        if(head.next == null) {
            return null;//沒有找到
        }
        //第一個遍歷得到鏈表的長度(節點個數)
        int size = getLength(head);
        //第二次遍歷  size-index 位置，就是我們倒數的第K個節點
        //先做一個index的校驗
        if(index <=0 || index > size) {
            return null;
        }
        //定義給輔助變量， for 循環定位到倒數的index
        StuNode cur = head.next; //3 // 3 - 1 = 2
        for(int i =0; i< size - index; i++) {
            cur = cur.next;
        }
        return cur;
    }

public static void main(String[] args) {
        //進行測試
        //先創建節點
        StuNode hero1 = new StuNode(1, "張三", "85");
        StuNode hero2 = new StuNode(2, "李四", "87");
        StuNode hero3 = new StuNode(3, "小明", "70");
        StuNode hero4 = new StuNode(4, "小紅", "90");

        //創建要給鏈表
        SingleLinkedList singleLinkedList = new SingleLinkedList();


        //加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        // 測試一下單鏈表的反轉功能
        System.out.println("原來鏈表的情況");
        singleLinkedList.list();

        singleLinkedList.del(2);
        System.out.println("刪除之后的鏈表");
        singleLinkedList.list();
        System.out.println("有效節點個數="+getLength(singleLinkedList.getHead()));
        StuNode stuNode = findLastIndexNode(singleLinkedList.getHead(),2);
        System.out.println("倒數第二個節點數是"+stuNode);
    }

原來鏈表的情況
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=4, name=小紅, mark=90]
刪除之后的鏈表
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=4, name=小紅, mark=90]
有效節點個數=3
倒數第二個節點數是StuNode [stuNo=3, name=小明, mark=70]

第三題思路

1. 先定義一個節點 reverseHead = new StuNode();

2. 從頭到尾遍歷原來的鏈表，每遍歷一個節點，就將其取出，並放在新的鏈表reverseHead 的最前端.

3. 原來的鏈表的head.next = reverseHead.next

實現代碼：

//將單鏈表反轉
    public static void reversetList(StuNode head) {
        //如果當前鏈表為空，或者只有一個節點，無需反轉，直接返回
        if(head.next == null || head.next.next == null) {
            return ;
        }

        //定義一個輔助的指針(變量)，幫助我們遍歷原來的鏈表
        StuNode cur = head.next;
        StuNode next = null;// 指向當前節點[cur]的下一個節點
        StuNode reverseHead = new StuNode(0, "", "");
        //遍歷原來的鏈表，每遍歷一個節點，就將其取出，並放在新的鏈表reverseHead 的最前端
        //動腦筋
        while(cur != null) {
            next = cur.next;//先暫時保存當前節點的下一個節點，因為后面需要使用
            cur.next = reverseHead.next;//將cur的下一個節點指向新的鏈表的最前端
            reverseHead.next = cur; //將cur 連接到新的鏈表上
            cur = next;//讓cur后移
        }
        //將head.next 指向 reverseHead.next , 實現單鏈表的反轉
        head.next = reverseHead.next;
    }

public static void main(String[] args) {
        //進行測試
        //先創建節點
        StuNode hero1 = new StuNode(1, "張三", "85");
        StuNode hero2 = new StuNode(2, "李四", "87");
        StuNode hero3 = new StuNode(3, "小明", "70");
        StuNode hero4 = new StuNode(4, "小紅", "90");

        //創建要給鏈表
        SingleLinkedList singleLinkedList = new SingleLinkedList();


        //加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        // 測試一下單鏈表的反轉功能
        System.out.println("原來鏈表的情況");
        singleLinkedList.list();
        System.out.println("反轉鏈表的情況");
        reversetList(singleLinkedList.getHead());
        singleLinkedList.list();

        /*singleLinkedList.del(2);
        System.out.println("刪除之后的鏈表");
        singleLinkedList.list();
        System.out.println("有效節點個數="+getLength(singleLinkedList.getHead()));
        StuNode stuNode = findLastIndexNode(singleLinkedList.getHead(),2);
        System.out.println("倒數第二個節點數是"+stuNode);*/
    }

原來鏈表的情況
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=4, name=小紅, mark=90]
反轉鏈表的情況
StuNode [stuNo=4, name=小紅, mark=90]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=1, name=張三, mark=85]

第四題思路

1. 上面的題的要求就是逆序打印單鏈表.

2. 方式1： 先將單鏈表進行反轉操作，然后再遍歷即可，這樣的做的問題是會破壞原來的單鏈表的結構，不建議

3. 方式2：可以利用棧這個數據結構，將各個節點壓入到棧中，然后利用棧的先進后出的特點，就實現了逆序打印的效果.

實現代碼：

//方式2：
    //可以利用棧這個數據結構，將各個節點壓入到棧中，然后利用棧的先進后出的特點，就實現了逆序打印的效果
    public static void reversePrint(StuNode head) {
        if(head.next == null) {
            return;//空鏈表，不能打印
        }
        //創建要給一個棧，將各個節點壓入棧
        Stack<StuNode> stack = new Stack<StuNode>();
        StuNode cur = head.next;
        //將鏈表的所有節點壓入棧
        while(cur != null) {
            stack.push(cur);
            cur = cur.next; //cur后移，這樣就可以壓入下一個節點
        }
        //將棧中的節點進行打印,pop 出棧
        while (stack.size() > 0) {
            System.out.println(stack.pop()); //stack的特點是先進后出
        }
    }

public static void main(String[] args) {
        //進行測試
        //先創建節點
        StuNode hero1 = new StuNode(1, "張三", "85");
        StuNode hero2 = new StuNode(2, "李四", "87");
        StuNode hero3 = new StuNode(3, "小明", "70");
        StuNode hero4 = new StuNode(4, "小紅", "90");

        //創建要給鏈表
        SingleLinkedList singleLinkedList = new SingleLinkedList();


        //加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        // 測試一下單鏈表的反轉功能
        System.out.println("原來鏈表的情況");
        singleLinkedList.list();
        System.out.println("逆序打印單鏈表");
        reversePrint(singleLinkedList.getHead());

        /*singleLinkedList.del(2);
        System.out.println("刪除之后的鏈表");
        singleLinkedList.list();
        System.out.println("有效節點個數="+getLength(singleLinkedList.getHead()));
        StuNode stuNode = findLastIndexNode(singleLinkedList.getHead(),2);
        System.out.println("倒數第二個節點數是"+stuNode);*/
    }

原來鏈表的情況
StuNode [stuNo=1, name=張三, mark=85]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=4, name=小紅, mark=90]
逆序打印單鏈表
StuNode [stuNo=4, name=小紅, mark=90]
StuNode [stuNo=3, name=小明, mark=70]
StuNode [stuNo=2, name=李四, mark=87]
StuNode [stuNo=1, name=張三, mark=85]