單鏈表常見的4道筆試題（Java版）

單鏈表中有效節點的個數

思路分析：

如果是帶頭節點的鏈表，不需要統計頭節點。也就是說該鏈表的長度。

1. 判斷該鏈表是否為空，如果為空，則直接返回 0 ；
2. 定一個變量length，用來記錄節點的個數；
3. 不為空，用一個臨時變量指向頭結點的下一個位置，
4. 遍歷該鏈表，只要data不為空，length加一。直到temp的下一位為空為止。
5. 返回該變量

代碼實現：

public static int getLength(HeroNode head){
    if(head.next == null){ //空鏈表
        return 0;
    }
    int length = 0;
    //定義一個輔助變量，直接指向頭節點的下一個節點
    HeroNode cur = head.next;
    while(cur != null){
        length++;
        cur = cur.next;//遍歷
    }
    return length;
}

查找單鏈表中的倒數第k個結點

思路分析：findLastIndexNode（Node node , int index）

1. 先判斷該鏈表是否為空，為空則返回null;
2. 不為空，則先進行遍歷，輸出鏈表的總長度
3. 定以一個臨時變量temp用來進行遍歷操作，temp是從head頭部下一個節點開始的
4. 定義一個size用來存儲鏈表的長度；
5. 只要temp不為空，size就加一，直到遍歷完整個鏈表
6. index的合法性判斷，不能小於等於0或大於鏈表總長度
7. 再for循環到size-index次，將temp指向目標位置；
8. 返回該節點

代碼實現：

public HeroNode findLastIndexNode(Node node，int index) {
    // 判斷鏈表是否為空，
    if (node == null) {
        return null;
    }
    // 不為空，則先進行遍歷，輸出鏈表的總長度
    // 定以一個臨時變量temp用來進行遍歷操作，
    HeroNode temp = head.next;//從鏈表頭部的下一個開始
    // 定義一個size用來存儲鏈表的長度
    int size = 0;
    while (temp != null) {// temp下一個節點還有值
        size++;
        temp = temp.next;//指向下一個節點繼續
    }
    System.out.println(size);
    // 得到鏈表的總長度size后，我們只需遍歷size-index次即可得到第K個元素
    HeroNode cur = head.next;
    // 保證輸入的index是有效的
    if(index <= 0 || index > size){
        return null;
    }
    for(int i = 0; i< size-index;i++){
        cur = cur.next;
    }
    return cur;
}

單鏈表的反轉

思路分析：

1. 先定義一個新的頭節點，reverseHead
2. 從頭到尾去遍歷原來的鏈表，每遍歷一個節點，將其取出，放到reverseHead節點的后面
3. 將原來的頭部.next指向reverseHead.next

代碼實現：

public static void reverseLinkedList(HeroNode node) {
    // 1. 判斷所給的鏈表的長度是0或是1不用反轉
    if(node.next == null || node.next.next == null){
        return;
    }
    //2. 定義一個新的頭節點，reverseHead
    HeroNode reverseHead = new HeroNode(0,"","");
    //3. 從頭到尾去遍歷原來的鏈表，每遍歷一個節點，將其取出，放到reverseHead節點的后面
    HeroNode cur = node.next; // 臨時變量用來進行遍歷操作
    HeroNode next = null; //用來存儲當前節點的下一個節點的位置
    while(cur != null) {
        // 從右往左進行插入，
        next = cur.next; // 
        cur.next = reverseHead.next; // 如果temp此時是節點2，那么reverseHead.next是節點1，我們先讓節點2的下一位指向節點1
        reverseHead.next = cur; //讓新鏈表的頭結點指向取出來的節點。把temp插到reverseHead后面
        cur = next; // 繼續
    }

    //4. 將原來的頭部.next指向reverseHead.next
    node.next = reverseHead.next;
}s

從尾到頭打印單鏈表

方式1：反向遍歷

先反轉再遍歷，會破壞鏈表的結構

方式2：Stack棧

思路分析：

利用棧，將各個節點壓入到棧中，然后利用棧的先進后出的特點，就實現了逆序打印的效果

1. 先判斷所給鏈表是否為空，為空直接返回
2. 不為空，創建一個棧，定義一個臨時變量遍歷鏈表，將節點壓棧
3. 只要棧不為空，就先進后出的彈棧pop()

代碼實現：

public static void reversePrint2(HeroNode node){
    //1.
    if(node.next == null){
        return;
    }
    //2.
    HeroNode cur = node.next;
    Stack<HeroNode> stack = new Stack<HeroNode>();
    while(cur != null){
        stack.push(cur);
        cur = cur.next;
    }
    // 3.
    while(!stack.empty()){ //或者stack.size()>0
        System.out.println(stack.pop());
    }
}