【Algorithm】链表算法中哑结点作用

题目描述

Sort a linked list using insertion sort.

---

一般思路（直接在原链表上进行插排）

很好理解，就是遍历每个结点cur，同时记录其前一个结点pre。

如果碰到某个cur的值小于pre，从头结点开始遍历，直到找到应该插入的位置。

不使用哑结点的问题就是多判断了一个cur要替换头结点，头结点往后移的状况，这时不能用遍历的代码

需要额外写一种情况

                if(head.val > cur.val){
                    cur.next = head;
                    head = cur;
                }

 

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public static ListNode insertionSortList(ListNode head) {
        if(head == null || head.next == null)return head;
        for(ListNode pre = head; pre.next != null; ){
            ListNode cur = pre.next;
            if(cur.val < pre.val){    
                pre.next = cur.next;
                ListNode p = head;
                ListNode c = p.next;
                if(head.val > cur.val){
                    cur.next = head;
                    head = cur;
                }else {
                	//将cur从head遍历到其应该插入的地方（大于前者p小于后者c.next）
                    while(c != cur && c != null){
                        //头结点额外判断

                        if(c.val > cur.val){
                            p.next = cur;
                            cur.next = c;
                            break;
                        }
                        p = c;
                        c = c.next;
                    }
                }
            }else pre = pre.next;
        }
        return head;
    }
}

 

使用哑结点

大致思路其实是一致的，但是他新建了一个哑结点作为“新的链表”（其实就建了一个结点）。

这样就不可能有替换头结点的情况了，因为头结点的值为Integer.MIN_VALUE。

*和哑结点没关系的地方：查找插入位置的时候用的是pre.next，而不是像上面维护两个指针p/h来查找插入位置。

**也就是pre代表了p，pre.next代表了h，verygood。

    public static ListNode insertionSortList(ListNode head) {
       
        //哑结点
        ListNode dummy = new ListNode(Integer.MIN_VALUE);
        ListNode pre = dummy;
        ListNode cur = head;
        while(cur != null){
            ListNode next = cur.next;
            pre = dummy;
            
            while(pre.next != null && pre.next.val < cur.val){
                pre = pre.next;
            }
            cur.next = pre.next;
            pre.next = cur;
            
            cur = next;
            
        }
        return dummy.next;
    }
}