剑指Offer_week_3

最新推荐文章于 2024-06-05 21:38:06 发布
最新推荐文章于 2024-06-05 21:38:06 发布
阅读量148 收藏
点赞数
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56042518/article/details/126967838
版权

61.序列化二叉树

image-20220919161118368

class Solution {
  private:
    string SerializeCore(TreeNode* root) {
        if (root == nullptr) {
            return "#!";	// !表示一个结点值的结束
        }

        string str;
        str = to_string(root->val) + "!";
        str += SerializeCore(root->left);
        str += SerializeCore(root->right);
        return str;
    }

    TreeNode* DeserializeCore(char*& str) {
        if (*str == '#') {
            str++;
            return nullptr;
        }

        int num = 0;
        while (*str != '!') {	// 当出现字符 ‘123!’，可以转换为int
            num = num * 10 + *str - '0';
            str++;
        }
        
        TreeNode* node = new TreeNode(num);
        node->left = DeserializeCore(++str);
        node->right = DeserializeCore(++str);
        return node;
    }

  public:
    char* Serialize(TreeNode* root) {
        string str = SerializeCore(root);
        char* res = new char[str.size()];
        for (int i = 0; i < str.size(); i++) {
            res[i] = str[i];
        }
        return res;
    }

    TreeNode* Deserialize(char* str) {
        return DeserializeCore(str);
    }
};

62.二叉搜索树的第k个节点

image-20220919162048578

class Solution {
    vector<int> vec;
public:
    void LDR(TreeNode* root) {
        if (!root) return;

        LDR(root->left);
        vec.push_back(root->val);
        LDR(root->right);
    }

    int KthNode(TreeNode* proot, int k) {
        LDR(proot);
        if (0 == k || k > vec.size()) return -1;

        return vec[k - 1];    
    }
};

63.数据流中的中位数

image-20220919163726350

使用容器，然后排序

class Solution {
public:
    vector<int> vec;
    void Insert(int num) {
        vec.push_back(num);
    }
  
    double GetMedian() { 
        sort(vec.begin(), vec.end());
        int len = vec.size();
  
        if (len % 2 == 1) {
            return double(vec[len / 2]);
        } else {
            return double(vec[len / 2] + vec[(len - 1) / 2]) / 2;
        }
    }
};

将其插入的所有数字看成一个集合，由大到小排列，然后左侧使用大顶堆，右侧使用小顶堆，这样就可以根据元素个数始终知道中位值，如果为奇数个，中位值就为大顶堆的top，如果为偶数个，中位值为大顶堆的top与小顶堆top的平均值

class Solution {
public:
    int count = 0;
    priority_queue<int, vector<int>, less<int>> left_big;         // 大顶锥, 降序排列, top指向大值，位于左侧
    priority_queue<int, vector<int>, greater<int>> right_small;   // 小顶锥, 升序排列, top指向小值，位于右侧

    void Insert(int num) {
        count++;
        if (count % 2 == 1) {
            right_small.push(num);
            left_big.push(right_small.top());
            right_small.pop();
        } else {
            left_big.push(num);
            right_small.push(left_big.top());
            left_big.pop();
        }
    }

    double GetMedian() { 
        if (count % 2 == 1) return left_big.top();
        else {
            return (left_big.top() + right_small.top()) / 2.0;
        }
    }
};

64.滑动窗口的最大值

image-20220920221358128

暴力循环

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
        int len = num.size();
        if (size > len || len == 0 || size == 0) return vector<int>();
        
        vector<int> ans;
        int cnt = len - size + 1;
        for (int i = 0; i < cnt; i++) {
            int maxNum = INT_MIN;
            for (int j = i; j < i + size; j++) {
                if (num[j] > maxNum) maxNum = num[j];
            }
            ans.push_back(maxNum);
        }
        return ans;
    }
};

双向队列

思路：

我们都知道，若是一个数字A进入窗口后，若是比窗口内其他数字都大，那么这个数字之前的数字都没用了，因为它们必定会比A早离开窗口，在A离开之前都争不过A，所以A在进入时依次从尾部排除掉之前的小值再进入，而每次窗口移动要弹出窗口最前面值，因此队首也需要弹出，所以我们选择双向队列。

具体做法：

  • step 1：维护一个双向队列，用来存储数列的下标。

  • step 2：首先检查窗口大小与数组大小。

  • step 3：先遍历第一个窗口，如果即将进入队列的下标的值大于队列后方的值，依次将小于的值拿出来去掉，再加入，保证队列是递增序。

  • step 4：遍历后续窗口，每次取出队首就是最大值，如果某个下标已经过了窗口，则从队列前方将其弹出。

  • step 5：对于之后的窗口，重复step 3，直到数组结束。

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
        int len = num.size();
        if (size > len || len == 0 || size == 0) return vector<int>();
        
        vector<int> ans;
        deque<int> dq;  // 维护一个双向队列，用来存储数列的下标
        for (int i = 0; i < len; i++) {
            // 去掉比自己先进队列的小于自己的值
            while (!dq.empty() && num[dq.back()] < num[i]) {
                dq.pop_back();
            }
            dq.push_back(i);

            // 判断队列的头部的下标是否不在窗口范围
            if (dq.front() + size <= i) {
                dq.pop_front();
            }
            
            // 判断是否形成了窗口
            if (i + 1 >= size) {
                ans.push_back(num[dq.front()]);
            }
        }
        return ans;
    }
};

65.矩阵中的路径

image-20220920230656832

DFS

class Solution {
public:
    bool DFS(vector<vector<char>>& board, char* str, int index, int x, int y, 
        vector<vector<bool>>& visited) 
    {
        if (index == strlen(str)) return true;
        if ((x < 0) || (y < 0) || (x >= board.size()) || (y >= board[0].size())) 				return false;
        if (visited[x][y]) return false;
        if (board[x][y] != str[index]) return false;
        visited[x][y] = true;

        if (DFS(board, str, index + 1, x, y - 1, visited) || //上
		DFS(board, str, index + 1, x, y + 1, visited) ||     //下
		DFS(board, str, index + 1, x - 1, y, visited) ||     //左
		DFS(board, str, index + 1, x + 1, y, visited))       //右
		return true; // 有符合要求的

        visited[x][y] = false; // 如果没有符合要求的，需要从新遍历搜索，改回false
	    return false;
    }

    bool hasPath(char* matrix, int rows, int cols, char* str)
    {
        if (str == nullptr || rows <= 0 || cols <= 0) return false;
        vector<vector<char>> board(rows, vector<char>(cols));
        
        // 将字符串装入二维数组中
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                board[i][j] = matrix[i * cols + j];
            }
        }

        vector<vector<bool>> visited(rows, vector<bool>(cols, false));
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (DFS(board, str, 0, i, j, visited) == true) return true;
            }
        }
        return false;
    }
};

66.机器人的运动范围

image-20220920232245806

class Solution {
public:
    int cnt = 0;

    int cal(int n) {
        int sum = 0;
        while (n) {
            sum += (n % 10);
            n /= 10;
        }
        return sum;
    }

    void DFS(int i, int j, int rows, int cols, 
             int threshold, vector<vector<bool> >& visited) {
        // 越界访问
        if (i < 0 || j < 0 || i >= rows || j >= cols) return;
        // 已经访问过
        if (visited[i][j]) return;
        // 不符合要求
        if (cal(i) + cal(j) > threshold) return;

        cnt += 1;
        visited[i][j] = true;

        // 上下左右
        DFS(i + 1, j, rows, cols, threshold, visited);
        DFS(i - 1, j, rows, cols, threshold, visited);
        DFS(i, j - 1, rows, cols, threshold, visited);
        DFS(i, j + 1, rows, cols, threshold, visited);
    }

    int movingCount(int threshold, int rows, int cols) {
        if (rows < 0 || cols < 0) return 0;
        vector<vector<bool>> visited(rows, vector<bool>(cols, false));
        DFS(0, 0, rows, cols, threshold, visited);
        return cnt;
    }
};

67.剪绳子

image-20220920234109974

  • 4 ： 2+2

  • 5 ： 2+3

  • 6 ： 3+3

  • 7 ： 2+2+3 或者4+3

  • 8 ： 2+3+3

  • 9 ： 3+3+3

  • 10：2+2+3+3 或者4+3+3

  • 分析后可以推出，最大乘积划分后 只有2和3，所以主要求出要分别划分为多少个2和3

class Solution {
public:
    int cutRope(int number) {
        if (number == 2) return 1;
        if (number == 3) return 2;

        int x = number % 3;
        int y = number / 3;

        if (x == 0) return pow(3, y);
        else if (x == 1) return 2 * 2 * pow(3, y - 1);  // 看成有两个2, y-1个3  而不是 y个3，1个1
        else return 2 * pow(3, y);      // 一个2，y个3
    }
};

class Solution {
public:
    int cutRope(int number) {
        if (number == 2) return 1;
        if (number == 3) return 2;

        int maxNum=1;
        while(number>4){
            maxNum*=3;
            number-=3;
        }
        maxNum*=number;
        return maxNum;
    }
};
小坤.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
剑指offer-Java代码_java_剑指offer_
09-30
剑指offer的Java代码全套加文字说明
sword-pointing-to-offer_java.zip_剑指offer_剑指offer java
09-20
剑指offer中都为c++实现的，这个为java实现的版本
剑指Offer_week_2
weixin_56042518的博客
09-21 194
剑指Offer_week_2
剑指offer题解合集——Week1day2
qq_51931826的博客
12-19 395
剑指offer
剑指offer题解合集——Week2day5
qq_51931826的博客
12-31 665
剑指offer题解合集——Week2day5
剑指Offer-week1
weixin_61819021的博客
04-20 1115
目录 1-找出数组中重复元素 1-找出数组中重复元素 给定一个长度为 n 的整数数组 nums，数组中所有的数字都在 0∼n−1 的范围内。 数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。 请找出数组中任意一个重复的数字。 注意：如果某些数字不在 0∼n−1的范围内，或数组中不包含重复数字，则返回 -1； special judge： 给每个数字分配一个坑，不在对应坑就交换并重复该操作。 class Solution { public:
剑指offer-week1
weixin_43493354的博客
12-16 731
一、找出数组中的重复数字 描述 在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组[2,3,1,0,2,5,3]，那么对应的输出是2或者3。存在不合法的输入的话输出-1 数据范围： 进阶：时间复杂度，空间复杂度 输入：[2,3,1,0,2,5,3] 返回值：2 说明： 2或3都是对的 采用重排数组的办法，时间复杂度为O(n)，空间复杂度为O(1)； 首先，我们可
剑指Offer week 0
weixin_56042518的博客
09-05 380
剑指offer week 0
剑指Offer week 1
weixin_56042518的博客
09-12 445
剑指Offer week 1
《剑指offer》题解——week7
Java技术一点通
08-30 3074
滑动窗口对应的数据结构为 双端队列 ，本题使用 单调队列 即可解决本问题。遍历数组时，每轮保证单调队列 dequedequedeque ：算法流程： 根据题意，此 5 张牌是顺子的 条件 如下：算法流程： 假设有一圈数字 [0,1,2,3,4],m=3[0, 1, 2, 3, 4],m = 3[0,1,2,3,4],m=3 我们每次将删除元素的后一个元素放在最前面方便计数:第四轮反推，补上 mmm 个位置，然后模上当时的数组大小 2，位置是 。 第三轮反推，补上 mmm 个位置，然后模上当时的
剑指offer week1题
usstmiracle的博客
06-25 128
给定一个长度为n的数组nums 数组的所有数组都在0~n-1范围内。 数组中某些数组重复，但不知道几个数字重复，也不知道数字重复几次，请找出数组中任意一个重复的数字。 解题思路：如果第1个位置的数是4，则把这个数与第4个位置的数比较，如果不相同，把这个数与第4个位置上面的数交换 这样每次就能把一个数放到正确的位置上去。 再把第一个位置的数换到正确的位置上去，直到换到不能换为止。 int...
No4_fliesdm7_familywbh_剑指offer_
10-01
剑指offer第4题，二维数组查找，已过牛客网。
剑指offer（java版）.rar_剑指offer_剑指offer java_剑指offer（java版）
09-24
java方向面试经常考的编程题47道，比如单例模式等
T43-n个筛子点数.rar_剑指offer_筛子
07-15
计算N个筛子点数和，使用递归和循环两种方法
N叉树的层序遍历-力扣
最新发布
why_12134的博客
06-05 320
本题同样是二叉树的层序遍历的扩展，只不过二叉树每个节点的子节点只有左右节点，而N叉树的子节点是一个数组，层序遍历到一个节点时，需要将这个节点的子节点数组的每个节点都入队。
回溯之分割回文串
JINbigXIA的博客
06-04 287
思路：直接看回溯函数的内容，首先我们是取段的，如果这一段不行那就往后面加1，直到加道循环结束。如果可以取端，并且取到了最后一段，也就是开始的startIndex大于等于size那么就代表这一条都是回文字符串。然后需要一个判断函数，判断字符串是否为回文字符串，如果是往path里面加。学到的新函数：array.substr( a ,b) a表示字符串的开始，b表示数量 含义：选取字符串array从a开始往后的b个数。难点：这里用到一个很取段的思路，其实和取点的内容差不多，但是取端更难理解。
生信算法7 - 核酸序列Fasta和蛋白PDB文件读写与检索
LittleComputerRobot的博客
06-03 368
核酸序列Fasta和蛋白PDB文件读写与检索
TypeScript算法每日一题：一维数组的动态和（1480）
海风依旧
06-04 182
TypeScript算法每日一题：一维数组的动态和（1480）
剑指offer java
09-18
《剑指offer》是一本程序猿面试的经典书籍，其中包含了很多常见的算法题和解答。在这本书中，有关跳台阶的问题有两个，分别是《剑指offer》10 矩阵覆盖和《剑指offer》9 青蛙变态跳台阶。 对于《剑指offer》10 矩阵...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值