[每日两题系列]刷算法题咯~~

        本系列所选题目均来自力扣或者牛客网站. 所选题目主要是以其中的简单题为主, 中等题为辅, 包含少数困难题(原因是: 本人目前能力还不够~ ). 开展这个系列的目的是督促自己, 在暑假的时间里也要保持有一定的刷题量, 拒绝摆烂~
        话不多说, 直接开刷~~

排序链表

        题目描述: 给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
        要求在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序.

解题思路:
        (1) 排序链表, 实际上就是考查我们的排序算法, 只是套上了链表而已, 主要思想还是排序. 但是题目中又要求我们时间复杂度只能在 O(n logn) 范围之内, 所以在使用排序算法的时候, 就要考虑在最坏情况下最多也只能是 O(n logn) , 这时候就只剩下归并排序的算法了.
        (2) 由于使用归并排序是需要知道所排元素的头, 中, 尾元素, 所以, 该题默认提供的方法就不满足我们的需求了, 我们就可以直接将其转移到一个能带有两个参数的方法中(且这两个参数分别代表头尾节点), 这时候其实就可以把这个方法与原本提供的方法构成重载即可.
        (3) 之后下面代码的基本思路就和归并算法的思路一样了, 换成链表即可. 唯一要注意的是, 由于这里是链表, 所以找中间元素的时候, 就不像之前的数组找中间元素一样了, 这里找中间就需要使用前后指针来对链表进行遍历(这一点在之前是讲过的), 前指针每次走两步, 后指针每次走一步, 前指针走完的时候, 后指针所指的节点就是中间元素了.

实现代码:

class Solution {
    public ListNode sortList(ListNode head) {
        return sortList(head,null);
    }

    public ListNode sortList(ListNode head, ListNode tail) {
        if(head==null){
            return null;
        }
        if(head.next==tail){
            head.next=null;
            return head;
        }
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=tail&&fast.next!=tail){
            fast=fast.next.next;
            slow=slow.next;
        }
        ListNode mid=slow;
        ListNode list1=sortList(head,mid);
        ListNode list2=sortList(mid,tail);
        ListNode sorted=merge(list1,list2);
        return sorted;
    }

    public ListNode merge(ListNode head1, ListNode head2) {
        ListNode dummyHead=new ListNode(0);
        ListNode tmp=dummyHead;
        ListNode tmp1=head1;
        ListNode tmp2=head2;
        while(tmp1!=null&&tmp2!=null){
            if(tmp1.val<=tmp2.val){
                tmp.next=tmp1;
                tmp1=tmp1.next;
            }else{
                tmp.next=tmp2;
                tmp2=tmp2.next;
            }
            tmp=tmp.next;
        }
        if(tmp1!=null){
            tmp.next=tmp1;
        }else{
            tmp.next=tmp2;
        }return dummyHead.next;
    }
}

奇偶链表

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

解题思路:
        (1) 如若链表中没有节点, 则直接返回空; 如若链表中只有一个节点, 直接返回这个节点即可.
        (2) 由于是要分离奇偶节点, 所以我们可以定义两个新的链表头节点, 一个来存奇数节点, 一个来存偶数节点, 最后再将偶数节点组成的链表拼接到奇数节点组成的链表后面去即可.
        (3) 具体实现过程是有两个指针相互交替获取各自的下一个节点拼到另一个指针后面, 直到将链表遍历完为止.

实现代码:

class Solution {
    public ListNode oddEvenList(ListNode head) {
        if(head==null){
            return null;
        }
        if(head.next==null){
            return head;
        }
        ListNode curbs=head;
        ListNode as=head.next;
        ListNode curas=as;
        while(curas!=null&&curas.next!=null){
            curbs.next=curas.next;
            curbs=curbs.next;
            curas.next=curbs.next;
            curas=curas.next;
        }
        curbs.next=as;
        return head;
    }
}