leetcode—6/19

1. 重排链表

给定一个单链表L: L₀ -> L₁ ->…-> L_n-1 -> L_n
将其重新排列后变为：L₀ -> L_n-> L₁ -> L_n-1-> L₂ -> L_n-2->…
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换

思路：使用双指针将整个链表分成两段，将后半段链表倒序并插入到前半段链表中

void reorderList(ListNode* head) {
        ListNode* slow = head;
        ListNode* fast = head;
        ListNode* pre = nullptr;
        //没有，只有一个，两个节点，则返回原链表
        if(head == nullptr)
        {
            return;
        }
        while(fast && fast -> next)
        {
            pre = slow;
            slow = slow -> next;
            fast = fast -> next -> next;
        }
        if(fast)
        {
            pre = slow;
            slow = slow -> next;
        }
        fast = head;
        pre -> next = nullptr;
        //slow指向即将要翻转的后半段链表的头节点
        ListNode* cur = slow;
        pre = nullptr;
        ListNode* temp;
        while(cur)
        {
            temp = cur -> next;
            cur -> next = pre;
            pre = cur;
            cur = temp;
        }
        //pre指向翻转后的后半段链表的头节点
        //将后半段插入前半段中
        while(fast && pre)
        {
            temp = fast -> next;
            fast -> next = pre;
            pre = pre -> next;
            fast -> next -> next = temp;
            fast = temp;
        }
    }

2. 二叉树的前序遍历

给定一个二叉树，返回它的前序遍历

• 递归

void preorder(TreeNode* root, vector<int>& res)
    {
        if(root == nullptr)
        {
            return;
        }
        res.push_back(root -> val);
        preorder(root -> left, res);
        preorder(root -> right, res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        preorder(root, res);
        return res;
    }

• 非递归

void preorder(TreeNode* root, vector<int>& res)
    {
        if(root == nullptr)
        {
            return;
        }
        stack<TreeNode*> s;
        s.push(root);
                
        while(!s.empty())
        {
            TreeNode* node = s.top();
            s.pop();
            res.push_back(node -> val);
            if(node -> right)
            {
                s.push(node -> right);
            }
            if(node -> left)
            {
                s.push(node -> left);
            }
        }
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        preorder(root, res);
        return res;
    }