链表

Tips:

 1.链表结构dummy node 的使用。当链表结构发生变化时使用dummy node.也就是其链表表头可能发生变化的时候。

2.链表结构基本操作：

　　插入一个节点

　　删除一个节点

　　旋转链表

　　合并两个链表

　　求一个链表的中间位置

 几个总结：

以下题目细节容易出错：

1. 删除排序链表重复元素这两个题，两个循环的使用。

2. 翻转链表，删除倒数第n个结点这两个题，首先找倒数第n,不够跳出，然后两指针移动的这两个题目。

 

 

 

删除排序链表中的重复元素****

给定一个排序链表，删除所有重复的元素每个元素只留下一个

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

 

删除排序链表中的重复数字 II

给定一个排序链表，删除所有重复的元素只留下原链表中没有重复的元素。

题目不难，但是有需要注意细节。引入dummyNode prev 和 curt简化代码

public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode tail = dummy;
        while (head != null) {
            while (head != null && head.next != null && head.val == head.next.val) {
                head = head.next;
            }
            if (tail.next == head) {
                tail = tail.next;
                head = head.next;
            } else {
                tail.next = head.next;
                head = head.next;
            }
        }
        return dummy.next;
    }

 

在O(1)时间复杂度删除链表节点

给定一个单链表中的一个等待被删除的节点(非表头或表尾)。请在在O(1)时间复杂度删除该链表节点。

没多少意思，就是套路。

 public void deleteNode(ListNode node) {
        // write your code here
        if (node  == null || node.next == null) {
            return;
        }
        node.val = node.next.val;
        node.next = node.next.next;
    }

 

 删除链表中的元素

删除链表中等于给定值val的所有节点

public ListNode removeElements(ListNode head, int val) {
        // Write your code here
        if (head == null) {
            return null;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode prev = dummy;
        ListNode curt = head;
        while (curt != null) {
            while (curt != null && curt.val == val) {
                curt = curt.next;
            }
            prev.next = curt;
            prev = curt;
            if (curt != null) {
                curt = curt.next;
            }
        }
        return dummy.next;
    }

 

无序链表的重复项删除

删除链表中等于给定值val的所有节点

 public ListNode removeElements(ListNode head, int val) {
        // Write your code here
        if (head == null) {
            return null;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode prev = dummy;
        ListNode curt = head;
        while (curt != null) {
            while (curt != null && curt.val == val) {
                curt = curt.next;
            }
            prev.next = curt;
            prev = curt;
            if (curt != null) {
                curt = curt.next;
            }
        }
        return dummy.next;
    }

两两交换链表中的节点

public ListNode swapPairs(ListNode head) {
        // Write your code here
        if (head == null || head.next == null) {
            return head;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode tail = dummy;
        ListNode tmp = null;
        while (head != null && head.next != null) {
            tmp = head.next.next;
            tail.next = head.next;
            head.next.next = head;
            head.next = tmp;
            tail = head;
            head = tmp;
        }
        return dummy.next;
    }

 

交换链表当中两个节点

给你一个链表以及两个权值v1和v2，交换链表中权值为v1和v2的这两个节点。保证链表中节点权值各不相同，如果没有找到对应节点，那么什么也不用做。

 public ListNode swapNodes(ListNode head, int v1, int v2) {
        // Write your code here
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode curt = head;
        ListNode first = null;
        ListNode prevFirst = null;
        ListNode nextFirst = null;
        ListNode second = null;
        ListNode prevSecond = null;
        ListNode nextSecond = null;
        ListNode prev = dummy;
        while (curt != null) {
            if (v1 == curt.val) {
                first = curt;
                prevFirst = prev;
                nextFirst = curt.next;
            }
            else if (v2 == curt.val) {
                second = curt;
                prevSecond = prev;
                nextSecond = curt.next;
            }
            prev = curt;
            curt = curt.next;
        }
        if (first != null && second != null) {
            if (prevFirst == second) {
                prevSecond.next = first;
                first.next = second;
                second.next = nextFirst;
            }
            else if (prevSecond == first) {
                prevFirst.next = second;
                second.next = first;
                first.next = nextSecond;
            }
            else {
                prevFirst.next = second;
                second.next = nextFirst;
                prevSecond.next = first;
                first.next = nextSecond;     
            }
            return dummy.next;
        }
        else {
            return head;
        }
    }

 

删除链表中倒数第n个节点

给定一个链表，删除链表中倒数第n个节点，返回链表的头节点。

 

旋转链表 --not bug free

给定一个链表，旋转链表，使得每个节点向右移动k个位置，其中k是一个非负数

之前提交的代码其实是有bug的,lintcode测试不完备。

方法一：两个指针

public ListNode rotateRight(ListNode head, int k) {
        if (head == null || k == 0) {
            return head;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode right = dummy;
        ListNode left = dummy;
        int i = 0;
        for (; i < k; i++) {
            right = right.next; // 不能与下一句话交换顺序，否则跳出时i记录的就不是结点个数
            if (right == null) {
                break;
            }
           
        }
        if (right == null) {
            k %= i;
            if (k == 0) {
                return head;
            }
            right = dummy;
            for (i = 0; i < k; i++) {
                right = right.next;
            }
        }
        while (right.next != null) {
            right = right.next;
            left = left.next;
        }
        ListNode newHead = left.next;
        left.next = null;
        right.next = dummy.next;
        return newHead;
    }

 

方法二：直接先求出长度，省的出现那么多问题

public ListNode rotateRight(ListNode head, int k) {
        if (head == null || k == 0) {
            return head;
        }
        int size = 0;
        ListNode cur = head;
        while (cur.next != null) {
            size++;
            cur = cur.next;
        }
        ListNode tail = cur;
        size += 1;
        k %= size;
        if (k == 0) {
            return head;
        }
        size = size - k - 1;
        cur = head;
        for (int i = 0; i < size; i++) {
            cur = cur.next;
        }
        ListNode newHead = cur.next;
        cur.next = null;
        tail.next = head;
        return newHead;
    }

 

 

翻转链表

翻转一个链表

public ListNode reverse(ListNode head) {
        // write your code here
        if (head == null || head.next == null) {
            return head;
        }
        ListNode curt = head;
        ListNode prev = null;
        ListNode tmp;
        while (curt != null) {
            tmp = curt.next;
            curt.next = prev;
            prev = curt;
            curt = tmp;
        }
        return prev;
    }

翻转链表 II

翻转链表中第m个节点到第n个节点的部分

分步骤进行，先找到节点，再翻转，再连接。

public ListNode reverseBetween(ListNode head, int m , int n) {
        // write your code
        if (head == null || head.next == null) {
            return head;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        reverseNode(dummy, m, n);
        return dummy.next;
    }
    public void reverseNode(ListNode dummy, int m, int n) {
        ListNode head = dummy.next;
        ListNode begin = findKth(head, m - 1);
        ListNode curt = begin == null ? head:begin.next;
        ListNode end = curt;
        //reverse
        ListNode tmp = null;
        ListNode prev = null;
        for (int i = m; i <= n; i++) {
            tmp = curt.next;
            curt.next = prev;
            prev = curt;
            curt = tmp;
        }
        //connect
        if (begin == null) {
            dummy.next = prev;
        }
        else {
            begin.next = prev;
        }
        end.next = curt;
    }
     public ListNode findKth(ListNode head, int k) {
        if (k == 0) {
            return null;
        }
        while (k > 1 && head != null) {
            head = head.next;
            k--;
        }
        return head;
    } 

 

链表划分

给定一个单链表和数值x，划分链表使得所有小于x的节点排在大于等于x的节点之前。

你应该保留两部分内链表节点原有的相对顺序。

代码中Attention,注意！容易忽略

public ListNode partition(ListNode head, int x) {
        // write your code here
        if (head == null || head.next == null) {
            return head;
        }
        ListNode leftDummy = new ListNode(0);
        ListNode rightDummy = new ListNode(0);
        ListNode left = leftDummy;
        ListNode right = rightDummy;
        
        while (head != null) {
            if (head.val < x) {
                left.next = head;
                left = head;
            }
            else {
                right.next = head;
                right = head;
            }
            head = head.next;
        }
        right.next = null;//attention
        left.next = rightDummy.next;
        return leftDummy.next;
    }

 

链表排序

数组：

　　merge Sort : time O(nlogn)  space O(n)

　　quick Sort:    time O(nlogn)  space O(1)

　　heap Sort: 　time O(nlogn)  apace O(1)

链表排序不能使用堆排序，因为堆排序是直接定位去找元素的，在链表结构中，这较浪费时间。

这里使用归并排序

 public ListNode sortList(ListNode head) {  
        // write your code here
        if (head == null || head.next == null) {
            return head;
        }
        ListNode middle = middleNode(head);
        ListNode right = sortList(middle.next);
        middle.next = null;
        ListNode left = sortList(head);
        return merge(left, right);
    }
    public ListNode merge(ListNode left, ListNode right) {
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        while (left != null && right != null) {
            if (left.val < right.val) {
                tail.next = left;
                left = left.next;
            }
            else {
                tail.next = right;
                right = right.next;
            }
            tail = tail.next;
        }
        if (left != null) {
            tail.next = left;
        }
        else {
            tail.next = right;
        }
        return dummy.next;
    }
    public ListNode middleNode(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode fast = head.next;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

 

 链表插入排序*

有一点需要特别注意的，dummy.next并没有指向head，前面排序好的部分的尾节点指向空，这样就避免了12345这样的考察当前，发现并没有比它大的所带来的问题。

 public ListNode insertionSortList(ListNode head) {
        // write your code here
        ListNode dummy = new ListNode(0);
        while (head != null) {
            ListNode node = dummy;
            while (node.next != null && node.next.val < head.val) {
                node = node.next;
            }
            ListNode tmp = head.next;
            head.next = node.next;
            node.next = head;
            head = tmp;
        }
        return dummy.next;
    }

 

重排链表

给定一个单链表L: L0→L1→…→Ln-1→Ln,

重新排列后为：L0→Ln→L1→Ln-1→L2→Ln-2→…

必须在不改变节点值的情况下进行原地操作。

找中点 -> 求逆序->合并

public void reorderList(ListNode head) {
        if (head == null || head.next == null) {
            return;
        }
        ListNode middle = findMiddle(head);
        ListNode newHead = reverseList(middle);
        mergeTwoList(head, newHead);
    }
    public void mergeTwoList(ListNode head, ListNode newHead) {
        while (newHead != null) {
            ListNode temp1 = head.next;
            ListNode temp2 = newHead.next;
            head.next = newHead;
            newHead.next = temp1;
            head = temp1;
            newHead = temp2;
        }
        if (head != null) {
            // 如果原来节点个数为偶数个的话，前半部分的最后一个节点指针还指向后半部分的，如果不加此操作，导致MLE   
            head.next = null; // Attention! 
        }
    }
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        while (head != null) {
            ListNode temp = head.next;
            head.next = prev;
            prev = head;
            head = temp;
        }
        return prev;
    }
    public ListNode findMiddle(ListNode head) {
        ListNode right = head;
        ListNode left = head;
        while (right != null && right.next != null) {
            right = right.next.next;
            left = left.next;
        }
        return left;
    }

 

Palindrome Linked List

Implement a function to check if a linked list is a palindrome.

找中点—>求逆序->比较

public boolean isPalindrome(ListNode head) {
        // Write your code here
        if (head == null || head.next == null) {
            return true;
        }
        ListNode middle = findMiddle(head);
        ListNode reverseHead = reverseList(middle.next);
        middle.next = null;
        return isPalindromeHelp(head, reverseHead);
    }
    public ListNode findMiddle (ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode fast = head.next;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        while (head != null) {
            ListNode temp = head.next;
            head.next = prev;
            prev = head;
            head = temp;
        }
        return prev;
    }
    public boolean isPalindromeHelp(ListNode l1, ListNode l2) {
        while (l1 != null && l2 != null) {
            if (l1.val != l2.val) {
                return false;
            }
            l1 = l1.next;
            l2 = l2.next;
        }
        return true;
    }

 

带环链表

给定一个链表，判断它是否有环。

public boolean hasCycle(ListNode head) {  
        // write your code here
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (slow == fast) {
                return true;
            }
        }
        return false;
    }

 

带环链表 II

给定一个链表，如果链表中存在环，则返回到链表中环的起始节点的值，如果没有环，返回null。

public ListNode detectCycle(ListNode head) {  
        // write your code here
        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) {//Attention
            return null;
        }
        slow  = head;
        while (fast != slow) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }

 

合并两个排序链表

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // write your code here
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                tail.next = l1;
                l1 = l1.next;
            }
            else {
                tail.next = l2;
                l2 = l2.next;
            }
            tail = tail.next;
        }
        if (l1 != null) {
            tail.next = l1;
        }
        else {
            tail.next = l2;
        }
        return dummy.next;
    }

 

合并k个排序链表

合并k个排序链表，并且返回合并后的排序链表。尝试分析和描述其复杂度。

方法一：分治 Nlogk

public ListNode mergeKLists(List<ListNode> lists) {  
        // write your code here
        if (lists == null || lists.size() == 0) {
            return null;
        }
        return mergeKListsHelp(lists, 0, lists.size() - 1);
    }
    public ListNode mergeKListsHelp(List<ListNode> lists, int start, int end) {
        if (start == end) {
            return lists.get(start);
        }
        if (start + 1 == end) {
            return mergeTwoLists(lists.get(start), lists.get(end));
        }
        int mid = (start + end) / 2;
        return mergeTwoLists(mergeKListsHelp(lists, start,mid), mergeKListsHelp(lists, mid + 1, end));
    }
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // write your code here
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                tail.next = l1;
                l1 = l1.next;
            }
            else {
                tail.next = l2;
                l2 = l2.next;
            }
            tail = tail.next;
        }
        if (l1 != null) {
            tail.next = l1;
        }
        else {
            tail.next = l2;
        }
        return dummy.next;
    } 

方法二：heap Nlogk

private Comparator<ListNode> ListNodeComparator = new Comparator<ListNode>(){
        public int compare(ListNode left, ListNode right) {
            if (left == null) {
                return 1;
            }
            if (right == null) {
                return -1;
            }
            return left.val - right.val;
        }
    };
    public ListNode mergeKLists(List<ListNode> lists) {  
        // write your code here
        if (lists == null || lists.size() == 0) {
            return null;
        }
        Queue<ListNode> queue = new PriorityQueue<ListNode>(lists.size(), ListNodeComparator);
        for (int i = 0; i < lists.size(); i++) {
            if (lists.get(i) != null) {
                queue.offer(lists.get(i));
            }
        }
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        while (!queue.isEmpty()) {
            ListNode top = queue.poll();
            tail.next = top;
            tail = top;
            if (top.next != null) {
                queue.offer(top.next);
            }
        }
        return dummy.next;
    }

方法三：merge Two By Two

public ListNode mergeKLists(List<ListNode> lists) {  
        // write your code here
        if (lists == null || lists.size() == 0) {
            return null;
        }
        while (lists.size() > 1) {
            List<ListNode> new_List = new ArrayList<ListNode>();
            for (int i = 0; i < lists.size() - 1; i += 2) {
                ListNode tmp = mergeTwoList(lists.get(i),lists.get(i + 1));
                new_List.add(tmp);
            }
            if (lists.size() % 2 == 1) {
                new_List.add(lists.get(lists.size() - 1));
            }
            lists = new_List;
        }
        return lists.get(0);
    }
    public ListNode mergeTwoList(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                tail.next = l1;
                l1 = l1.next;
            }
            else {
                tail.next = l2;
                l2 = l2.next;
            }
            tail = tail.next;
        }
        if (l1 != null) {
            tail.next = l1;
        }
        else {
            tail.next = l2;
        }
        return dummy.next;
    }

 

复制带随机指针的链表

给出一个链表，每个节点包含一个额外增加的随机指针可以指向链表中的任何节点或空的节点。

返回一个深拷贝的链表。

方法一：hashMap

public RandomListNode copyRandomList(RandomListNode head) {
        // write your code here
        if (head == null) {
            return null;
        }
        HashMap<RandomListNode, RandomListNode> hashMap = new HashMap<>();
        RandomListNode tmpNode = null;
        RandomListNode old = head;
        while (old != null) {
            tmpNode = new RandomListNode(old.label);
            hashMap.put(old, tmpNode);
            old = old.next;
        }
        old = head;
        while (old != null)  {
            RandomListNode new_node = hashMap.get(old);
            new_node.next = hashMap.get(old.next);
            new_node.random = hashMap.get(old.random);
            old = old.next;
        }
        return hashMap.get(head);
    }

方法二：指针操作，先和在一起。然后再分开。复制next 复制random 拆开

public RandomListNode copyRandomList(RandomListNode head) {
        // write your code here
        if (head == null) {
            return null;
        }
        copyNext(head);
        copyRandom(head);
        return splitList(head);
    }
    public void copyNext(RandomListNode head) {
        while (head != null) {
            RandomListNode new_node = new RandomListNode(head.label);
            new_node.next = head.next;
            new_node.random = head.random;
            head.next = new_node;
            head = new_node.next;
        }
    }
    public void copyRandom(RandomListNode head) {
        while (head != null) {
            if (head.next.random != null) {
                head.next.random = head.random.next;
            }
            head = head.next.next;
        }
    }
    public RandomListNode splitList(RandomListNode head) {
        RandomListNode new_head = head.next;
        while (head != null) {
            RandomListNode tmp = head.next;
            head.next = tmp.next;
            head = head.next;
            if (tmp.next != null) {
                tmp.next = tmp.next.next;
            }
        }
        return new_head;
    }

 

排序列表转换为二分查找树

分治

 public TreeNode sortedListToBST(ListNode head) {  
        // write your code here
        if (head == null) {
            return null;
        }
        if (head.next == null) {
            return new TreeNode(head.val);
        }
        ListNode preMiddle = findPreMiddle(head);
        if (preMiddle == null) {
            TreeNode root = new TreeNode(head.val);
            TreeNode right = new TreeNode(head.next.val);
            root.right = right;
            return root;
        }
        ListNode middle = preMiddle.next;
        TreeNode root = new TreeNode(middle.val);
        
        TreeNode right = sortedListToBST(middle.next);
        preMiddle.next = null;
        TreeNode left = sortedListToBST(head);
        
        root.left = left;
        root.right = right;
        return root;
    }
    public ListNode findPreMiddle(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode prev = null;
        ListNode slow = head;
        ListNode fast = head.next;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            prev = slow;
            slow = slow.next;
        }
        return prev;
    }

 分治法二：

 private ListNode current;
    public TreeNode sortedListToBST(ListNode head) {  
        // write your code here
        if (head == null) {
            return null;
        }
        int size = getSize(head);
        current = head;
        return sortedListToBSTHelper(size);
    }
    public int getSize(ListNode head) {
        int size = 0;
        while (head != null) {
            head = head.next;
            size++;
        }
        return size;
    }
    public TreeNode sortedListToBSTHelper(int size) {
        if (size <= 0) {
            return null;
        }
        TreeNode left = sortedListToBSTHelper(size / 2);
        TreeNode root = new TreeNode(current.val);
        current = current.next;
        TreeNode right = sortedListToBSTHelper(size - 1 -size / 2);
        root.left = left;
        root.right = right;
        return root;
    }

 

将二叉查找树转换成双链表

将一个二叉查找树按照中序遍历转换成双向链表。

方法一：

中序遍历结束后再进行转化。

public DoublyListNode bstToDoublyList(TreeNode root) {  
        // Write your code here
        if (root == null) {
            return null;
        }
        List<DoublyListNode> list = new ArrayList<>();
        inorderTraverse(list, root);
        int size = list.size();
        for (int i = 1; i < size - 1; i++) {
            list.get(i).next = list.get(i + 1);
            list.get(i).prev = list.get(i - 1);
        }
        if (size > 1) {
            list.get(0).next = list.get(1);
            list.get(size - 1).prev = list.get(size - 2);
        }
        else {
            list.get(0).next = null;
        }
        return list.get(0);
    }
    public void inorderTraverse(List<DoublyListNode> list, TreeNode root) {
        if (root.left != null) {
            inorderTraverse(list, root.left);
        }
        list.add(new DoublyListNode(root.val));
        if (root.right != null) {
            inorderTraverse(list, root.right);
        }
        
    }

方法二：ResultType,记录最左边最右边

public DoublyListNode bstToDoublyList(TreeNode root) {  
        // Write your code here
        if (root == null) {
            return null;
        }
        return helper(root).first;
    }
    public ResultType helper(TreeNode root) {
        if (root == null) {
            return null;
        }
        ResultType left = helper(root.left);
        ResultType right = helper(root.right);
        DoublyListNode node = new DoublyListNode(root.val);
        ResultType result = new ResultType(null,null);
        if (left == null) {
            result.first = node;
        } 
        else {
            result.first = left.first;
            left.last.next = node;
            node.prev =left.last;
        }
        if (right == null) {
            result.last = node;
        }
        else {
            result.last = right.last;
            node.next = right.first;
            right.first.prev = node;
        }
        return result;
    }

 

K组翻转链表

给你一个链表以及一个k,将这个链表从头指针开始每k个翻转一下。
链表元素个数不是k的倍数，最后剩余的不用翻转。

一段一段翻转。首先获取长度，看一共有多少段需要翻转。对每一段需要翻转的，记录tail 和head,翻转结果返回尾部和下一个节点。然后tail.next = 尾部,head.next = 下一个,

tail = head,head = head.next。

public ListNode reverseKGroup(ListNode head, int k) {
        // Write your code here
        if (head == null || k <= 1) {
            return head;
        }
        int size = getSize(head);
        if (size < k) {
            return head;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode tail = dummy;
        int group = size / k;
        for (int i = 0; i < group; i++) {
            ListNode[] reversed = reverseKHelp(head, k);
            tail.next = reversed[0];
            head.next = reversed[1];
            tail = head;
            head = head.next;
        }
        return dummy.next;
    }
    public ListNode[] reverseKHelp(ListNode head, int k) {
        ListNode prev = null;
        ListNode curt = head;
        ListNode tmp;
        while (curt != null && k > 0) {
            tmp = curt.next;
            curt.next = prev;
            prev = curt;
            curt = tmp;
            k--;
        }
        ListNode[] res = {prev,curt};
        return res;
    }
    public int getSize(ListNode head) {
        int size = 0;
        while (head != null) {
            head = head.next;
            size++;
        }
        return size;
    }

 

链表求和

你有两个用链表代表的整数，其中每个节点包含一个数字。数字存储按照在原来整数中相反的顺序，使得第一个数字位于链表的开头。写出一个函数将两个整数相加，用链表形式返回和。

public ListNode addLists(ListNode l1, ListNode l2) {
        // write your code here
        if (l1 == null) {
            return l2;
        }
        if (l2 == null) {
            return l1;
        }
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        int flag = 0;
        int sum = 0;
        while (l1 != null && l2 != null) {
            sum = l1.val + l2.val + flag;
            flag = sum/10;
            tail.next = new ListNode(sum % 10);
            tail = tail.next;
            l1 = l1.next;
            l2 = l2.next;
        }
        while (l1 != null) {
            sum = l1.val + flag;
            flag = sum/10;
            tail.next = new ListNode(sum % 10);
            tail = tail.next;
            l1 = l1.next;
        }
        while (l2 != null) {
            sum = l2.val + flag;
            flag = sum/10;
            tail.next = new ListNode(sum % 10);
            tail = tail.next;
            l2 = l2.next;
        }
        if (flag == 0) {
            tail.next = null;
        }
        else {
            tail.next = new ListNode(1);
        }
        return dummy.next;
    }

 

链表求和 II

假定用一个链表表示两个数，其中每个节点仅包含一个数字。假设这两个数的数字顺序排列，请设计一种方法将两个数相加，并将其结果表现为链表的形式。

public ListNode addLists2(ListNode l1, ListNode l2) {
        // write your code here
        if (l1 == null) {
            return l2;
        }
        if (l2 == null) {
            return l1;
        }
        ListNode rl1 = reverseNode(l1);
        ListNode rl2 = reverseNode(l2);
        ListNode sumNode = addHelper(rl1, rl2);
        return reverseNode(sumNode);
    }  
    public ListNode reverseNode(ListNode head) {
        ListNode prev = null;
        while (head != null) {
            ListNode tmp = head.next;
            head.next = prev;
            prev = head;
            head = tmp;
        }
        return prev;
    }
    public ListNode addHelper(ListNode l1, ListNode l2) {
         int flag =0;
         ListNode dummy = new ListNode(0);
         ListNode tail = dummy;
         while (l1 != null && l2 != null) {
             int sum = l1.val + l2.val + flag;
             flag = sum / 10;
             tail.next = new ListNode(sum % 10);
             tail = tail.next;
             l1 = l1.next;
             l2 = l2.next;
         }
         while (l1 != null) {
             int sum = l1.val + flag;
             flag = sum / 10;
             tail.next = new ListNode(sum % 10);
             tail = tail.next;
             l1 = l1.next;
         }
         while (l2 != null) {
             int sum = l2.val + flag;
             flag = sum / 10;
             tail.next = new ListNode(sum % 10);
             tail = tail.next;
             l2 = l2.next;
         }
         if (flag != 0) {
             tail.next = new ListNode(1);
         }
         return dummy.next;
    }

 

链表倒数第n个节点

找到单链表倒数第n个节点，保证链表中节点的最少数量为n。

方法一：

找到单链表倒数第n个节点，保证链表中节点的最少数量为n。

方法二：

ListNode nthToLast(ListNode head, int n) {
        // write your code here
        if (head == null || head.next == null) {
            return head;
        }
        ListNode curt = head;
        for (int i = 0; i < n; i++) {
            curt = curt.next;
        }
        ListNode res = head;
        while (curt != null) {
            curt = curt.next;
            res = res.next;
        }
        return res;
    }