链表

环形链表插值问题

题目：
有一个整数val，如何在节点值有序的环形链表中插入一个节点值为val的节点，并且保证这个环形单链表依然有序。

给定链表的信息，及元素的值A及对应的nxt指向的元素编号同时给定val，请构造出这个环形链表，并插入该值。

测试样例：
[1,3,4,5,7],[1,2,3,4,0],2
返回：{1,2,3,4,5,7}

代码：

import java.util.*;

/*
public 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 curNode = new ListNode(val);
            curNode.next = curNode;
            return curNode;
        }

        ListNode head = new ListNode(A[0]);
        ListNode tail = head;

        for(int i=0;i<nxt.length;i++){
            ListNode curNode = null;
            if(nxt[i]==0){
                curNode = head;
            }else{
                curNode = new ListNode(A[nxt[i]]);
                tail.next = curNode;
                tail = curNode; 
            }


        }

        tail.next = head;


        //循环比较值
        ListNode curNode = new ListNode(val);
        if(val<=head.val){
            curNode.next = head;
            tail.next = curNode;
            return curNode;
        }

        ListNode preNode = head;
        ListNode nextNode = preNode.next;

        while(val>nextNode.val&&nextNode.next!=head){
            preNode = nextNode;
            nextNode = preNode.next;
        }

        curNode.next = nextNode;
        preNode.next = curNode;

        return head;

    }
}

链表的分化问题

题目：
对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。

给定一个链表的头结点head，同时给定阈值val，请返回一个链表，使小于等于它的结点在前，大于等于它的在后，保证结点值不重复。

测试样例：
{1,4,2,5},3
{1,2,4,5}

代码：

import java.util.*;

/*
public 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;
        }

        //将链表与val循环比较，分成两部分，小于等于的组成一个链表，大于的组成另一个链表，然后最后将这两个链表链接起来即可
        ListNode minHead = null;
        ListNode minTail = null;
        ListNode maxHead = null;
        ListNode maxTail = null;
        ListNode temp = null;

        while(head!=null){
            //定义一个临时节点，保存head的next引用
            temp = head.next;
            //将head的next设为空
            head.next = null;

            if(head.val<=val){
                if(minHead==null){
                    minHead = head;
                    minTail = head;
                }else{
                    minTail.next = head;
                    minTail = head;
                }
            }else{

                if(maxHead==null){
                    maxHead = head;
                    maxTail = head;
                }else{
                    maxTail.next = head;
                    maxTail = head;
                }  
            }

            head = temp;

        }

        //小链表不为空，返回小链表的头部，否则返回大链表的头部
        if(minHead!=null){

            minTail.next = maxHead;
            return minHead;
        }else{
            return maxHead;
        }


    }
}

链表指定值清除

题目：
现在有一个单链表。链表中每个节点保存一个整数，再给定一个值val，把所有等于val的节点删掉。

给定一个单链表的头结点head，同时给定一个值val，请返回清除后的链表的头结点，保证链表中有不等于该值的其它值。请保证其他元素的相对顺序。

测试样例：
{1,2,3,4,3,2,1},2
{1,3,4,3,1}

代码：

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class ClearValue {
    public ListNode clear(ListNode head, int val) {
        // write code here
        if(head==null){
            return head;
        }

        while(head!=null&&head.val==val){
            head = head.next;
        }

        ListNode node = head;
        while(node.next!=null){

            if(node.next.val==val){
                node.next = node.next.next; 
            }else{

                node = node.next;

            } 

        }

        return head;

    }
}