基础链表问题练习2

Posted 小智RE0

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了基础链表问题练习2相关的知识,希望对你有一定的参考价值。

文章目录


1 LC:86. 分隔链表

原题位置:86. 分隔链表

给你一个链表的头节点 head 和一个特定值 x ,请你对链表进行分隔,
使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。

你应当 保留 两个分区中每个节点的初始相对位置。

提示:
链表中节点的数目在范围 [0, 200]-100 <= Node.val <= 100
-200 <= x <= 200

类似于快排的思路,小于x的节点拼接到一块;大于等于x的节点拼接到一块;
然后最终再把两条链表拼接;

class Solution 
    public ListNode partition(ListNode head, int x) 
        if(head == null) return null;

        //按照题目的要求实际就像快排,大的放一堆,小的放一堆;
        ListNode small = new ListNode(0);
        ListNode big = new ListNode(0);
        ListNode smallHead = small;
        ListNode bigHead = big;

        while(head!=null)
            //若当前的节点较小,就往小堆拼;
            if(head.val < x)
                smallHead.next = head;
                smallHead = smallHead.next;
            else
                bigHead.next = head;
                bigHead = bigHead.next;
            
            head = head.next;
        
        //最终拼到一块;
        bigHead.next = null;
        smallHead.next = big.next;

        return small.next;
    


2 LC:206. 反转链表 [简单]

原题位置:206. 反转链表

给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。

示例 3:
输入:head = []
输出:[]
 
提示:
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

非常简单的反转链表思路;先构建一个空节点,依次将链表的节点挂接到后面即可;

class Solution 
    public ListNode reverseList(ListNode head) 
        //简易反转;
        ListNode preNode = null;
        while(head!=null)
            ListNode tempNode = head.next;
            head.next = preNode;
            preNode = head;
            head = tempNode;
        
        return preNode;
    


3 LC:92. 反转链表 II [中等]

原题位置:92. 反转链表 II

给你单链表的头指针 head 和两个整数 left 和 right ,其中 left <= right 。
请你反转从位置 left 到位置 right 的链表节点,返回 反转后的链表 。

提示:
链表中节点数目为 n
1 <= n <= 500
-500 <= Node.val <= 500
1 <= left <= right <= n

这里处理的话,相对于麻烦一点,因为他要对一段指定区间的节点进行反转处理;
那么就先找到待反转节点的前置节点;然后进行区间内的反转;

class Solution 
    public ListNode reverseBetween(ListNode head, int left, int right) 
        if(head==null||head.next==null)
            return head;
        
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode preNode = dummy;
        //将前置指针放到待反转节点的前一个位置;
        for(int i =0;i<left-1;i++)
            preNode = preNode.next;
        
        //标记待反转的第一个节点;
        ListNode curNode = preNode.next;
        //反转时的临时节点;
        ListNode tempNode;
        for(int i =0;i<right-left;i++)
            tempNode = curNode.next;
            //当前节点接到隔着的那个节点上;
            curNode.next = tempNode.next;
            //临时节点接到当前节点前;
            tempNode.next = preNode.next;
            //将临时节点的位置确认到前置节点后;
            preNode.next = tempNode;
        
        return dummy.next;
    


4 LC:109. 有序链表转换二叉搜索树

原题位置:109. 有序链表转换二叉搜索树

给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。
本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:
给定的有序链表: [-10, -3, 0, 5, 9],
一个可能的答案是:[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树:

      0
     / \\
   -3   9
   /   /
 -10  5

这里使用递归思路容易理解;
快慢指针找到链表的中心节点,作为根结点;
由于这份链表正好是升序排序的,那么左右分离;递归左右子树即可;

class Solution 
    public TreeNode sortedListToBST(ListNode head) 
        //排除特殊用例;
        if(head==null) return null;
        if(head.next == null) return new TreeNode(head.val);
        //快慢指针做法;
        ListNode fast = head;
        ListNode slow = head;
        //用于分隔链表;
        ListNode prefix = null;
        while(fast!=null && fast.next!=null)
            fast = fast.next.next;
            prefix = slow;
            slow = slow.next;
        
        //这里慢指针就是当前根结点;
        TreeNode root = new TreeNode(slow.val);
        //递归出右子树;
        root.right = sortedListToBST(slow.next);
        //此时分隔链表;
        prefix.next = null;
        //递归出左子树;
        root.left = sortedListToBST(head);
        return root; 
    


5 LC:143. 重排链表

原题位置:143. 重排链表

给定一个单链表 L 的头节点 head ,单链表 L表示为:
L0 → L1 → … → Ln - 1 → Ln
请将其重新排列后变为:
L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
提示:
- 链表的长度范围为 [1, 5 * 104]
- 1 <= node.val <= 1000


处理比较简单,先用快慢指针将链表分开,然后将后半部分的链表反转处理;

然后将后半部分链表逐个插入到前面的链表中;

class Solution 
    public void reorderList(ListNode head) 
        //排除特殊用例;
        if(head == null||head.next==null)
            return;
        
        ListNode fast = head;
        ListNode slow = head;
        while(fast!=null && fast.next!=null)
            fast = fast.next.next;
            slow = slow.next;
        
        //分隔链表;
        ListNode twoHead = slow.next;
        slow.next = null;
        //对于第二段链表进行反转处理;
        fast = reverseList(twoHead);
        //慢指针重置;
        slow = head;
        //将第二份链表插入到前面的链表中;
        while(fast!=null)
            ListNode temp = fast.next;
            fast.next = slow.next;
            slow.next = fast;
            //快慢指针向后取值;
            slow = fast.next;
            fast = temp;
        
    

    //反转链表;
    public ListNode reverseList(ListNode node)
        ListNode dummy = null;
        while(node!=null)
            ListNode temp = node.next;
            node.next = dummy;
            dummy = node;
            node = temp;
        
        return dummy;
    


6 LC:147. 对链表进行插入排序

147. 对链表进行插入排序

给定单个链表的头 head ,使用 插入排序 对链表进行排序,并返回 排序后链表的头 。
插入排序 算法的步骤:

插入排序是迭代的,每次只移动一个元素,直到所有元素可以形成一个有序的输出列表。
每次迭代中,插入排序只从输入数据中移除一个待排序的元素,找到它在序列中适当的位置,并将其插入。
重复直到所有输入数据插入完为止。
下面是插入排序算法的一个图形示例。部分排序的列表(黑色)最初只包含列表中的第一个元素。
每次迭代时,从输入数据中删除一个元素(红色),并就地插入已排序的列表中。
对链表进行插入排序。

提示:
列表中的节点数在 [1, 5000]范围内
-5000 <= Node.val <= 5000

class Solution 
    public ListNode insertionSortList(ListNode head) 
        //排除特例;
        if(head == null || head.next==null)
            return head;
        
        ListNode dummy = new ListNode(0);
        ListNode curNode = head;
        while(curNode!=null)
            //先标记存储后一位节点,便于后续使用;
            ListNode tempNode = curNode.next;
            //前置节点,每次都重置;
            ListNode preNode = dummy;
            while(preNode.next!=null && preNode.next.val<curNode.val)
                preNode = preNode.next;
            
            //链接;
            curNode.next = preNode.next;
            preNode.next = curNode;
            //向后移动;
            curNode = tempNode;
        
        return dummy.next;
    


7 LC:148. 排序链表

原题位置:148. 排序链表

给你链表的头结点 head ,请将其按 升序 排列并返回 排序后的链表 。
提示:
链表中节点的数目在范围 [0, 5 * 104]-10^5 <= Node.val <= 10^5

比较容易理解的递归思路;
分隔链表后,再归并到一份链表中;

class Solution 
    public ListNode sortList(ListNode head) 
        //特例排除;
        if(head == null || head.next==null)
            return head;
        
        //使用快慢指针,找到链表的中点;
        ListNode fast = head;
        ListNode slow = head;
        while(fast.next != null && fast.next.next != null)
            slow = slow.next;
            fast = fast.next.next;
        
        //此时准备分隔链表;
        ListNode twoHead = slow.next;
        slow.next = null;
        //采用递归的方式对两段链表处理;
        ListNode oneList = sortList(head);
        ListNode twoList = sortList(twoHead);
        //合并处理;
        return merge(oneList,twoList);
    
    
    //合并两段链表;
    public ListNode merge(ListNode l1,ListNode l2)
        if(l1 == null)
            return l2;
        
        if(l2 == null)
            return l1;
        
        //采用第三方链表做法;
        ListNode res = new ListNode(0);
        ListNode curNode = res;
        while(l1!=null && l2!=null)
            if(l1.val<=l2.val)
                curNode.next = l1;
                l1 = l1.next;
            else
                curNode.next = l2;
                l2 = l2.next;
            
            curNode = curNode.next;
        
        //注意可能有链表没结束;
        if(l1!=null)
            curNode.next = l1;
        
        if(l2!=null)
            curNode.next = l2;
        
        return res.next;
    


8 LC:203. 移除链表元素

原题位置:203. 移除链表元素

给你一个链表的头节点 head 和一个整数 val ,
请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。
提示:
列表中的节点数目在范围 [0, 104]1 <= Node.val <= 50
0 <= val <= 50


递归思路移出

class Solution 
    public ListNode removeElements(ListNode head, int val) 
        //排除特例;
        if(head == null)
            return null;
        
        head.next = removeElements(head.next,val);
        //若相等,则返回后一个结点即可;
        if(head.val == val)
            return head.next;
        else
            return head;
        
    

非递归方式,需要遍历链表,找到匹配的目标节点;脱离链表即可;

class Solution 
    public ListNode removeElements(ListNode head, int val) 
        //排除特例;
        if(head == null)
            return null;
        
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode curNode = dummy;
        //注意,最后还要返回新的头结点,
        while(curNode.next!=null)
            //匹配目标值;
            if(curNode.next.val == val)
                ListNode delNode = curNode.next;
                curNode.next = delNode.next;
                delNode.next = null;
            else
                curNode = curNode.next;
            
        
        return dummy.next;
    


9 LC:234. 回文链表

原题位置:234. 回文链表

给你一个单链表的头节点 head ,请你判断该链表是否为回文链表。
如果是,返回 true ;否则,返回 false 。
提示:

链表中节点数目在范围[1, 105]0 <= Node.val <= 9

具体思路,找到链表中心点;
注意区分链表长度为奇数个时,需要将中间的一个节点分到左边;
然后主要是将右半部分链表的节点进行反转;用两个指针;
依次比较左边和右边链表的节点值是否相等;达到判断回文链表的效果;

class Solution 
    public boolean isPalindrome(ListNode head) 
        //使用快慢指针;找到中心;
        ListNode fast = head;
        ListNode slow = head;
        while(fast!=null && fast.next!=null)
            fast = fast.next.next;
            slow = slow.next;
        
        ListNode twoHead = slow;
        //若为奇数长度,则将中心点放到左边的链表中,仅反转右边的链表;
        if(fast!=null)
            twoHead = slow.next;
        
        //反转后半部分链表;
        fast = reverse(twoHead);
        //重置慢指针;
        slow = head;
        while(fast!=null)
            if(fast.val!=slow.val)
                return false;
            
            fast = fast.next;
            slow = slow.next;
        
        return true;
    
    //反转链表;
    public ListNode reverse(ListNode node)
        ListNode preNode =null;
        while(node!=null)
            ListNode tempNode = node.next;
            node.next = preNode;
            preNode = node;
            node = tempNode;
        
        return preNode;
    


附:原地删除链表的指定的节点;
注意:无法访问链表的头结点
原题位置: 237. 删除链表中的节点

找到指定删除节点的后一个结点,然后将需要删除节点的值value覆盖,那么删除后面这个结点即可;

class Solution 
    public void deleteNode(ListNode node) 
        //要删除当前节点,就把后一个结点的值覆盖到这里;
        ListNode subNode = node.next;
        node.val = subNode.val;
        //把下个节点的后继节点接过来;
        node.next = subNode.next;
        //删除自己;
        subNode.next = null;
    


10 LC: 328. 奇偶链表

原题位置: 328. 奇偶链表

给定单链表的头节点 head ,将所有索引为奇数的节点和索引为偶数的节点分别组合在一起,
然后返回重新排序的列表。
第一个节点的索引被认为是 奇数 , 第二个节点的索引为 偶数 ,以此类推。
请注意,偶数组和奇数组内部的相对顺序应该与输入时保持一致。
你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。
提示:
n ==  链表中的节点数
0 <= n <= 10^4
-10^6 <= Node.val <= 10^6

和86题的思路很相似;分成两部分链表进行拼接;
注意奇偶索引可以用一个标志数进行判断;

class Solution 
    public ListNode oddEvenList(ListNode head) 
        //采用分隔链表的思路;
        ListNode oddDummy  = new ListNode(0);
        ListNode evenDummy = new ListNode(0);
        //分别的操作节点;
        ListNode oddHead  = oddDummy;
        ListNode evenHead = evenDummy;
        //一个计数标志,简易区分奇偶索引;
        int num=1;
        while(head!=null)
            //偶数处理;
            if(num%2 == 0)
                evenHead.next = head;
                evenHead = evenHead.next;
            else
                oddHead.next = head;
                oddHead = oddHead.next;
            
            num +=1;
            head = head.next;
        
        //这里注意要对两段链表拼接;
        oddHead.next = evenDummy.next;
        evenHead.next = null;
        return oddDummy.next;
    


11 LC:4

以上是关于基础链表问题练习2的主要内容,如果未能解决你的问题,请参考以下文章

二叉树基础练习

基础链表问题练习1

数据结构二叉树基础oj练习2(源码+算法思路)

基础练习区间DPcodevs1090 加分二叉树题解

日常学习随笔-用链表的形式实现普通二叉树的新增查找遍历(前中后序)等基础功能(侧重源码+说明)

数据结构二叉树的基础操作( 1.创建二叉树2.先序遍历3.中序排序4.后序遍历 5.层序遍历6. 统计节点的数目 7.交换左右子树 8.计算并输出该二叉树的深度)