数据结构之链表面试题汇总（四）得到两个单链表相交的第一个交点、用O（1）的时间效率删除单向链表中的指定节点

date: 2016-08-18 9:15:00
title: 数据结构之链表面试题汇总（四）得到两个单链表相交的第一个交点、用O（1）的时间效率删除单向链表中的指定节点
categories: 数据结构

版权声明：本站采用开放的[知识共享署名-非商业性使用-相同方式共享 许可协议]进行许可

所有文章出现的代码，将会出现在我的github中，名字可以根据类全名来找，我在github中的文件夹也会加目录备注。

---

得到两个单链表相交的第一个交点

思路：

• 要得到两个单链表相交的第一个交点，首先得判断这两个单链表有没有相交
• 而判断两个单链表是否相交，就要判断两个单链表的最后一个节点是否电箱
• 只有两个链表的最后一个节点相等，两个链表才可能相交。
• 同时还需要考虑两个单链表长度的问题，既然两个链表相交是相交之后那部分的节点一样，那么我们可以把较长链表前面那部分截成跟较短链表长度一样，然后再找相交节点

图解：

代码实现：

public class FirstIntersectNode {
    public static Node getFirstIntersectNode(Node head1, Node head2) {
        // judge head1 and head2 wether is null,if true return null
        if (head1 == null || head2 == null)
            return null;
        // use 2 variables to record their length
        int length1 = 0;
        int length2 = 0;
        // compare them move longer one to the equal length
        Node current1 = head1;
        Node current2 = head2;
        Node last1 = head1;
        Node last2 = head2;

        // get these lists's length and the tail node
        while (last1.getNext() != null) {
            length1++;
            last1 = last1.getNext();
        }

        while (last2.getNext() != null) {
            length2++;
            last2 = last2.getNext();
        }

        // if their last node unequal that they have no intersection
        if (last1 != last2) {
            return null;
        }

        // set their length to equal
        if (length1 > length2) {
            int k = length1 - length2;
            while (k != 0) {
                current1.getNext();
                k--;
            }
        } else {
            int k = length2 - length1;
            while (k != 0) {
                current2.getNext();
                k--;
            }
        }
        // while the current node is not the last node
        while (current1 != null) {
            // move these pointers together backward in one step
            current1 = current1.getNext();
            current2 = current2.getNext();
            if (current1 == current2) {
                // compare the two current node if equal return node
                return current1;
            }
        }

        return null;

    }

}

测试代码:

public class ReverseLinkedListTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);

        Node list1 = new Node(23);
        Node list2 = new Node(23);
        Node list3 = new Node(2);
        Node list4 = node4;
        Node list5 = node5;
        list1.setNext(list2);
        list2.setNext(list3);
        list3.setNext(list4);
        list4.setNext(list5);

        System.out.println(FirstIntersectNode.getFirstIntersectNode(node1,
                list1).getRecord());
    }

}

运行结果：

测试代码:不相交的两条链表

public class ReverseLinkedListTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);

        Node list1 = new Node(23);
        Node list2 = new Node(23);
        Node list3 = new Node(2);
        Node list4 = new Node(2);
        Node list5 = new Node(2);
        list1.setNext(list2);
        list2.setNext(list3);
        list3.setNext(list4);
        list4.setNext(list5);

        System.out.println(FirstIntersectNode.getFirstIntersectNode(node1,
                list1).getRecord());
    }

}

运行结果：

用O（1）的时间效率删除单向链表中的指定节点

思路：

• 用O（1）的时间效率删除单向链表中指定节点，猛然一看好像不可能，因为单向链表是线性的，既然要删除指定的节点，必须要对整个链表进行遍历。

• 再仔细想想，好像也不一定需要遍历整条链表，有没有考虑过需要遍历整条链表的情况？那是最坏的情况吧？即要删除的节点在指定链表的最后一个节点，这时就需要遍历整条链表，得到最后一个节点的前一个节点，然后设置前一个节点的后面节点为空

• 可是整条链表前n-1个元素，都可以直接通过设置当前节点的值和指向下一个节点的引用，即通过把下一个节点的值赋给当前节点的值，把下一个节点的下一个节点的指向，赋给当前节点的下一个节点指向即可

• 这样删除的时间复杂度为 前n-1个元素为O（1），最后一个为O（n) 但是总的来说 (n-1)*O(1)+O(n)]/n=O(1)

图解：

代码实现：

public class O1DeleteNode {

    public static void deleteNode(Node head, Node targetNode) {
        // judge head and tnode if they are null throw ex
        if (head == null || targetNode == null)
            throw new RuntimeException("the head or tnode is null");
        // judge tnode is the last node get the front node and set its next null
        if (targetNode.getNext() == null) {
            Node current = head;
            while (current.getNext() != targetNode) {
                current = current.getNext();
            }
            current.setNext(null);
        } else {
            // else directely assign the next value to tnode and next to tnode
            targetNode.setRecord(targetNode.getNext().getRecord());
            targetNode.setNext(targetNode.getNext().getNext());
        }
    }
}

测试代码：情况一：非末尾节点:

public class ReverseLinkedListTest {

    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);

        RecustionAllElementOfLinkedList.printAllElements(node1);
        System.out.println("----------------------------------------------");
        O1DeleteNode.deleteNode(node1, node4);
        System.out.println("----------------------------------------------");
        RecustionAllElementOfLinkedList.printAllElements(node1);
    }

}

运行结果：

测试代码：情况二：删除末尾节点：

public class ReverseLinkedListTest {

    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);

        RecustionAllElementOfLinkedList.printAllElements(node1);
        System.out.println("----------------------------------------------");
        O1DeleteNode.deleteNode(node1, node5);
        System.out.println("----------------------------------------------");
        RecustionAllElementOfLinkedList.printAllElements(node1);
    }

}

运行结果:

链表部分已完结，如果遇到新的，会持续更新……

参考资料：

归并排序–维基百科

程序员实用算法—Andrew Binstock / John Rex 机械工业出版 第二章第一节 链表 下载地址

使用递归和非递归方式反转单向链表

Java反转单链表实战

看图理解单链表的反转

剑指offer面试题13——在O（1）删除链表节点

时间复杂度分别为 O（n）和 O（1）的删除单链表结点的方法

链表面试题Java实现【重要】

算法大全（1）单链表

面试大总结之一：Java搞定面试中的链表题目

---