链表基础训练(二)

题目一：

　　编写代码，以给定值x为基准将链表分为两部分，所有小于x的结点排在大于或等于x的结点之前。给定一个链表的头结点 ListNode * pHead，请返回重新后的链表的头指针。注意：分割以后原来的数据顺序不变，不要开辟新的空间，即不要新建节点。比如 5 6 3 2 7 以 3 为基准分区后为2 5 6 3 7。

　　思路：题目说不要新建节点，但是可以新建节点指针。定义左右两个链表指针，小于x的元素链接到左边链表，大于等于x的元素链接到右边链表，最后左右两个链表相连即可。这里需要注意边界的问题，假如左边的链表为空，那么直接返回右边链表的头指针。

public class 链表分区 {
    private static class ListNode {
        int val;
        ListNode next = null;

        ListNode(int val) {
            this.val = val;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder(val + "");
            ListNode nnext = next;
            while (nnext != null) {
                sb.append(nnext.val);
                nnext = nnext.next;
            }
            return sb.toString();
        }
    }
    public static ListNode partition(ListNode pHead, int x) {
        ListNode p = pHead;
        ListNode leftFirst = null;
        ListNode leftTail = null;
        ListNode rightFirst = null;
        ListNode rightTail = null;

        while (p != null) {//顺序扫描所有节点
          int pValue = p.val;
          if (pValue < x) {//小于x
            if (leftTail == null) {
              leftFirst = p;
              leftTail = p;
            } else {
              leftTail.next = p;
              leftTail = leftTail.next;
            }
          } else {//大于等于x
            if (rightTail == null) {
              rightFirst = p;
              rightTail = p;
            } else {
              rightTail.next = p;
              rightTail = rightTail.next;
            }
          }
          p = p.next;
        }
        if (leftFirst == null) {// 左边链表可能为空
          return rightFirst;
        }
        leftTail.next = rightFirst;//左右两个链表连接起来
        if (rightTail != null)
          rightTail.next = null;
        return leftFirst;
      }
    public static void main(String[] args) {
        int[] arr = { 5,6,3,2,7 };
        ListNode head = new ListNode(arr[0]);// 哑元
        ListNode p = head;
        for (int i = 1; i < arr.length; i++) {
            p.next = new ListNode(arr[i]);
            p = p.next;
        }
        ListNode p1 = head.next;
        ListNode res = partition(head, 3);
        while (res != null) {
            // 理解这里为什么通过res就能遍历链表  函数里是左右链表连接起来的
            System.out.println(res.val);
            res = res.next;
        }
    }
}

　　结果：

　　　　

题目二：

　　链表加法：有两个用链表表示的整数，每个结点包含一个数位。这些数位是反向存放的，也就是个位排在链表的首部。编写函数对这两个整数求和，并用链表形式返回结果。给定两个链表ListNode* A，ListNode* B，请返回A+B的结果(ListNode*)。

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

　　返回：{4,4,4}

　　{7,4,0,7,5},{2,7,2,3,4}   返回：{9,1,3,0,0,1}

　　思路：一是使用for循环遍历两个链表把对应的位上的数字加起来，遍历链表的时候创建节点最后把相加后的链表的头结点返回。二是使用递归的方法，在递归的方法中创建新的节点，把当前两个对应的链表的数字加起来，然后剩下来的节点进行递归求解，把两张链表对应位相加后的结果的节点链接起来，最后得到的就是相加后的结果的链表，返回头指针就可以了。

public class 链表加法 {
    public static ListNode plusAB(ListNode a, ListNode b) {
        return plusAB(a, b, 0);
    }

    private static ListNode plusAB(ListNode a, ListNode b, int i) {
        if (a == null && b == null && i == 0)
            return null;
        int value = i;
        if (a != null)
            value += a.val;
        if (b != null)
            value += b.val;
        ListNode result = new ListNode(value % 10);
        result.next = plusAB(a == null ? null : a.next, b == null ? null : b.next, value >= 10 ? 1 : 0);
        return result;
    }
    
    private static class ListNode {
        int val;
        ListNode next = null;

        ListNode(int val) {
            this.val = val;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder(val + "");
            ListNode nnext = next;
            while (nnext != null) {
                sb.append(nnext.val);
                nnext = nnext.next;
            }
            return sb.toString();
        }
    }

    public static void main(String[] args) {
        
        ListNode node1 = new ListNode(7);
        node1.next = new ListNode(4);
        node1.next.next = new ListNode(0);
        node1.next.next.next = new ListNode(7);
        node1.next.next.next.next = new ListNode(5);
        System.out.println(node1);

        ListNode node2 = new ListNode(2);
        node2.next = new ListNode(7);
        node2.next.next = new ListNode(2);
        node2.next.next.next = new ListNode(3);
        node2.next.next.next.next = new ListNode(4);
        System.out.println(node2);

        ListNode result = plusAB(node1, node2);
        System.out.println(result);

    }
}

　　结果：

　　　　

题目三：

　　给定一个有环链表，实现一个算法返回环路的开头结点。有环链表的定义：在链表中某个结点的next元素指向在它前面出现过的节点，则表明该链表存在环路。

　　思路：解法一，使用HashSet判断是否有重复元素。解法二，使用了经典的技巧，快慢指针。首先可以使用快慢指针来判断链表是否有环。使用两个指针来进行移动，一个为快指针，一个为慢指针，快指针一次移动两步，慢指针一次移动一步，假如链表有环的话那么这两个指针一定会在某一个地方会相遇的，为什么呢？有没有可能不会相遇呢？答案是不可能的，两个指针一定会在某一个位置上相遇，因为假如它们没有相遇，快指针的位置为i + 1,那么慢指针的位置为i，那么退回到上一步的状态，那么两个指针的位置都是i-1，那么它是一定会相遇的。所以在有环的情况之下第二圈的时候快指针追慢指针那么最后一定会在某一个位置上相遇。假如链表是没有环的，那么慢指针一定会在走的时候而快指针就到达链表的末尾了，所以永远不可能两者相遇。

　　假如题目要求不能使用额外的空间来进行记录，所以也可以使用快慢指针方式求出环起点。

　　　　

　　假设慢指针s走k步到了有环的节点，因为快指针f每次走两步，所以与有环节点的距离为k，那么这个时候应该是f追s，假设环的长度为l，所以s，f另外之间的距离为l - k，所以 f 要走多l - k的距离就可以追上s，与s相遇，由于每走一步s与f的距离就会减少1，所以当s走l - k步的时候那么两者就相遇了，这个时候相遇的点是关键，明显可以看出相遇的点与有环的点相距k的距离。而头结点到有环节点的距离也是k，那么只要s与头结点同时以同样的速度移动那么当他们相遇的时候该节点就是有环的节点了。所以我们可以在循环中判断两个指针是否相等，相等的时候跳出循环然后s与头结点同时以同样的速度移动那么当他们相遇的时候该节点就是环的起点了。

import java.util.HashSet;

public class 链表环起点 {
    private static class ListNode {
        int val;
        ListNode next = null;

        ListNode(int val) {
            this.val = val;
        }

//        @Override
//        public String toString() {
//            StringBuilder sb = new StringBuilder(val + "");
//            ListNode nnext = next;
//            while (nnext != null) {
//                sb.append(nnext.val);
//                nnext = nnext.next;
//            }
//            return sb.toString();
//        }
    }
    
    // 解法一
    public static ListNode check(ListNode head) {
        ListNode p = head;
        HashSet set = new HashSet();
        while (true) {
            if (set.contains(p))
                return p;
            else {
                set.add(p);
                p = p.next;
            }
        }
    }

    // 判断是否有环  快慢指针
    public static boolean hasCircle(ListNode head) {
        ListNode s = head;
        ListNode f = head;
        while (true) {
            s = s.next;
            f = f.next.next;
            if (s == f)
                return true;
            if (f.next == null)
                return false;
        }
    }

    // 解法二  求出环起点 这里面包含了判断是否满足有环
    public static ListNode beginOfCircle(ListNode head) {
        ListNode s = head;
        ListNode f = head;
        while (f != null && f.next != null) {
            s = s.next;
            f = f.next.next;
            if (s == f)
                break;
        }
        // System.out.println(f); 
        // 这里不能这样调用  因为默认是System.out.println(f.toString()) 
        // 会陷入死循环 因为上面重写了toString()
        // 何种方式退出的？ 如果没环 返回null
        // 下面 f == null f也会默认调用toString()方法，而导致堆溢出，
        // 所以注释掉了toString()方法 运行成功
        if (f == null || f.next == null) {
            return null;
        }
        
        ListNode p = head;
        while (p != s) {
            p = p.next;
            s = s.next;
        }
        return p;
    }

    public static void main(String[] args) {
        ListNode node = new ListNode(1);
        node.next = new ListNode(2);
        ListNode begin = new ListNode(32);
        node.next.next = begin;
        node.next.next.next = new ListNode(32);
        node.next.next.next.next = new ListNode(2);
        node.next.next.next.next.next = begin;
         ListNode res = check(node);
         System.out.println("解法一："+res.val);

        System.out.println(hasCircle(node));
        System.out.println("解法二："+beginOfCircle(node).val);
    }
}

　　结果：