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

時間 2019-12-08

標籤數據結構鏈表 linkedlist 欄目 Java 简体版

原文原文鏈接

鏈表(Linked List)介紹

鏈表是有序的列表，可是它在內存中是存儲以下前端

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

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

3）各個節點不必定連續存儲，如上圖數據結構

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

單鏈表介紹

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

應用實例this

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

1.完成學生成績的增刪改查操做3d

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();
    }

main

原來鏈表的狀況
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();

    }

main

原來鏈表的狀況
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();

    }

main

原來鏈表的狀況
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()));


    }

main

原來鏈表的狀況
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);
    }

main

原來鏈表的狀況
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);*/
    }

main

原來鏈表的狀況
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);*/
    }

main

原來鏈表的狀況
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]

輸出