十大链表金典笔试题

目录

一,Leedcode面试题0205链表求和

二,Leedcode19删除链表的倒数第N个结点

三,Leedcode21合并两个有序链表

四,Leedcode82删除排序链表中的重复元素

五,Leedcode92反转链表

六,Leedcode141环形链表

七,Leedcode160相交链表

八,Leedcode234回文链表

九,Leetcode26原地删除数组中的重复项

十,面试题0204分割链表

十一,Leetcode206反转链表


一,Leedcode面试题0205链表求和

  //方法2:递归
    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //递归终止条件
        if (l2 == null){
            return l1;
        }
        if (l1 == null){
            return l2;
        }
        ListNode h1 = l1;
        ListNode h2 = l2;
        //我只知道当前两个链表d额头节点的和,剩下的我不知道,交给add方法
        //如果有节点为空,并且temp== 0,直接返回还有节点的链表
        int temp = (h1.val + h2.val ) > 9 ? 1 : 0;
        if (temp == 0){
            h1.val = (h1.val + h2.val );
        }else {//temp = 1;
            h1.val = ((h1.val + h2.val) % 10);
            h1.next = addIsOverTen(h1.next,temp);
        }
        h1.next = addTwoNumbers(h1.next,h2.next);
        return h1;
    }

    //方法1:开辟新空间
    public static ListNode addTwoNumbers1(ListNode l1, ListNode l2) {

        //方法1:创建一个新链表
        ListNode dummy = new ListNode();
        ListNode dummyHead = dummy;
        if (l1 == null){
            return l2;
        }
        if (l2 == null){
            return l1;
        }

        ListNode h1 = l1;
        ListNode h2 = l2;
        int temp = 0;
        while (h1 != null && h2 != null){
            int sum = h1.val + h2.val + temp;
            if (sum > 9){
                temp = 1;
            }else {
                temp = 0;
            }
            dummy.next = new ListNode(sum % 10);
            h1 = h1.next;
            h2 = h2.next;
            dummy = dummy.next;
        }
        //如果有节点为空,并且temp== 0,直接返回还有节点的链表
        if (temp == 0){
            dummy.next = h1 == null ? h2 : h1;
        }else {//temp = 1;
            //判断那个节点为空
            if (h1 == null && h2 == null){
                dummy.next = new ListNode(1);
            }else if (h1 == null){
                dummy.next = addIsOverTen(h2,temp);
            }else {
                dummy.next = addIsOverTen(h1,temp);
            }
        }
        return dummyHead.next;
    }
    public static ListNode addIsOverTen(ListNode head,int temp){
        if (head == null){
            return new ListNode(temp);
        }
        ListNode cur = head;
        if ((cur.val + temp) > 9){
            cur.val = 0;
            temp = 1;
            if (cur.next == null){
                cur.next = new ListNode(1);
            }else {
                addIsOverTen(cur.next,temp);
            }
        }else {
            cur.val += 1;
        }
        return head;
    }

二,Leedcode19删除链表的倒数第N个结点

public ListNode removeNthFromEnd(ListNode head, int n) {
        int len = 1;
        ListNode node = head;
        int count = 1;
        while(node.next != null){
            len++;
            node = node.next;
        }
        node = head;
        if(len == n){
            head = head.next;
            return head;
        }
        while(count < len-n){
            node = node.next;
            count++;
        }
        node.next = node.next.next;
        return head;
    }

三,Leedcode21合并两个有序链表

 //方法1
    public ListNode mergeTwoLists1(ListNode list1, ListNode list2) {
        //虚拟头节点
        ListNode head = new ListNode();
        ListNode cur = head;
        while (list1 != null && list2 != null){
            if (list1.val <= list2.val){
                cur.next = list1;
                cur = list1;
                list1 = list1.next;
            }else {
                cur.next = list2;
                cur = list2;
                list2 = list2.next;
            }
        }
        if (list1 == null){
            cur.next = list2;
        }
        if (list2 == null){
            cur.next = list1;
        }
        return head.next;
    }
    //方法2:递归
    /**
     * 传入两个链表list1和list2就能拼接成一个有序的单链表,返回头节点
     * @param list1
     * @param list2
     * @return
     */
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        //递归结束条件
        if (list1 == null){
            return list2;
        }
        if (list2 == null){
            return list1;
        }
        if (list1.val <= list2.val){
            list1.next = mergeTwoLists(list1.next,list2);
            return list1;
        }else {
            list2.next = mergeTwoLists(list1,list2.next);
            return list2;
        }
    }

四,Leedcode82删除排序链表中的重复元素

 //三指针法
    public static ListNode deleteDuplicates1(ListNode head) {
        //创建一个虚拟节点,防止头节点就是重复的节点,而导致头节点无法删除
        ListNode dummyHead = new ListNode();
        //创建一个prev节点用来遍历虚拟节点绑定的链表
        ListNode prev = dummyHead;
        //让虚拟节点的next指向链表的头节点
        dummyHead.next = head;
        //创建一个新的节点,用来指向虚拟节点的下一个节点
        ListNode cur = prev.next;
        //如果cur不为空,说明链表至少存在一个节点
        while (cur != null){
            //创建一个新的节点next,初识默认指向cur的next,next的作用是来用来判断cur和next是否为重复节点
            ListNode next = cur.next;
            //next=null,说明此时已经将整个链表遍历结束(链表只有一个元素),此时返回dummyHead.next;
            if (next == null){
                return dummyHead.next;
            }
            //走到这里说明此时链表的遍历没有到最后
            //如果cur和next节点的值相等,说明节点是重复的,此时所有需要删除节点,如果不相等,说明没有重复节点,三个指针同时向后移动,开始下一次while循环

            //如果不相等,执行if语句,说明此时节点不为重复节点
            if (cur.val != next.val){
                //将三个节点全部后移一位,这里只写prev后移和cur的后移,是应为next在进入while循环时,定义的就是cur的下一个节点,默认就相当于后移一位
                prev = prev.next;
                cur = cur.next;
            }else {
                //如果存在重复值,next一直后移,直到找到不重复的节点,找到next与cur不重复的节点以后,将prev.next = next;直接删除prev到next之间所有重复的节点
                //因为要执行next = next.next,所以在这里需要保证next不为空,否则会空指针异常
                while (next != null && cur.val == next.val){
                    next = next.next;
                }
                //走到这里说明此时next节点与cur不重复,让prev.next指向next,删除所有重复的节点,让cur=next,开始下一次循环时,cur = next ,next = cur.next;继续用来判断是否存在重复节点
                prev.next = next;
                cur = next;
            }
        }
        //走到这里说明此时已经遍历完成所有的节点,返回dummy.next;
        //因为dummyHead没有存储val,dummyhead.next指向head头节点,所以返回demmyHead.next;
        return dummyHead.next;
    }
    //递归解法

    /**
     * 方法语义:给你一个链表的头节点,你就可以删除链表中所有重复出现的所有节点
     * @param head
     * @return
     */
    //此方法不对,分析的思路不对
    public static ListNode deleteDuplicates2(ListNode head) {
        //1.终止条件
        //如果链表为空,或者链表中只有一个节点,肯定就不会存在重复节点
        if (head == null || head.next == null){
            return head;
        }
        //走到这里说明链表至少存在两个节点
        //需要创建一个虚拟节点用来删除头节点就是重复节点的情况
        ListNode dummyHead = new ListNode();
        dummyHead.next = head;
        //将头节点以后的节点传入具有删除重复节点的方法中,会返回一个新的节点
        ListNode newHead = deleteDuplicates(head.next);
        //判断newHead和head的是否重复
        if (head.val == newHead.val){
            //执行到此,说明节点head和剩余节点删除重复节点以后返回的新节点相等,说明head和newHead重复。
            //此时将dummyHead.next = newHead.next就会将head和newHead重复的节点全部删掉
            dummyHead.next = newHead.next;
        }else {
            //走到这里,说明head和newHead不重复,直接拼接
            head.next = newHead;
        }
        //拼接完成,返回dummyHead.next
        return dummyHead.next;
    }

    /**
     * 方法语义:给你一个链表的头节点,你就可以删除链表中所有重复出现的所有节点,返回一个新节点
     * @param head
     * @return
     */
    public static ListNode deleteDuplicates(ListNode head) {
        //终止条件
        if (head == null || head.next == null){
            return head;
        }
        //说明至少存在两个节点
        //判断两节点是否相等,如果不相等
        if (head.val != head.next.val){
            //如果不相等 ,  当前头节点直接拼接剩余节点删除重复节点的后返回的新节点头
            head.next = deleteDuplicates(head.next);
            return head;
        }else {
            //两节点重复
            ListNode node = head.next;
            while (node != null && node.val == head.val){
                node = node.next;
            }
            //如果重复,找到重复的节点以后,调用改方法,直接不和头节点拼接,直接返回,就会将重复的头节点一并删除掉
            return deleteDuplicates(node);
        }
    }

五,Leedcode92反转链表

ListNode successor;
    public ListNode reverseBetween(ListNode head, int left, int right) {
        if (left == 1){
            return reverseN(head,right);
        }
        head.next = reverseBetween(head.next,left-1,right-1);
        return head;
    }
    //反转前N个节点
    public ListNode reverseN(ListNode head,int n) {
        //如果n==1,则说明就反转一个节点,就等于不反转
        if (n == 1){
            successor = head.next;
            return head;
        }
        //n > 2
        ListNode temp = head.next;
        ListNode newHead = reverseN(head.next,n-1);
        temp.next = head;
        head.next = successor;
        return newHead;
    }



    /**
     * 给你单链表的头指针 head 和两个整数 left 和 right ,其中 left <= right 。
     * 就反转从位置 left 到位置 right 的链表节点,返回 反转后的链表 。
     *
     * 链表中节点数目为 n
     * 1 <= n <= 500
     * -500 <= Node.val <= 500
     * 1 <= left <= right <= n
     *
     * @param head
     * @param left
     * @param right
     * @return
     */
    public ListNode reverseBetween1(ListNode head, int left, int right) {
        //递归终止条件,如果head.next == null,直接返回
        if (head.next == null){
            return head;
        }
        ListNode cur = new ListNode();
        cur.next = head;
        ListNode before = cur;
        //否则找到需要   反转的节点的  前驱节点before;  假如left = 2,i = 0,i
        for (int i = 0; i < left - 1; i++) {
            before = before.next;
        }
        //找反转节点的开始节点
        ListNode leftNode = before.next;
        //然后将before指向空,避免环状链表。
        before.next = null;
        //找到需要反转的节点的末节点
        ListNode cur1 = new ListNode();
        cur1 = leftNode;
        for (int i = 0; i < right - left; i++) {
            cur1 = cur1.next;
        }
        ListNode end = new ListNode();

        //找到反转链表的尾节点
        ListNode rightNode = cur1;
        //记录要反转链表  尾节点的下一个节点end;
        end = rightNode.next;
        //将rightNode.next 质控,避免环形链表
        rightNode.next = null;


        //然后反转需要反转的部分链表
        ListNode reverseList = reverseList(leftNode);
        // 然后拼接前一半
        before.next = reverseList;

        //拼接后一半,后一半的节点的尾节点现在经过反转,leftNode成了reverseList的为节点
        leftNode.next = end;

        //     //返回结果
        return cur.next;
    }
    public ListNode reverseList(ListNode head) {
        //1递归终止条件
        if (head == null || head.next == null) {
            return head;
        }
        //保存第二个节点的地址
        ListNode temp = head.next;
        //将第二节点以后反转,得到新头节点
        ListNode node = reverseList(head.next);
        //让第二个节点的next指向head
        temp.next = head;
        //消除环
        head.next = null;
        //2得到剩余节点逆转后的链表,
        return node;
    }

六,Leedcode141环形链表

public boolean hasCycle1(ListNode head) {
        if (head == null || head.next == null){
            return false;
        }
        //方法1:快慢指针
        ListNode slow = head;
        ListNode fast = head.next;
        while (slow != fast){
            if (fast == null || fast.next == null){
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return true;
    }


    //方法1:set去重
    public boolean hasCycle(ListNode head) {
        Set set = new HashSet<>();
        int count = 0;
        while (head != null){
            if (set.contains(head)){
                return true;
            }
            set.add(head);
            head = head.next;
        }
        return false;
    }

七,Leedcode160相交链表

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode l1 = headA;
        ListNode l2 = headB;
        while(l1 != l2){
            l1 = l1 == null ? headB : l1.next;
            l2 = l2 == null ? headA : l2.next;
        }
        return l1;
    }

八,Leedcode234回文链表

//方法1:先全部反转,在全部比较
    public boolean isPalindrome1(ListNode head) {
        ListNode node = reverseList(head);
        while (head != null){
            if (head.val != node.val){
                return false;
            }
            node = node.next;
            head = head.next;
        }
        return true;
    }
    public ListNode reverseList1(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        //方法1.临时节点
        ListNode dummyHead = new ListNode();
        //链表的第一个节点已经在新链表中
        while (head != null){
            //开始执行新的链表
            ListNode node = new ListNode(head.val);
            node.next = dummyHead.next;
            dummyHead.next = node;
            head = head.next;
        }
        return dummyHead.next;
    }

    //方法2:先快慢指针,在逆转后一半链表
    public static boolean isPalindrome(ListNode head) {
        ListNode middleNode = middleNode(head);
        ListNode node = reverseList(middleNode);
        while (node != null){
            if (node.val != head.val){
                return  false;
            }
            head = head.next;
            node = node.next;
        }
        return true;
    }

    public static ListNode middleNode(ListNode head){
        ListNode frs = head,sec = head;
        while (sec != null && sec.next != null){
            frs = frs.next;
            sec = sec.next.next;
        }
        return frs;
    }

    public static ListNode reverseList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode node = head.next;
        ListNode newNode = reverseList(head.next);
        node.next = head;
        head.next = null;
        return newNode;
    }

九,Leetcode26原地删除数组中的重复项

 public static int removeDuplicates(int[] nums) {
        int left = 0,right = 0;
        while (right < nums.length){
            //如果左边等于不等于右边,左边++,右边++
            if (nums[left] != nums[right]){
                left++;
                nums[left] = nums[right];
            }
            right++;
        }
        return left+1;
    }
    public static int removeDuplicates1(int[] nums) {
        //单指针
        int left = 0,right = 0;
        for (int i = 1; i < nums.length; i++) {
            //如果相邻两元素相等
            if (nums[i] == nums[i-1]){
                continue;
            }else {
                left++;
                nums[left] = nums[i];
            }
        }
        return left+1;
    }

十,面试题0204分割链表

public ListNode partition(ListNode head, int x) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode smailHead = new ListNode();
        ListNode smailTail = smailHead;
        ListNode bigHead = new ListNode();
        ListNode bigTail = bigHead;

        while (head != null){
            if (head.val < x){
                smailTail.next = head;
                smailTail = head;
            }else {
                bigTail.next = head;
                bigTail = head;
            }
            head = head.next;
        }
        bigHead.next = null;
        smailTail.next = bigHead.next;
        return smailHead.next;
    }

十一,Leetcode206反转链表

 //方法1:临时节点
    public static ListNode reverseList2(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        //方法1.临时节点
        ListNode prev = new ListNode();
        //链表的第一个节点已经在新链表中
        prev.next = null;
        while (head != null){
            //开始执行新的链表
            ListNode temp = head.next;
            head.next = prev.next;
            prev.next = head;
            head = temp;
        }
        return prev.next;
    }
    //方法2:三指针
    public ListNode reverseList1(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode prev = new ListNode();
        ListNode sec = head;
        while (sec != null){
            ListNode temp = sec.next;
            sec.next = prev;
            prev = sec;
            sec = temp;
        }
        return prev;
    }
    //方法3:递归
    /**
     * 哥你一你个单链表,你就能将链表反转,并返回头节点
     * @param head
     * @return
     */
    public ListNode reverseList(ListNode head) {
        //1递归终止条件
        if (head == null || head.next == null) {
            return head;
        }
        //保存第二个节点的地址
        ListNode temp = head.next;
        //将第二节点以后反转,得到新头节点
        ListNode node = reverseList(head.next);
        //让第二个节点的next指向head
        temp.next = head;
        //消除环
        head.next = null;
        //2得到剩余节点逆转后的链表,
        return node;
    }

你可能感兴趣的:(数据结构,链表,数据结构,算法)