丑数、BST转换成循环链表、栈的压入和弹出、十进制转换成二进制

丑数

• 2, 3, 5三个数的倍数轮流放进DP数组, 谁小谁先放入
• 就好像三个人轮流根据已经铺路的位置向前铺路, 谁能铺的最近, 就先铺并往前一步移到下一个已经铺好的位置

class Solution {
public:
/*
    bool check_ugly(int n)
    {
        while(n != 1)
        {
            if(n % 2 == 0)
                n /= 2;
            else if(n % 3 == 0)
                n /= 3;
            else if(n % 5 == 0)
                n /= 5;
            else
                break;
        }
        return n == 1;
    }
    */
    int nthUglyNumber(int n) {
        int dp[n];
        dp[0] = 1;
        int a = 0, b = 0, c= 0;
        for(int i = 1; i < n; i++)
        {
            int n1 = dp[a] * 2;
            int n2 = dp[b] * 3;
            int n3 = dp[c] * 5;
            dp[i] = min(n1, min(n2, n3));
            // 只能是if, 因为有时候有公倍数, 都要更新
            if(dp[i] == n1) a++;
            if(dp[i] == n2) b++;
            if(dp[i] == n3) c++;
        }
        return dp[n-1];
    }
};

BST转换成循环链表

• 需要借助pre, cur, head三个指针, 而不是一个都不借用, 想着返回指针.
• 中序遍历从小到大输出.将cout<val 的位置替换成相关操作.

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
public:
    Node* head = NULL, *pre = NULL;
    void dfs(Node* cur)
    {
        if(cur == NULL) return ;
        // 左中右
        dfs(cur->left);
        if(pre != NULL) pre->right = cur;
        else head = cur;
        cur->left = pre;
        pre = cur;
        dfs(cur->right);
    }
    Node* treeToDoublyList(Node* root) {
        if(!root) return NULL;
        dfs(root);
        head->left = pre;
        pre->right = head;
        return head;
    }
};

栈的压入和弹出

• 关于stack和queue在使用s.top()或者q.front()时, 一定要先判断是否为空 !s.empty(), !q.empty().

class Solution {
public:
    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
        /*
        if(pushed.size() == 0 && popped.size() == 0)
            return true;
        stack<int> s;
        s.push(pushed[0]);
        int sz = pushed.size();
        int i = 1;
        int j = 0;
        while(i < sz || !s.empty())
        {
            while(i < sz && (s.empty() || s.top() != popped[j]))
            {
                s.push(pushed[i++]);
            }
            if(s.top() == popped[j])
            {
                s.pop();
                j++;
            }
            else
                break;
        }
        */
        stack<int> s;
        int i = 0;
        for(auto& num : pushed)
        {
            s.push(num);
            while(!s.empty() && s.top() == popped[i])
            {
                s.pop();
                i++;
            }
        }
        return s.empty();
    }
};

十进制转换成二进制

• 整数 : 不断对2取模, 直到被除数为0, 从下往上
• 小数 : 不断乘2取整数, 直到最后剩余部分为0, 从上往下

int main()
{
    double n;
    cin>>n;
    string res = "0.";
    /* 整数
    string res = "";
    while(n > 0)
    {
        int mod = n % 2;
        n /= 2;
        res += to_string(mod);
    }
    reverse(res.begin(), res.end());
     */
    // 小数
    while(n > 0)
    {
        n *= 2;
        int temp = int(n);
        n -= temp;
        res += to_string(temp);
    }
    cout<<res<<endl;
    return 0;
}