数据结构-6.链表经典题和双向链表的实现

---

前言

hello，大家好，我是阿旭啊。今天给大家带来数据结构第六篇：链表经典题型和双向链表的实现。希望能给大家一些小帮助~

---

一．链表经典题（附带链接）

1.反转一个链表

首先进行链表判空。

        if (head == null){
            return null;

然后判断是否只有一个节点：

        if (head.next == null){
            return head;
        }

由于head也进行了改变，所以没必要给head找一个替身。我们给head.next找一个替身cur。我们将cur的next设置成head，再将cur设置成head，此时前两个节点已经反转完成。

            cur.next = head;
            head = cur;

但是我们会发现第三个结点以及之后的节点已经找不到了。所以我们还需要给第三个结点找一个替身cur1。当前两个节点反转之后我们将cur1设置成cur，cur1设置成cur.next。此时再次进行上述操作来进行第二个和第三个结点的反转。

            cur.next = head;	
            head = cur;
            cur = cur1;
 			cur1 = cur.next;

然而当我们cur等于null的时候会发现cur1空指针异常。所以我们将cur1 = cur.next;放到循环的第一位。这样最后cur会和cur1相等，避免了空指针异常。
完整代码：

public ListNode reverseList(ListNode head) {
        if (head == null){
            return null;
        }
        if (head.next == null){
            return head;
        }
        ListNode cur = head.next;
        head.next = null;
        while(cur != null){
            ListNode cur1 = cur.next;
            cur.next = head;
            head = cur;
            cur = cur1;
        }
        return head;
    }

2.给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间节点。

使用快慢指针来进行取中间。找head的两个替身分别为fast，slow。当fast不等于空且fast.next不等于空的时候（要注意不能写反，如果写反当fast为空的时候会发生空指针异常），fast走两步，slow走一步。最后返回slow就是中间的节点。

    public ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

3.输入一个链表，输出该链表中倒数第k个结点

依旧使用快慢指针来解题。首先判断k是否是否合法。先让快指针走k步。之后快慢指针一起走，直到快指针为空。此时的慢指针就是倒数第k个节点。

public ListNode FindKthToTail(ListNode head,int k) {
        if (k <= 0){
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        for (int i = 0; i < k; i++){
            if(fast == null){
                return null;
            }
            fast = fast.next;

        }
        while(fast != null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }

4.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

首先设置一个新的头结点newHead。然后将newHead设置成head（此时newHead已经是head的替身）。同时遍历list1和list2，当list1不为空且list2也不为空时进行循环。如果list1.value 此时返回head.next就是合并后的新链表。

    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {

        ListNode newHead = new ListNode(0);
        ListNode head = newHead;
        while(list1 != null && list2 != null){
            if(list1.val < list2.val){
                newHead.next = list1;
                list1 = list1.next;
                newHead = newHead.next;
            }else{
                newHead.next = list2;
                list2 = list2.next;
                newHead = newHead.next;
            }
        }
        if(list1 == null){
                newHead.next = list2;
        }
         if(list2 == null){
                newHead.next = list1;
        }
        return head.next;
    }

5.编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。

思路：建立两个链表，第一个是小于x的节点，第二个是大于或等于x的节点，最后将第二个链表尾插到第一个链表。
实践：先找一个原来头结点的替身cur。然后创建两个头结点head1，head2。然后找这两个头结点的替身cur1，cur2。遍历原来的链表，如果cur.value

 public ListNode partition(ListNode pHead, int x) {
        ListNode cur = pHead;
        ListNode head1 = new ListNode(0);
        ListNode head2 = new ListNode(0);
        ListNode cur1 = head1;
        ListNode cur2 = head2;
        while(cur != null){
            if (cur.val < x){ 
                cur1.next = cur;
                cur1 = cur1.next;
            }else{
                cur2.next = cur;
                cur2 = cur2.next;
            }
            cur = cur.next;
        }
        cur1.next = head2.next;
        cur2.next = null;
        return head1.next;
    }

6.链表的回文结构

思路：先判空。回文结构的链表从中间节点分开后将后半段链表反转。此时两个链表应该是一样的。如果不一样就不回文

public boolean chkPalindrome(ListNode A) {
            if (A == null){
            return false;
        }
        ListNode fast = A;
        ListNode slow = A;
        //找中间位置slow
        while (fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        //开始反转后半链表,翻转完毕后slow为新列表的newHead
        ListNode newHead = slow.next;
        slow.next = null;
        while (newHead != null){
            ListNode cur = newHead.next;
            newHead.next = slow;
            slow = newHead;
            newHead = cur;
        }
        //开始判断是否是回文
        ListNode cur1 = A;
        while(slow != null){
            if (cur1.val != slow .val){
                return false;
            }
            cur1 = cur1.next;
            slow  = slow.next;
        }
        return true;
    }

7.输入两个链表，找出它们的第一个公共结点

思路：两个链表后半段相同，前面相差的步数就是两个链表的长度之差。我们可以让长链表先走相差的步数，然后两个链表一起走，这样当两个节点相等时就是相同部分
实践：先判空。先找出两个头结点的替身curA，curB。求两个链表的长度分别为countA，countB。然后将curA和curB再次改回两个头结点的替身。然后求步数之差ret。如果countA

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null){
            return null;
        }
        int countA = 0;
        int countB = 0;
        ListNode curA = headA;
        ListNode curB = headB;
        //分别求两个链表的长度
        while(curA != null){
            countA++;
            curA = curA.next;
        }
        curA = headA;
        while(curB != null){
            countB++;
            curB = curB.next;
        }
        curB = headB;
        //求差值步数的长度
        int ret = countA - countB;
        if (ret < 0){
            curA = headB;
            curB = headA;
            ret = countB - countA;
        }
        for(int i = 0; i < ret; i++){
            curA = curA.next;
        }
        while (curA != curB){
            curA = curA.next;
            curB = curB.next;
        }
        return curA;
    }

8.给定一个链表，判断链表中是否有环

思路：本题仍然使用快慢指针，快指针走两步，慢指针走一步，当快指针等于慢指针的时候就说明他们链表有环，如果快指针为空或者快指针的后驱为空则链表没有环。

public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null){
            return false;
        } 
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow){
                return true;
            }
        }
        return false;
    }

9.给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 NULL

从head到入口点长X，环长为S，从相遇点到入口为y。相遇点是由快慢指针快走两步，慢走一步找到的。所以他们的路程也是二倍的关系：
当快指针在环里走了c圈：
2 [x + （s - y）] = x + （s - y） + cs
解得：
x = （c - 1）s + y
从中可以看出来如果使用快慢指针一个指针在head开始走，一个从相遇点开始走，当他们相等的时候就是入口点。

public ListNode detectCycle(ListNode head) {
        if (head == null){
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow){
                break;
            }
        }
        if (fast == null || fast.next == null){
            return null;
        }
        fast = head;
        while (fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }

二.双向链表的方法及实现

双向链表中的节点包括：值（value）， 前驱（prve），后驱（next）。

1.双向链表的方法

public class MyLinkedList {
//头插法
public void addFirst(int data){ }
//尾插法
public void addLast(int data){}
//任意位置插入,第一个数据节点为0号下标
public void addIndex(int index,int data){}
//查找是否包含关键字key是否在单链表当中
public boolean contains(int key){}
//删除第一次出现关键字为key的节点
public void remove(int key){}
//删除所有值为key的节点
public void removeAllKey(int key){}
//得到单链表的长度
public int size(){} public void display(){} public void clear(){}
} 

2.双向链表实现

首先，双链表类中包括节点类和所有的方法。和单列表一样，先把双向链表类中的节点类写出来。节点类中包括value，next，prev以及一个构造方法：

public class MyLinkedList {
    static class ListNode {
        public int value;
        public ListNode next;
        public ListNode prev;

        public ListNode(int value) {
            this.value = value;
        }
    }
}

在单链表中，我们有头结点（head），我们设置了一个成员变量为head。在双向链表中，我们可以设置头结点（head）和尾结点（last）：

public ListNode head;
public ListNode last;

我们第一个写的方法是获得链表的长度size方法。顺序遍历一遍链表然后进行count计数。要注意要用cur来替代head：

public int size() {
    ListNode cur = head;
    int count = 0;
    while (cur != null) {
        count++;
        cur = cur.next;
    }
    return count;
}

我们第二个写的方法是打印链表display方法。顺序遍历链表**（只要是遍历链表且不改变链表的时候都需要进行cur替身）**，遍历的时候一个一个打印：

public void display() {
    ListNode cur = head;
    while (cur != null) {
        System.out.print(cur.value + " ");
        cur = cur.next;
    }
    System.out.println();
}

我们第三个写的方法是查找链表中是否含有key值的contains方法。遍历一遍链表，并且每一个进行value值与key值进行对比。若相等就true。不相等就false：

public boolean contains(int key) {
    if (head == null) {
        return false;
    }
    ListNode cur = head;
    while (cur != null) {
        if (cur.value == key) {
            return true;
        }
        cur = cur.next;
    }
    return false;
}

我们发现双向链表的这三个方法与单向链表的这三个方法是一样的。
我们第四个写的方法是头插法addFirst方法。定义一个新的节点。先把新节点与原来的链表联系起来，再去设置头结点。要注意一开始需要判空，当链表为空时，新节点既是头结点也是尾结点：

public void addFirst(int data) {
    ListNode node = new ListNode(data);
    if (head == null) {
        last = node;
        head = node;
        return;
    }
    node.next = head;
    head.prev = node;
    head = node;
}

我们第五个写尾插法addLast方法。双向链表中我们不仅定义了head，还定义了last。我们可以直接使用last来将新节点与原来的链表联系到一起，然后将新节点设置成last：

public void addLast(int data) {
    ListNode node = new ListNode(data);
    if (head == null) {
        last = node;
        head = node;
        return;
    }   
    node.prev = last;
    last.next = node;
    last = node;
}

我们第六个写任意位置插入函数addIndex（第一个节点为0号下标）。涉及到了位置，我们第一步先判断位置是否合法。如果不合法就抛出IndextOusBoundsException异常。当位置判断为0时候，进行头插法，当位置为size（）时候，进行尾插法。在中间插入时候我们需要先找到插入位置的前一个位置（使用for循环和cur替身）。然后先对节点的next和prev进行改变，再对原链表中的节点的next和prev进行改变：

public void addIndex(int index, int data) {
    if (index < 0 || index > size()) {
        throw new IndexOutBoundsException("获取数据时，位置不合法");
    }
    if (index == 0) {
        addFirst(data);
        return;
    }
    if (index == size()) {
        addLast(data);
        return;
    }
    ListNode node = new ListNode(data);
    ListNode cur = head;
    for (int i = 0; i < index - 1; i++) {
        cur = cur.next;
    }
    node.next = cur.next;
    node.prev = cur;
    cur.next.prev = node;
    cur.next = node;
}

我们第七个写删除第一次出现关键字为key的节点 方法remove方法。首先先判断这个链表是否为空，如果为空就直接返回。将cur设置成head的替身进行遍历。当cur.value等于key时判断是否为头结点。如果是头结点，再去判断是否这个链表只有这一个结点。如果只有这一个结点那么直接将头结点置空（也可以将尾结点置空，也因此时头结点等于尾结点。）然后返回。如果不是只有这一个节点，那么将头结点后置，然后将新的头结点的prev置空，然后返回。如果不是头结点而是尾结点，将尾结点前置，然后将新的尾结点的next置为空然后返回。如果是中间节点，那么将删除节点的前一个节点的next置成删除节点的下一个节点，删除节点的后一个节点的prev置成删除节点的掐一个节点的next然后返回。如果cur的value不等于key，那么判断下一个节点。

public void remove(int key) {
    if (head == null) {
        return;
    }
    ListNode cur = head;
    while (cur != null) {
        if (cur.value == key) {
            if (cur == head) {
                if (cur.next == null) {
                    head = null;
                } else {
                    head = head.next;
                    head.prev = null;
                }
                return;
            } else if (cur == last) {
                last = last.prev;
                last.next = null;
                return;
            } else {
                cur.prev.next = cur.next;
                cur.next.prev = cur.prev;
                return;
            }
        }
        cur = cur.next;
    }
}

我们第八个写删除所有关键字为key的节点的方法removeAllKey方法。首先需要判断链表是否为空。如果为空则直接返回。设置一个cur来当做head的替身。然后遍历这个链表。当cue的value与key相等时，如果cur是head，判断是否只有一个结点，如果只有一个结点，head置空。如果不是只有一个结点。将head后置一位，并且新head的prev置空。如果cur不是head而是last，last前置一位并且last的next置空。如果也不是last，将cur的前一个节点的next设置成cur的下一个节点，将cur的下一个节点的prev设置成cur的上一个节点。（与上一个方法相比就是把每次相等的返回去掉。）

public void removeAllKey(int key) {
    if (head == null) {
        return;
    }
    ListNode cur = head;
    while (cur != null) {
        if (cur.value == key) {
            if (cur == head) {
                if (cur.next == null) {
                    head = null;
                } else {
                    head = head.next;
                    head.prev = null;
                }
            } else if (cur == last) {
                last = last.prev;
                last.next = null;
            } else {
                cur.prev.next = cur.next;
                cur.next.prev = cur.prev;
            }
        }
        cur = cur.next;
    }
}

我们写最后一个清空链表的函数clean函数。我们可以直接将head和last置空（最简单的办法）。在java源码中是将每一个节点全部置空。

public void clear() {
    //head = null;
    //last= null;
    ListNode cur = head.next;
    while (cur != null){
        head = null;
        head = cur;
        cur = cur.next;
    }
    head = null;
}

---

总结

好啦~本篇文章就到此结束。希望大家能够多多点赞，多多评论，多多批评，大家下一篇再见!!!