链表常见题型

环形链表插值练习题

有一个整数val，如何在节点值有序的环形链表中插入一个节点值为val的节点，并且保证这个环形单链表依然有序。
给定链表的信息，及元素的值A及对应的nxt指向的元素编号同时给定val，请构造出这个环形链表，并插入该值。
测试样例：
[1,3,4,5,7],[1,2,3,4,0],2
返回：{1,2,3,4,5,7}

分析：
一共有三种情况
1、如果原链表为空
2、如果链表不为空
3、如果p和c转一圈都没有发现应该插入的位置，此时node应该插入头节点的前面

import java.util.*;


class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class InsertValue {
    public ListNode insert(int[] A, int[] nxt, int val) {

        if (A == null || A.length == 0){
            ListNode node = new ListNode(val);
            return node;
        }
        ListNode head = new ListNode(A[0]);
        // 构建有序链表（并非环形，因为不能题目不让返回环形）
        ListNode headTemp = head;
        for (int i = 0; i < A.length-1; i++){
            ListNode temp = new ListNode(A[nxt[i]]);
            headTemp.next = temp;
            headTemp = temp;
        }
        // 如果值小于链表头部值，则插入头部，且返回node链表
        if (val < head.val){
            ListNode node = new ListNode(val);
            node.next = head;
            return node;
        }

        // 循环遍历，寻找合适的位置插入
        ListNode pre = head;
        ListNode cur = pre.next;
        while (cur != null){
            if (val >= pre.val && val <= cur.val){
                break;
            }
            pre = cur;
            cur = cur.next;
        }
        // 要么是找到了合适的位置（break出来），要么是val都大于链表值，在最后位置插入
        ListNode node = new ListNode(val);
        node.next = cur;
        pre.next = node;

        return head;

    }
}

---

访问单个节点的删除练习题

实现一个算法，删除单向链表中间的某个结点，假定你只能访问该结点。
给定带删除的节点，请执行删除操作，若该节点为尾节点，返回false，否则返回true

分析：
1、下一个节点指向删除的节点，然后删除下一个节点

import java.util.*;


class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class Remove {
    public boolean removeNode(ListNode pNode) {
        // 空节节不能删除
        if (pNode == null){
            return false;
        }
        ListNode next = pNode.next;
        // 空节点不能赋值给节点
        if (next == null){
            return false;
        }
        pNode.val = next.val;
        pNode.next = next.next;
        return true;

    }
}

---

链表的分化练习题

对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。
给定一个链表的头结点head，同时给定阈值val，请返回一个链表，使小于等于它的结点在前，大于等于它的在后，保证结点值不重复。
测试样例：
{1,4,2,5},3
返回结果：
{1,2,4,5}
分析：
1、建立两个链表：小于等于val链表，大于val链表

import java.util.*;

class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class Divide {
    public ListNode listDivide(ListNode head, int val) {
        if (head == null || head.next == null){
            return head;
        }
        // 当前节点
        ListNode curNode = head, temp = null;
        // 小于val的链表与尾节点
        ListNode smallerHead = null, smallerTail = null;
        // 与大于val的链表与尾节点
        ListNode biggerHead = null, biggerTail = null;
        while (curNode != null){
            // 取出第一个节点
            temp = curNode;
            curNode = curNode.next;

            // 避免其它链表连接后成为闭环
            temp.next = null;
            int value = temp.val;


            if (value <= val){
                // 如果是第一个，则附头
                if (smallerHead == null){
                    smallerHead = temp;
                }
                // 如果不是第一个，则尾部添加
                else{
                    smallerTail.next = temp;
                }
                // 尾部指向最后一个
                smallerTail = temp;
            }
            else {
                 // 如果是第一个，则附头
                if (biggerHead == null){
                    biggerHead = temp;
                }
                // 如果不是第一个，则尾部添加
                else{
                    biggerTail.next = temp;
                }
                // 尾部指向最后一个
                biggerTail = temp;
            }
        }
        // 如果小的链表没值，则返回大的链表
        if (smallerHead == null){
            return biggerHead;
        }
        // 如果大的链表没值，则返回小的链表
        if (biggerHead == null){
            return smallerHead;
        }
        // 小链表与大链表连接
        smallerTail.next = biggerHead;
        return smallerHead;

    }
}

---

打印两个链表的公共值练习题

现有两个升序链表，且链表中均无重复元素。请设计一个高效的算法，打印两个链表的公共值部分。
给定两个链表的头指针headA和headB，请返回一个vector，元素为两个链表的公共部分。请保证返回数组的升序。两个链表的元素个数均小于等于500。保证一定有公共值
测试样例： {1,2,3,4,5,6,7},{2,4,6,8,10}
返回：[2.4.6]

分析：
1、两数比较，小的自己+1，等于的装进数组，然后都+1

import java.util.*;

class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class Common {
    public int[] findCommonParts(ListNode headA, ListNode headB) {
        List<Integer> list = new ArrayList<>();
        while (headA != null && headB != null){
            if (headA.val < headB.val){
                headA = headA.next;
            }
            else if (headA.val > headB.val){
                headB = headB.next;
            }
            else{
                list.add(headA.val);
                headA = headA.next;
                headB = headB.next;
            }
        }
        int[] a = new int[list.size()];
        for (int i = 0; i < list.size(); i++)
        {
            a[i] = list.get(i);
        }
        return a;

    }
}

---

链表的k逆序练习题

有一个单链表，请设计一个算法，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点。例如链表1->2->3->4->5->6->7->8->null，K=3这个例子。调整后为，3->2->1->6->5->4->7->8->null。因为K==3，所以每三个节点之间逆序，但其中的7，8不调整，因为只有两个节点不够一组。 给定一个单链表的头指针head,同时给定K值，返回逆序后的链表的头指针。

分析：
1、使用栈存储3个数，出栈就是倒序啦。里边有许多的细节需要画图处理的

import java.util.*;

class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class KInverse {
    public ListNode inverse(ListNode head, int k) {
        if (k < 2){
            return head;
        }
        Stack<ListNode> stack = new Stack<>();
        ListNode newHead = head, cur = head;
        // 上一个链表的末端，下一个链表的开始
        ListNode preEnd = null, nextStart = null;
        while (cur != null){
            nextStart = cur.next;
            stack.push(cur);
            if (stack.size() == k){
                preEnd = reload(stack, preEnd, nextStart);
                // 因为逆序了，所以头结点需要改变（就一次）
                if (newHead == head){
                    newHead = cur;
                }
            }
            cur = nextStart;
        }
        return newHead;
    }
    public ListNode reload(Stack<ListNode> stack, ListNode preEnd, ListNode nextStart){
        ListNode cur = stack.pop();
        // 如果不等于null，则上一个末端（preEnd）直接连接当前（cur）的节点
        if (preEnd != null){
            preEnd.next = cur;
        }
        ListNode next = null;
        while (!stack.isEmpty()){
            next = stack.pop();
            cur.next = next;
            cur = next;
        }
        // 三个节点中的最后一个节点与下一个链表（nextStart）连接
        cur.next = nextStart;
        // 返回当前链表的最后一个节点
        return cur;
    }
}

---

链表指定值清除练习题

现在有一个单链表。链表中每个节点保存一个整数，再给定一个值val，把所有等于val的节点删掉。
给定一个单链表的头结点head，同时给定一个值val，请返回清除后的链表的头结点，保证链表中有不等于该值的其它值。请保证其他元素的相对顺序。
测试样例：
{1,2,3,4,3,2,1},2
返回值：
{1,3,4,3,1}

分析：
1、遍历链表，一样的值则删除掉

import java.util.*;

class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class ClearValue {
    public ListNode clear(ListNode head, int val) {
        // 避免头部为一样值
        while (head != null){
            if (head.val != val)
                break;
            head = head.next;
        }
        ListNode pre = head;
        ListNode cur = head;
        // 遍历链表，一样的值则删除
        while (cur != null){
            if (cur.val == val){
                pre.next = cur.next;
            }
            else {
                pre = cur;
            }
            cur = cur.next;
        }
        return head;
    }
}

---

链表的回文结构练习题

请编写一个函数，检查链表是否为回文。 给定一个链表ListNode* pHead，请返回一个bool，代表链表是否为回文。
测试样例：
{1,2,3,2,1}
返回：true
{1,2,3,2,3}

分析：
回文:是否对称
1、将数据全入栈，出栈的时候与链表一一比较，都相等则回文。。

import java.util.*;


class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class Palindrome {
    public boolean isPalindrome(ListNode pHead) {
        if (pHead == null){
            return false;
        }
        Stack<ListNode> stack = new Stack<>();
        // 将节点都放到栈里
        ListNode cur = pHead;
        while (cur != null){
            stack.push(cur);
            cur = cur.next;
        }
        // 出栈，看是否全都相等
        ListNode temp = null;
        cur = pHead;
        while (!stack.isEmpty()){
            temp = stack.pop();
            if (temp.val != cur.val){
                return false;
            }
            else {
                cur = cur.next;
            }
        }
        return true;
    }
}

---

链表判环练习题

如何判断一个单链表是否有环？有环的话返回进入环的第一个节点的值，无环的话返回-1。如果链表的长度为N，请做到时间复杂度O(N)，额外空间复杂度O(1)。
给定一个单链表的头结点head（注意另一个参数adjust为加密后的数据调整参数，方便数据设置，与本题求解无关)，请返回所求值。

import java.util.*;


class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class ChkLoop {
    public int chkLoop(ListNode head, int adjust) {
        ListNode fast = head;
        ListNode slow = head;
        boolean circle = false;
        while (fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            // 当相等时说明是闭环；
            if (fast == slow){
                circle = true;
                break;
            }
        }
        if (circle == false){
            return -1;
        }
        // fast再从头来开始，当它们再次相遇说明是入口点；
        fast = head;
        while(fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return fast.val;

    }
}

---