資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

天然呆dull 發表於 2021-08-27
演算法 資料結構

連結串列是有序的列表,但是在記憶體中儲存圖下圖所示

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

  1. 連結串列是以 節點 的方式來儲存,是 鏈式儲存
  2. 每個節點包含 data 域next 域,指向下一個節點
  3. 連結串列的各個節點 不一定是連續儲存,如上圖所示
  4. 連結串列還分:帶頭節點、不帶頭節點,根據實際需求來確定

上面進行了一個簡單的介紹,下面分幾部分來講解:

單連結串列

單連結串列(帶頭節點)邏輯結構 示意圖如下,當下一個節點為 的時候,該連結串列就結束了

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

注意:是邏輯結構,前面說過,在記憶體中節點不是一個接一個的。

單連結串列的應用例項

考慮這樣一個場景:使用帶 head 頭單向連結串列 實現水滸英雄排行榜管理

  1. 完成對英雄人物的 增刪改查 操作

  2. 第一種方法:在新增英雄時,直接新增到連結串列的尾部

  3. 第二種方法:在新增英雄時,根據排名將英雄插入到指定位置

    如果有這個排名,則新增失敗,並給出提示

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

如上圖所示,新增流程。我們建立 HeroNode 節點,他的定義如下

class HeroNode {
  int no;//排名
  String name;
  String nickName;//暱稱
  HeroNode next;//指向下一個節點
}

next 指向下一個節點,為空則代表該連結串列結束。其他的欄位則是上面所說的資料了。

單連結串列-無排序實現

/**
 * 單向連結串列測試
 */
public class SingleLinkedListDemo {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及時雨");
        HeroNode hero2 = new HeroNode(2, "盧俊義", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吳用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林沖", "豹子頭");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);

        singleLinkedList.list();
    }
}

/**
 * 單向連結串列
 */
class SingleLinkedList {
    // 頭節點,不儲存任何資料,只是用來作為一個起始點
    private HeroNode head = new HeroNode(0, "", "");

    /**
     * 新增節點
     *
     *    思路 不考慮編號順序時:
     *      1. 找到當前連結串列的最後節點
     *      2. 將最後整個節點的 next 指向新的節點
     * 
     *
     * @param node
     */
    public void add(HeroNode node) {
        // 要遍歷到 next 為 null 的時候,才能進行新增
        HeroNode temp = head;
        while (true) {
            // 找到連結串列的最後,就退出迴圈
            if (temp.next == null) {
                break;
            }
            //如果沒有找到最後, 將將temp後移
            temp = temp.next;
        }
        //當退出while迴圈時,temp就指向了連結串列的最後
		//將最後這個節點的next 指向 新的節點
        temp.next = node;
    }

    /**
     * 列印連結串列中的資料
     */
    public void list() {
        //判斷連結串列是否為空
        if (head.next == null) {
            System.out.println("連結串列為空");
            return;
        }
        //因為頭節點,不能動,因此我們需要一個輔助變數來遍歷
        HeroNode temp = head.next;
        while (true) {
            // 如果是連結串列的最後
            if (temp == null) {
                break;
            }
            //列印資訊
            System.out.println(temp);
            //指標後移,一定要記得
            temp = temp.next;
        }
    }
}

/**
 * 連結串列中的一個節點:英雄節點
 */
class HeroNode {
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;

    public HeroNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    /**
     * 為了顯示方便,重寫
     *
     * @return
     */
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

測試輸出

HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}

可以看到,已經實現了,如果將 no=4 提前加入

SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(hero1);
singleLinkedList.add(hero4);  // 提升到這裡加入
singleLinkedList.add(hero2);
singleLinkedList.add(hero3);
    

測試資料如下

HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}

編號就是無序的了。下面來實現有序的

單連結串列-有序實現(從小到大)

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

新增思路如下:

  1. 首先 找到 新新增節點的位置(新節點遍歷比較排名,來查詢要插入的位置),通過輔助變數 temp,然後迴圈遍歷查詢

  2. 如果有這個排名,則新增失敗,並給出提示,沒有則進行下面的步驟

  3. 新的節點node.next = temp.next

  4. temp.next = 新的節點node.next

    :temp輔助節點為要插入點的前一個節點。

簡單一點就是:通過排序規則(當前是從小到大)遍歷找到要插入的位置,然後改變 next 的指向。

程式碼實現,在原有的程式碼基礎上新增了一個新增方法,如下

    /**
     * 
     * 新增節點,考慮排序
     *思路:
     *  1. 先找到該節點要新增的位置
     *  2. 通過輔助變數temp改變前一個節點和新節點的 next 指向
     *
     *
     * @param node
     */
    public void addByOrder(HeroNode node) {
        // 由於 head 變數不能動,動了就無法從頭遍歷了,使用輔助變數來完成我們的新增
        //因為單連結串列,因為我們找的temp 是位於 新增位置的前一個節點,否則插入不了
        HeroNode temp = head;
        boolean exist = false;  // 新增的節點是否已經在連結串列中存在,預設為false
        while (true) {
            if (temp.next == null) {
                // 如果是連結串列尾,則跳出迴圈
                break;
            }
            // 如果當前節點的 next 編號,大於目標節點(要插入的節點)編號,則找到
            // 應該將目標節點新增到  temp 與 next 之間
            if (temp.next.no > node.no) {
                break;
            }
            // 如果他們相等,則表示連結串列中已經存在目標節點了
            if (temp.next.no == node.no) {
                exist = true;//新增的節點已經在連結串列中存在
                break;
            }
            // 沒找到,則後移 temp ,繼續尋找
            temp = temp.next;
        }

        if (exist) {
            System.out.printf("準備插入的英雄編號 %d 已經存在,不能加入 \n", node.no);
            return;
        }
        // 把節點插入到 temp 和 temp.next 之間
        // temp  ->  node  -> temp.next
        node.next = temp.next;
        temp.next = node;
    }
    

測試用例如下

    /**
     * 考慮順序的新增
     */
    public static void test2() {
        HeroNode hero1 = new HeroNode(1, "宋江", "及時雨");
        HeroNode hero2 = new HeroNode(2, "盧俊義", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吳用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林沖", "豹子頭");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);  // 新增順序提前
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        singleLinkedList.list();
    }

輸出資訊

HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}

如果重複新增的話,會輸出如下類似的資訊

準備插入的英雄編號 4 已經存在,不能加入 

單連結串列的修改

在原來的程式碼基礎上新增 update 方法

    /**
     *修改節點的資訊, 根據no編號來修改,即no編號不能改.
	 *說明
	 *1. 根據 newNode 的 no 來修改即可
     *
     * @param newNode
     */
    public void update(HeroNode newNode) {
        if (head.next == null) {
            System.out.println("連結串列為空");
            return;
        }
        //找到需要修改的節點, 根據no編號
		//定義一個輔助變數
        HeroNode temp = head.next;
        boolean exist = false;  // 是否找到要修改的節點
        while (true) {
            // 如果是連結串列尾部
            if (temp == null) {
                break;
            }
            // 如果已找到
            if (temp.no == newNode.no) {
                exist = true;
                break;
            }
            temp = temp.next;
        }
        // 如果已找到,則修改資訊
        if (exist) {
            temp.name = newNode.name;
            temp.nickName = newNode.nickName;
        } else {//沒有找到
            System.out.printf("未找到編號為 %d 的英雄", newNode.no);
        }
    }
    

測試用例

singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero3);

// 測試修改
System.out.println("修改前");
singleLinkedList.list();
HeroNode hero4New = new HeroNode(4, "林沖-修改測試", "豹子頭-修改測試");
singleLinkedList.update(hero4New);

System.out.println("修改後");
singleLinkedList.list();

測試輸出

修改前
HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}
修改後
HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}
HeroNode{no=4, name='林沖-修改測試', nickName='豹子頭-修改測試'}

單連結串列的刪除

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

如上圖所示,思路如下:

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

    為什麼要找到前一個?因為是單向連結串列,找目標節點就無法完成刪除了。

  2. temp.next = temp.next.next

  3. 被刪除的節點,如果沒有其他的引用的話,會被垃圾回收機制回收

    /**
     * 
     *   按編號刪除節點
     *   1. 找到要刪除的前一個節點
     *   2. 然後將這個前一個節點的 next 指向變更到要刪除節點的 next 節點
     * 
     *
     * @param no
     */
    public void delete(int no) {
        if (head.next == null) {
            System.out.println("連結串列為空");
            return;
        }
        HeroNode temp = head;
        boolean exist = false;  // 是否找到要刪除的節點
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no) {
                exist = true;
                break;
            }
            temp = temp.next;
        }
        if (!exist) {
            System.out.printf("未找到匹配的編號 %d \n", no);
            return;
        }
        // 刪除操作
        temp.next = temp.next.next;
    }

測試程式碼

System.out.println("刪除前");
singleLinkedList.list();
singleLinkedList.delete(1);
singleLinkedList.delete(4);
System.out.println("刪除後");
singleLinkedList.list();
    

輸出資訊

刪除前
HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}
刪除後
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}

tip:學會思想,將其靈活運用到所需專案中。

單連結串列面試題

為了加深理解,來看幾個面試題

求單連結串列中有效節點的個數

思路:直接迴圈統計就行

    /**
     * 獲取連結串列長度
     * @return
     */
    public int length() {
        if (head.next == null) {
            return 0;
        }
        HeroNode temp = head.next;
        int num = 0;
        while (temp != null) {
            num++;
            temp = temp.next;
        }
        return num;
    }

測試用例

@Test
public void lengthTest() {
  System.out.println(singleLinkedList.length());
  singleLinkedList.delete(1);
  System.out.println(singleLinkedList.length());
}

輸出

4
3

查詢單連結串列中的倒數第 k 個結點

新浪面試題

    /**
     *
     * 查詢單連結串列中的倒數第k個結點 【新浪面試題】
     *  思路
     *  1. 編寫一個方法,接收head節點,同時接收一個index 
     *  2. index 表示是倒數第index個節點
     *  3. 先把連結串列從頭到尾遍歷,得到連結串列的總的長度 getLength
     *  4. 得到size 後,我們從連結串列的第一個開始遍歷 (size-index)個,就可以得到
     *  5. 如果找到了,則返回該節點,否則返回nulll
     *
     * @param index 倒數第幾個節點
     * @return
     */
	public static HeroNode findLastIndexNode(HeroNode 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
		HeroNode cur = head.next; //3 // 3 - 1 = 2
		for(int i =0; i< size - index; i++) {
			cur = cur.next;
		}
		return cur;
		
	}

測試用例

@Test
public void findLastIndexNodeTest() {
    //進行測試
		//先建立節點
		HeroNode hero1 = new HeroNode(1, "宋江", "及時雨");
		HeroNode hero2 = new HeroNode(2, "盧俊義", "玉麒麟");
		HeroNode hero3 = new HeroNode(3, "吳用", "智多星");
		HeroNode hero4 = new HeroNode(4, "林沖", "豹子頭");
		
		//建立要給連結串列
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		
		
		//加入
		singleLinkedList.add(hero1);
		singleLinkedList.add(hero4);
		singleLinkedList.add(hero2);
		singleLinkedList.add(hero3);
    
      System.out.println("查詢測試");
      HeroNode lastIndexNode = singleLinkedList.findLastIndexNode(singleLinkedList.getHead(),1);
      System.out.println("查詢倒數第 1 個 " + lastIndexNode);
      lastIndexNode = singleLinkedList.findLastIndexNode(singleLinkedList.getHead(),4);
      System.out.println("查詢倒數第 4 個 " + lastIndexNode);
      lastIndexNode = singleLinkedList.findLastIndexNode(singleLinkedList.getHead(),2);
      System.out.println("查詢倒數第 2 個 " + lastIndexNode);
      lastIndexNode = singleLinkedList.findLastIndexNode(singleLinkedList.getHead(),5);
      System.out.println("查詢倒數第 5 個 " + lastIndexNode);
}

輸出資訊

查詢測試
查詢倒數第 1 個 HeroNode{no=3, name='吳用', nickName='智多星'}
查詢倒數第 4 個 HeroNode{no=1, name='宋江', nickName='及時雨'}
查詢倒數第 2 個 HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
查詢倒數第 5 個 null

單連結串列的反轉

騰訊面試題,這個有點難度。

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

思路:

  1. 定義一個新的 reverseHead 節點
  2. 從原連結串列中依次取出節點,並 始終新增到 reverseHead 的第一個節點
  3. 將原 head 節點的 next 指向 reverseHead.next

頭插法

如下圖所示:

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

//將單連結串列反轉
	public static void reversetList(HeroNode head) {
		//如果當前連結串列為空,或者只有一個節點,無需反轉,直接返回
		if(head.next == null || head.next.next == null) {
			return ;
		}
		
		//定義一個輔助的指標(變數),幫助我們遍歷原來的連結串列
		HeroNode cur = head.next;
		HeroNode next = null;// 指向當前節點[cur]的下一個節點
		HeroNode reverseHead = new HeroNode(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;
	}

測試用例

@Test
public void reverseTest() {
  System.out.println("翻轉前");
  singleLinkedList.list();

  singleLinkedList.reversetList(singleLinkedList.getHead());

  System.out.println("翻轉後");
  singleLinkedList.list();
}

輸出資訊

翻轉前
HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}
翻轉後
HeroNode{no=3, name='吳用', nickName='智多星'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}
HeroNode{no=1, name='宋江', nickName='及時雨'}

從尾到頭列印單連結串列

百度面試題,要求方式:

  1. 反向遍歷

思路:

  1. 反向遍歷 :使用前面翻轉操作後,再列印

    有一個問題:會破壞原連結串列的結構

  2. Stack 棧:利用棧先進後出的特點

    該資料結構看後面的部落格講解,這裡做個簡單的介紹

    資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

    如上圖所示:

    1. 入棧操作:資料 棧底 壓入
    2. 出棧操作:資料 棧頂 彈出

    將原連結串列遍歷,以此將每個節點壓入棧中,然後遍歷棧列印即可

/**
* 
* 逆序列印連結串列:使用棧先進後出的特點達到要求
* 
*/
public static void reversePrint(HeroNode head) {
		if(head.next == null) {
			return;//空連結串列,不能列印
		}
		//建立要給一個棧,將各個節點壓入棧
		Stack<HeroNode> stack = new Stack<HeroNode>();
		HeroNode cur = head.next;
		//將連結串列的所有節點壓入棧
		while(cur != null) {
			stack.push(cur);//壓棧
			cur = cur.next; //cur後移,這樣就可以壓入下一個節點
		}
		//將棧中的節點進行列印,pop 出棧
		while (stack.size() > 0) {
			System.out.println(stack.pop()); // 出棧,stack的特點是先進後出
		}
	}

測試用例

@Test
public void reversePrintTest(){
  System.out.println("連結串列資料");
  singleLinkedList.list();
  System.out.println("逆序列印");
  singleLinkedList.reversePrint();
} 

輸出資訊

連結串列資料
HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}
逆序列印
HeroNode{no=3, name='吳用', nickName='智多星'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}
HeroNode{no=1, name='宋江', nickName='及時雨'}

雙向連結串列

單向連結串列的缺點

從前面的練習題,包括實現單向連結串列中會發現 單向連結串列 的以下問題:

  • 查詢方向 只能是單向

  • 不能自我刪除

    需要靠輔助節點,要找到刪除節點的上一個節點和刪除節點,才能完成刪除

而以上問題,雙向連結串列:

  • 可以雙向查詢
  • 可以自我刪除

雙向連結串列分析

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

雙向連結串列的結構如上圖所示,每個節點都有 prenext 變數,所以它可以往前查詢或則往後查詢。

那麼下面先分析下雙向連結串列的:遍歷、新增、刪除 操作思路,之後再去實現:

  • 遍歷:和單向連結串列類似,只是可以雙向遍歷了

  • 修改:和單向連結串列一樣的方式

  • 新增:預設新增到雙向連結串列的最後一個節點

    1. temp.next = newNode
    2. newNode.pre = temp
  • 刪除

    資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

    如上圖所示,雙向連結串列可以自我刪除:

    1. 遍歷找到要刪除的那個節點 temp
    2. temp.next.pre = temp.pre
    3. temp.pre.next = temp.next

程式碼實現

可以基於單向連結串列上的部分程式碼進行修改。

/**
 * 連結串列中的一個節點:英雄節點
 */
class HeroNode {
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;// 指向下一個節點, 預設為null
    public HeroNode pre;// 指向前一個節點, 預設為null

    public HeroNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    /**
     * 為了顯示方便,重寫
     *
     * @return
     */
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}
/**
 * 雙向連結串列的操作實現
 */
// 建立一個雙向連結串列的類
class DoubleLinkedList {

	// 先初始化一個頭節點, 頭節點不要動, 不存放具體的資料
	private HeroNode head = new HeroNode(0, "", "");

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

	// 遍歷雙向連結串列的方法
	// 顯示連結串列[遍歷]
	public void list() {
		// 判斷連結串列是否為空
		if (head.next == null) {
			System.out.println("連結串列為空");
			return;
		}
		// 因為頭節點,不能動,因此我們需要一個輔助變數來遍歷
		HeroNode temp = head.next;
		while (true) {
			// 判斷是否到連結串列最後
			if (temp == null) {
				break;
			}
			// 輸出節點的資訊
			System.out.println(temp);
			// 將temp後移
			temp = temp.next;
		}
	}

	// 新增一個節點到雙向連結串列的最後.
	public void add(HeroNode heroNode) {

		// 因為head節點不能動,因此我們需要一個輔助遍歷 temp
		HeroNode2 temp = head;
		// 遍歷連結串列,找到最後
		while (true) {
			// 找到連結串列的最後
			if (temp.next == null) {
				break;
			}
			// 如果沒有找到最後, 將將temp後移
			temp = temp.next;
		}
		// 當退出while迴圈時,temp就指向了連結串列的最後
		// 形成一個雙向連結串列
		temp.next = heroNode;
		heroNode.pre = temp;
	}

	// 修改一個節點的內容, 可以看到雙向連結串列的節點內容修改和單向連結串列一樣
	public void update(HeroNode newHeroNode) {
		// 判斷是否空
		if (head.next == null) {
			System.out.println("連結串列為空~");
			return;
		}
		// 找到需要修改的節點, 根據no編號
		// 定義一個輔助變數
		HeroNode temp = head.next;
		boolean flag = false; // 表示是否找到該節點
		while (true) {
			if (temp == null) {
				break; // 已經遍歷完連結串列
			}
			if (temp.no == newHeroNode.no) {
				// 找到
				flag = true;
				break;
			}
			temp = temp.next;
		}
		// 根據flag 判斷是否找到要修改的節點
		if (flag) {
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;
		} else { // 沒有找到
			System.out.printf("沒有找到 編號 %d 的節點,不能修改\n", newHeroNode.no);
		}
	}

	// 從雙向連結串列中刪除一個節點,
	// 說明
	// 1 對於雙向連結串列,我們可以直接找到要刪除的這個節點
	// 2 找到後,自我刪除即可
	public void del(int no) {

		// 判斷當前連結串列是否為空
		if (head.next == null) {// 空連結串列
			System.out.println("連結串列為空,無法刪除");
			return;
		}

		HeroNode temp = head.next; // 輔助變數(指標)
		boolean flag = false; // 標誌是否找到待刪除節點的
		while (true) {
			if (temp == null) { // 已經到連結串列的最後
				break;
			}
			if (temp.no == no) {
				// 找到的待刪除節點的前一個節點temp
				flag = true;
				break;
			}
			temp = temp.next; // temp後移,遍歷
		}
		// 判斷flag
		if (flag) { // 找到
			// 可以刪除
			// temp.next = temp.next.next;[單向連結串列]
			temp.pre.next = temp.next;
			// 這裡我們的程式碼有問題?
			// 如果是最後一個節點,就不需要執行下面這句話,否則出現空指標
			if (temp.next != null) {
				temp.next.pre = temp.pre;
			}
		} else {
			System.out.printf("要刪除的 %d 節點不存在\n", no);
		}
	}

}

測試用例:

/**
 * 雙向連結串列測試
 */
public class DoubleLinkedListTest {
    DoubleLinkedList doubleLinkedList;

    @Before
    public void before() {
        HeroNode hero1 = new HeroNode(1, "宋江", "及時雨");
        HeroNode hero2 = new HeroNode(2, "盧俊義", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吳用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林沖", "豹子頭");

        // 測試新增
        doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero4);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
    }

    @Test
    public void addTest() {
        // before 中已測試
    }

    /**
     * 更新測試
     */
    @Test
    public void updateTest() {
        System.out.println("更新前");
        doubleLinkedList.print();
        HeroNode hero4New = new HeroNode(4, "林沖-修改測試", "豹子頭-修改測試");
        doubleLinkedList.update(hero4New);
        System.out.println("更新後");
        doubleLinkedList.print();
    }

    /**
     * 刪除測試
     */
    @Test
    public void deleteTest() {
        System.out.println("刪除前");
        doubleLinkedList.print();
        doubleLinkedList.del(1);
        doubleLinkedList.del(4);
        doubleLinkedList.del(3);
        System.out.println("刪除後");
        doubleLinkedList.print();
    }
}

測試輸出

更新前
HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}
更新後
HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=4, name='林沖-修改測試', nickName='豹子頭-修改測試'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}


刪除前
HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}
刪除後
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}

課程作業

實現:雙向連結串列的第二種新增方式,按照編號順序新增

實現和單向新增是一樣的

/**
* 
*  按編號順序新增
*  思路:
*     1. 從頭遍歷節點,
*     2. 找到比目標大的節點:插入到該節點之前(升序)
*     2. 如果已經存在相同編號的節點,則提示不允許新增
*
* 
*
* @param node
*/
public void addByOrder(HeroNode node) {
  HeroNode temp = head;
  boolean exist = false;  // 新增的節點是否已經在連結串列中存在,預設false

  while (true) {
    // 已到列表尾部
    if (temp.next == null) {
      break;
    }
    // 已找到
    if (temp.next.no > node.no) {
      break;
    }

    // 已存在該編號
    if (temp.next.no == node.no) {
      exist = true;
      break;
    }
    temp = temp.next;
  }
  if (exist) {
    System.out.printf("準備插入的英雄編號 %d 已經存在,不能加入 \n", node.no);
    return;
  }

  // 把節點插入到 temp 和 temp.next 之間
  // temp  <->  node  <-> temp.next
  node.next = temp.next;//插入的節點的next指向後一個節點
  node.pre = temp;//插入的節點的pre指向前一個節點
  temp.next.pre = node;//插入位置後一個節點的pre指向插入的節點
  temp.next = node;//將插入位置的前一個節點的next指向插入的節點
}

測試用例

@Test
public void addByOrderTest() {
  HeroNode hero1 = new HeroNode(1, "宋江", "及時雨");
  HeroNode hero2 = new HeroNode(2, "盧俊義", "玉麒麟");
  HeroNode hero3 = new HeroNode(3, "吳用", "智多星");
  HeroNode hero4 = new HeroNode(4, "林沖", "豹子頭");

  // 測試新增
  doubleLinkedList = new DoubleLinkedList();
  doubleLinkedList.addByOrder(hero1);
  doubleLinkedList.addByOrder(hero4);
  doubleLinkedList.addByOrder(hero2);
  doubleLinkedList.addByOrder(hero3);
  doubleLinkedList.addByOrder(hero3);
  doubleLinkedList.print();
}

測試輸出

準備插入的英雄編號 3 已經存在,不能加入 
HeroNode{no=1, name='宋江', nickName='及時雨'}
HeroNode{no=2, name='盧俊義', nickName='玉麒麟'}
HeroNode{no=3, name='吳用', nickName='智多星'}
HeroNode{no=4, name='林沖', nickName='豹子頭'}

單向環形連結串列-Josephu 問題

應用場景-約瑟夫問題

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

約瑟夫(Josephu)問題,也就是丟手帕問題,他的規則如下

  • 有編號為 1 ~ n 的 n 個人圍坐在一起
  • 約定編號為 K( 1 <= k <=n) 的人從 1 開始報數
  • 數到 m 的那個人出列,它的下一位又從 1 開始報數

迴圈以上過程,直到所有人都出列,並列出出列人的編號。

該問題其實可以使用 單迴圈連結串列(單向環形連結串列)來解決,思路如下:

  1. 先構成一個有 n 個節點的單迴圈連結串列
  2. 然後由 k 節點起從 1 開始計數
  3. 計數到 m 時,對應節點從連結串列中刪除,然後從下一個節點又從 1 開始計數

迴圈以上過程,直到最後一個節點從連結串列中刪除,演算法結束

單向環形連結串列介紹

它的邏輯結構就如下圖,形成了一個環狀。

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

約瑟夫問題示意圖

需求如下:

  • n=5:有 5 個人
  • k=1:從第一個人開始數
  • m=2:數兩次

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

沒有動圖,那麼使用下面的描述來講解:

  1. 第一輪:2 出佇列,1.next = 3

    還剩下:1、3、4、5

  2. 第二輪:4 出佇列,3.next = 5;(從 3 開始報數,第 2 個的出佇列,也就是 4)

    還剩下:1、3、5

  3. 第三輪:1 出佇列,5.next = 3

    還剩下:3、5

  4. 第四輪:5 出佇列,3.next = 3

    還剩下:3,自己的 next 就是自己

  5. 第五輪:3 出佇列,佇列中無元素,結束

那麼最終的出佇列順序就是:2、4、1、5、3

約舍夫問題可以使用陣列來解決,這裡使用單向環形連結串列,比較好理解

建立環形連結串列的思路圖解

環形連結串列新增思路

  1. 第 1 個節點被新增進來時

    資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

    使用一個 first 變數來表示這是第一個節點,和帶頭節點的連結串列一樣,first節點(也就是頭節點)不能去改變他,使用 curBody 變數來輔助我們解決新增的過程,並讓 next 指向自己,形成一個環形

  2. 第 2 個節點被新增進來時,boy是新要新增進來的節點

    資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

    將該節點加入到已有的環形變數,並把curBoy指向這個新節點,下面的以此類推

  3. 第 3 個節點被新增進來時

    資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

遍歷環形連結串列

  1. 先讓一個輔助變數 curBoy,指向 first 節點 Boy curBoy = first
  2. 通過一個 while 迴圈遍歷連結串列,當 cur.next = first 時,就遍歷完了

新增和連結串列列印程式碼實現

// 建立一個Boy類,表示一個節點
class Boy {
	private int no;// 編號
	private Boy next; // 指向下一個節點,預設null

	public Boy(int no) {
		this.no = no;
	}

	public int getNo() {
		return no;
	}

	public void setNo(int no) {
		this.no = no;
	}

	public Boy getNext() {
		return next;
	}

	public void setNext(Boy next) {
		this.next = next;
	}

}
/// 建立一個環形的單向連結串列
class CircleSingleLinkedList {
	// 建立一個first節點,當前沒有編號
	private Boy first = null;

	// 新增小孩節點,構建成一個環形的連結串列
	public void addBoy(int nums) {
		// nums 做一個資料校驗
		if (nums < 1) {
			System.out.println("nums的值不正確");
			return;
		}
		Boy curBoy = null; // 輔助指標,幫助構建環形連結串列
		// 使用for來建立我們的環形連結串列
		for (int i = 1; i <= nums; i++) {
			// 根據編號,建立小孩節點
			Boy boy = new Boy(i);
			// 如果是第一個小孩
			if (i == 1) {
				first = boy;
				first.setNext(first); // 構成環
				curBoy = first; // 讓curBoy指向第一個小孩
			} else {
				curBoy.setNext(boy);//
				boy.setNext(first);//
				curBoy = boy;
			}
		}
	}

	// 遍歷當前的環形連結串列
	public void showBoy() {
		// 判斷連結串列是否為空
		if (first == null) {
			System.out.println("沒有任何小孩~~");
			return;
		}
		// 因為first不能動,因此我們仍然使用一個輔助指標完成遍歷
		Boy curBoy = first;
		while (true) {
			System.out.printf("小孩的編號 %d \n", curBoy.getNo());
			if (curBoy.getNext() == first) {// 說明已經遍歷完畢
				break;
			}
			curBoy = curBoy.getNext(); // curBoy後移
		}
	}
}

測試用例:

/**
 * 約瑟夫問題測試
 */
public class JosepfuTest {
    /**
     * 新增測試
     */
    @Test
    public void addTest() {
       // 測試一把看看構建環形連結串列,和遍歷是否ok
		CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
		circleSingleLinkedList.addBoy(5);// 加入5個小孩節點
		circleSingleLinkedList.showBoy();
    }
}

測試輸出:為了驗證前面 5 個小孩的說明是否正確,這裡也新增 5 個小孩

小孩的編號 1 
小孩的編號 2 
小孩的編號 3 
小孩的編號 4 
小孩的編號 5 

出圈思路分析

還是以這個需求來分析:

使用者輸入如下:

  • n=5:有 5 個人
  • k=1:從第一個人開始數
  • m=2:數兩次
  1. 需要一個 輔助節點helper 來幫助出圈,當出圈報數開始時,報數完的時候first所指到的節點出圈,而helper就是來幫助出圈的,如下圖所示

    資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

  2. 將 first 定位到 k , helper緊隨其後 (k 從第幾個小孩開始報數)

    將 first 和 helper 移動 k-1

  3. 小孩報數時:移動 first 到出圈的節點上,hepler 始終在 first 後面

資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

first 和 helper 同時移動 m-1 次,是因為 開始數數的人 也要佔用一個位置(自己本身也要數):比如上圖,從 1 開始,first在編號 2 時,就數了 2 下了,它該出圈

  1. 小孩出圈(下圖是經過報數(2)後的圖,原圖first在 1 的位置)

    資料結構與演算法——連結串列 Linked List(單連結串列、雙向連結串列、單向環形連結串列-Josephu 問題)

    先將 first = first.getNext()(first指向下一個節點),然後將 helper.setNext(first)(將出圈小孩的後面一個小孩的next指向變化後的first),那麼就如上圖所示了,出圈的 first 被孤立出圈了,別人沒有引用它了,就會被垃圾回收機制銷燬了。

注意:只有 小孩報數和出圈是重複 的,其他的只是這個遊戲開始前的一些設定初始化。

出圈程式碼實現

在原來的環形佇列上新增遊戲開始方法(計算出圈順序)

/**
     * 遊戲開始,計算出圈順序
     *
     * @param startNo  從第幾個小孩開始數
     * @param countNum 數幾下
     * @param nums     參與該遊戲的小孩有多少個
     */
    public void countBoy(int startNo, int countNum, int nums) {
        // 進行一個資料校驗
        if (first == null ||  // 環形佇列沒有構建
                countNum < 1 ||  // 每次至少數 1 下
                startNo > nums  // 開始小孩不能大於參與遊戲的人數
        ) {
            System.out.println("引數有誤,請重新輸入");
        }
        // 1. 初始化輔助變數helper到  first 的後面
        //helper用來輔助出圈的
        //先和first指向同一個節點,後通過迴圈遍歷將其指向最後一個節點
        Boy helper = first;
        // 當 helper.next = first 時,就說明已經定位了,helper指向最後小孩節點
        while (helper.next != first) {
            helper = helper.getNext();
        }

        // 2.first 和 helper 同時移動,將first定位在 startNo 位置,helper緊跟其後
        // first 移動到 startNo 位置,同時helper也跟著
        for (int i = 0; i < startNo - 1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }

        // 為了測試方便,這裡新增一個日誌輸出
        System.out.printf("定位到位置: %d \n", startNo);

        // 3. 開始報數 和 出圈
        while (true) {
            // 當佇列中只剩下一個人的時候,跳出迴圈,因為最後一個必然是他自己出佇列
            if (helper == first) {
                break;
            }
            // 報數:移動 m-1 (報數要數自己本身)
            for (int i = 0; i < countNum - 1; i++) {
                // 因為 helper 永遠在 first 後面,只要在 first 移動時,指向 first 原來所在的位置即可
                first = first.getNext();
                helper = helper.getNext();
            }
            // 出圈
            System.out.printf("出圈小孩編號 %d \n", first.no);
            //這時將first指向的小孩節點出圈
            first = first.getNext();//將first指向出圈小孩的前面那個小孩
			helper.setNext(first); //將出圈小孩的後面一個小孩的next指向變化後的first
        }
        System.out.printf("最後剩下小孩編號 %d \n", first.getNo());
    }

測試用例

@Test
public void countBoy() {
  CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
		circleSingleLinkedList.addBoy(5);// 加入5個小孩節點
    	System.out.println("構建環形佇列");
		circleSingleLinkedList.showBoy();

  // 開始玩遊戲
  // 正確的輸出順序為:2、4、1、5、3
  circleSingleLinkedList.countBoy(1, 2, 5);
}

測試輸出

構建環形佇列
小孩編號 1 
小孩編號 2 
小孩編號 3 
小孩編號 4 
小孩編號 5 
定位到位置: 1 
小孩編號 1 
小孩編號 2 
小孩編號 3 
小孩編號 4 
小孩編號 5 
出圈小孩編號 2 
出圈小孩編號 4 
出圈小孩編號 1 
出圈小孩編號 5 
最後剩下小孩編號 3 

可以嘗試修改下從第 3 個小孩開始報數

定位到位置: 3 
小孩編號 3 
小孩編號 4 
小孩編號 5 
小孩編號 1 
小孩編號 2 
出圈小孩編號 4 
出圈小孩編號 1 
出圈小孩編號 3 
出圈小孩編號 2 
最後剩下小孩編號 5 

小結

需要正視的一個點:現在在學習資料結構,比如陣列可以模擬 佇列,陣列可以模擬 環形佇列,佇列也是一個資料結構,主要是思路

相關文章