41.日常算法

1.面试题 02.04. 分割链表

题目来源
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。你不需要 保留 每个分区中各节点的初始相对位置。

示例 1：
输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]

方法一——模拟

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        if (head == nullptr) return nullptr;
        ListNode* minx = new ListNode;
        ListNode* maxx = new ListNode;
        ListNode* cur = head;
        ListNode* curmin = minx;
        ListNode* curmax = maxx;
        while (cur){
            if (cur->val < x){
                curmin->next = cur;
                curmin = curmin->next;
            }else{
                curmax->next = cur;
                curmax = curmax->next;
            }
            cur = cur->next;
        }
        curmin->next = nullptr;
        curmax->next = nullptr;

        curmin->next = maxx->next;
        return minx->next;

    }
};

方法二——双指针+交换

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode* left = head;
        ListNode* right = head;
        while (right){
            if (right->val < x){
                std::swap(left->val, right->val);
                left = left->next;
            }
            right = right->next;
        }
        return head;
    }
};

2.将有序数组转换为二叉搜索树

题目来源
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡 二叉搜索树。

示例 1：
输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode * createBTree(TreeNode *&root, vector<int>& nums, int left, int right){
        if (left > right) return nullptr;
        int mid = (right - left) / 2 + left;
        root = new TreeNode(nums[mid]);
        root->left = createBTree(root->left, nums, left, mid - 1);
        root->right = createBTree(root->right, nums, mid + 1, right);
        return root;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode* root = nullptr;
        createBTree(root, nums, 0, nums.size() - 1);
        return root;
    }
};