【数据结构】链表的基本应用2

1.删除排序链表中的重复元素
（删除重复的元素，使每个元素值只出现一次）

public ListNode deleteDuplicates1(ListNode head) {
        ListNode cur = head;
        while(cur != null && cur.next != null) {
            if(cur.next.val == cur.val) {
                cur.next = cur.next.next;
            }else {
                cur = cur.next;
            }
        }
        return head;
    }

2.删除排序链表中的重复元素
（删除所有的重复元素,只保留原始链表中没有重复出现的数字）

public ListNode deleteDuplicates2(ListNode head) {
       if(head == null || head.next == null) {
           return head;
       } 
        ListNode result = new ListNode(-1);
        result.next = head;
        ListNode pre = result;
        while(pre.next!=null && pre.next.next!=null){
            ListNode a = pre.next;
            ListNode b = pre.next.next;
            if(b.val == a.val){
                while(b != null && b.val == a.val){
                    b = b.next;
                }
                pre.next = b;
            }
            else pre = pre.next;
        }
        return result.next; 
    }

3.编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前
（遍历整个链表，把小于 x 的尾插到一个小链表,把大于等于 x 的尾插到一个大链表中
理想情况下，把大链表接到小链表后边
如果没有小链表，直接返回大链表(大链表可能为空）
保证返回链表的最后一个结点.next == null）

public Node separateByX(Node head, int x) {
        
        /* 尾插
        1. 先情况讨论：
            1）如果当前链表为空，要插入的结点就是链表的第一个结点
            2) 如果链表不为空，
                1. 先找到当前的最后一个结点
                2. 让当前的最后一个结点的 next = 要插入的结点
                3. 如果每次的最后一个结点都是我们插入的
                    可以记录上次插入的最后一个结点
                4. 不要忘记更新最后一个结点
         */

        
        Node sHead = null;// 指向小链表的第一个结点
        Node sEnd = null;// 记录小链表的最后一个结点
        Node bHead = null;
        Node bEnd = null;

        for (Node cur = head; cur != null; cur = cur.next) {
            if (cur.val < x) {
                 /* 尾插到小的链表中 */
                if (sHead == null) {
                    sHead = cur;
                } else {
                    sEnd.next = cur;
                }
                sEnd = cur;
            } else {
                /* 尾插到大的链表中 */
                // 同理
                if (bHead == null) {
                    bHead = cur;
                } else {
                    bEnd.next = cur;
                }
                bEnd = cur;
            }
        }

        if (sEnd == null) {
            return bHead;
        }

        sEnd.next = bHead;
        if (bEnd != null) {
            bEnd.next = null;
        }
        return sHead;
    }

4.回文链表

public boolean isPalindrome(ListNode head) {
         if (head == null || head.next == null)
            return true;

        int len = 0;
        for (ListNode cur = head; cur != null; cur = cur.next) {
            len++;
        }
        // 反转前半段链表
        ListNode cur = head, pre = null;
        for (int i = 0; i < len / 2; i++) {
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        // 奇数个链表结点cur后移一位
        if ((len & 1) == 1) {
            cur = cur.next;
        }
        // 遍历比较pre和cur的值相等否
        for (ListNode p = cur, q = pre; p != null && q != null; p = p.next, q = q.next) {
            if (p.val != q.val)
                return false;
        }
        return true;

    }

5.相交链表
编写一个链表，找到两个单链表相交的起始结点

 public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) return null;
    ListNode pA = headA, pB = headB;
    while (pA != pB) {
        pA = pA == null ? headB : pA.next;
        pB = pB == null ? headA : pB.next;
    }
    return pA;