CodeTop每日系列三题------------------2021.12.13

LC剑指 Offer 62. 圆圈中最后剩下的数字
//2021秋招cvte笔试题当时没有做出来，是一道很经典的约瑟夫环题目dp。明确dp的含义就是当前状态转移方程要求的是需要删除的下标位置，初始化dp[n]数组那么当数字长度为1的时候仍然是0，所以dp[0] = 0,要求dp[n - 1]。并且题目满足递推关系所以可以采取变量的形式降低空间复杂度

class Solution {
    public int lastRemaining(int n, int m) {
        //dp[0]表示当前要删除的下标。
        //当数字长度为1的时候永远是0所以初始化dp[0] = 0;
        //因为满足递推关系，所以采取变量操作降低空间复杂度
        int x = 0;
        //数字长度从2 开始进行遍历，并且数字长度为n - 1
        for(int i = 2;i <= n;i++){
            //当前删除的下标位置递推下一个要删除的位置
            x = (x + m) % i;
            //加上需要移动的距离并且求模上当前数字长度就能求出下一个删除的下标
            //dp[i] = (dp[i - 1] + m) % i;
        }
        //最终返回递推出来的下标位置即可
        return x;
    }
}

LC225. 用队列实现栈
//本题目和用栈实现队列有点类似其实也是采取两个队列，一个作为辅助另一个队列则是专门"栈"，辅助队列压进元素之后将栈队列不为空全部放入辅助队列，最终将辅助队列和栈队列置换那么栈队列出来的就是完整的出栈顺序。

class MyStack {
    //作为queue1作为栈
    private Queue<Integer> queue1;
    //queue2作为辅助队列负责进行暂时存放并且交换
    private Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList();
        queue2 = new LinkedList();
    }
    
    public void push(int x) {
        queue2.offer(x);
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
        Queue<Integer> temp = queue1;
        //交换queue2当中的值到queue1当中
        queue1 = queue2;
        //将queue1此时为空放到queue2
        queue2 = temp;
    }
    
    public int pop() {
        return queue1.poll();
    }
    
    public int top() {
        return queue1.peek();
    }
    
    public boolean empty() {
        return queue1.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

328. 奇偶链表
//将链表分离并且合并操作，定义一个偶数链表的头节点，然后定义两个指针一个奇数指针一个偶数指针，当且仅当如果偶数不为空并且偶数next不为空进行遍历

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode oddEvenList(ListNode head) {
        if (head == null) {
            return head;
        }
        //定义一个偶数头节点，将链表分离
        ListNode evenHead = head.next;
        //一个奇数指针，一个偶数指针
        ListNode odd = head, even = evenHead;
        while (even != null && even.next != null) {
        //通过迭代先更新奇数在更新偶数节点
            //奇数下一个节点就是偶数的后一个节点
            odd.next = even.next;
            //然后移动奇数指针
            odd = odd.next;
            //同理偶数的下一个节点就是奇数的后一个节点
            even.next = odd.next;
            //然后移动偶数指针
            even = even.next;
        }
        //结束遍历以后再合并链表，在奇数后面合并偶数链表
        odd.next = evenHead;
        return head;
    }
}