剑指offer笔记

最新推荐文章于 2024-07-12 18:56:03 发布

KKxue_43902676

最新推荐文章于 2024-07-12 18:56:03 发布

阅读量45

点赞数

文章标签：算法数据结构

本文链接：https://blog.csdn.net/weixin_43902676/article/details/114888109

版权

文章目录

1、二维数组中查找
2、替换空格
3、从尾到头打印链表
4、重建二叉树
5、用两个栈实现队列
6、旋转数组的最小数
7、斐波那契数列
8、二进制中1的个数

1、二维数组中查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
解释：指针从右上开始，找到横向小于target的最大数，然后竖向寻找是否存在target。

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) { 
        int n = array.size();
        int m = array[0].size();
        int i = 0 ,j  = m - 1;
        while(i < n && j >= 0){
            if(array[i][j] == target)
                return true ;
            if(array[i][j] > target)
                j--;
            else
                i++;
        }
        return false; 
    }
};

2、替换空格

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param s string字符串 
     * @return string字符串
     */
    string replaceSpace(string s) {
        // write code here
//         for(int i=0;i<s.length();i++){
//             if(s[i]==' '){
//                 s.replace(i, 1, "%20");
//                 i+=2;
//             }
//         }
        while(s.find(' ')!=s.npos){
            s.replace(s.find(' '), 1, "%20");
        }
        return s;
    }
};

3、从尾到头打印链表

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> res;
        int mid;
        while(head){
            res.push_back(head->val);
            head=head->next;
        }
        int i=0,j=res.size()-1;
        while(i<j){
            mid=res[i];res[i]=res[j];res[j]=mid;
            i++;j--;
        }
        return res;
    }
};

4、重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
//方法一
    TreeNode* buildTree(int prebegin, int vinbegin, int vinend, vector<int> pre,vector<int> vin){
        if(vinbegin>=vinend)return nullptr;
        TreeNode *p=new TreeNode(pre[prebegin]);
        int index=vinbegin;
        while(index<vinend && vin[index++]!=pre[prebegin]);--index;
        p->left=buildTree(prebegin+1, vinbegin, index, pre, vin);
        p->right=buildTree(prebegin+index-vinbegin+1, index+1, vinend, pre, vin);
        return p;
    }
//    方法二
    TreeNode* rebuild(vector<int>& pre, int pre_left, int pre_right, vector<int>& vin, int vin_left, int vin_right) {
        if (pre_left > pre_right) return nullptr;
        TreeNode* root = new TreeNode(pre[pre_left]); // 根结点
        int root_index = vin_left;
        while (root_index <= vin_right && vin[root_index++] != pre[pre_left]);
        --root_index; // 中序遍历中头结点的下标
        root->left = rebuild(pre, pre_left+1, pre_left+root_index-vin_left, vin, vin_left, root_index-1);
        root->right = rebuild(pre, pre_left+root_index-vin_left+1, pre_right, vin, root_index+1, vin_right);
        return root;
    }
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        return buildTree(0, 0, vin.size(), pre, vin);
//         return rebuild(pre, 0, pre.size()-1, vin, 0, vin.size()-1);
    }
};

方法一
在这里插入图片描述
方法二

5、用两个栈实现队列

用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。
注解：如果我知道队列是FIFO，栈是FILO，但是这道题我还是不知道怎么写怎么办？
对于这种感觉不难，但是又不会写的，方法就是模拟。
比如有如下操作：(pop操作确保栈中有元素）

push(1);push(2);pop(3);push(4);

图片说明
根据队列的特性，只能pop(1),pop(2),pop之后的结果
在这里插入图片描述

上述是队列的操作。
当push的时候，我们必须要用一个stack来存，假设用stack1来存。
图片说明

那么push操作解决了。那么pop操作怎么办呢？
如果pop(1)，但是此时在stack1的栈底，如果要pop，必须再将stack1中的数据push到stack2中，然后在pop，如图
在这里插入图片描述
这样直接弹出stack2的栈顶就可以了。
如果要继续pop，那就继续弹出stack2就可以了

但是现在总感觉哪里还是有点问题。如果是这样就继续测试几个例子。
如果push(5)，
图片说明
所以最后总结一下：push操作就直接往stack1中push， pop操作需要分类一下：如果stack2为空，那么需要将stack1中的数据转移到stack2中，然后在对stack2进行pop，如果stack2不为空，直接pop就ok。

class Solution
{
public:
    void push(int node) {
        stack1.push(node);
    }

    int pop() {
        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.top());
                stack1.pop();
            }
        }
        int i=stack2.top();
        stack2.pop();
        return i;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

在这里插入图片描述

6、旋转数组的最小数

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
注解：
这种二分查找难就难在，arr[mid]跟谁比.
我们的目的是：当进行一次比较时，一定能够确定答案在mid的某一侧。一次比较为 arr[mid]跟谁比的问题。
一般的比较原则有：

如果有目标值target，那么直接让arr[mid] 和 target 比较即可。
如果没有目标值，一般可以考虑端点

这里我们把target 看作是右端点，来进行分析，那就要分析以下三种情况，看是否可以达到上述的目标。

情况1，arr[mid] > target：4 5 6 1 2 3
arr[mid] 为 6， target为右端点 3， arr[mid] > target, 说明[first … mid] 都是 >= target 的，因为原始数组是非递减，所以可以确定答案为 [mid+1…last]区间,所以 first = mid + 1
情况2，arr[mid] < target:5 6 1 2 3 4
arr[mid] 为 1， target为右端点 4， arr[mid] < target, 说明答案肯定不在[mid+1…last]，但是arr[mid] 有可能是答案,所以答案在[first, mid]区间，所以last = mid;
情况3，arr[mid] == target:
如果是 1 0 1 1 1， arr[mid] = target = 1, 显然答案在左边
如果是 1 1 1 0 1, arr[mid] = target = 1, 显然答案在右边

所以这种情况，不能确定答案在左边还是右边，那么就让last = last - 1;慢慢缩少区间，同时也不会错过答案。
在这里插入图片描述

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.size()==0)return 0;
        int i=0,j=rotateArray.size()-1,mid;
        while(i<j){
            if(rotateArray[i]<rotateArray[j])return rotateArray[i];
            mid=(i+j)/2;
            if(rotateArray[mid]>rotateArray[j]){
                i=mid+1;
            }else if(rotateArray[mid]<rotateArray[j]){
                j=mid;
            }else{
                j--;
            }
        }
        return rotateArray[i];
    }
};

7、斐波那契数列

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。n≤39
在这里插入图片描述

class Solution {
public:
    int Fibonacci(int n) {
        vector<int> df(n+1,0);
        df[1]=1;
        for(int i=2;i<=n;i++){
            df[i]=df[i-1]+df[i-2];
        }
        return df[n];
    }
};

8、二进制中1的个数

输入一个整数，输出该数32位二进制表示中1的个数。其中负数用补码表示。
注解：让一个数0x01从右向左与val的每一位进行&操作来判断

class Solution {
public:
     int  NumberOf1(int n) {
         int sum=0,mark=1;
         while(mark!=0){
             sum+=(n & mark)?1:0;
             mark=(mark<<1);
         }
         return sum;
     }
};

KKxue_43902676

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指offer笔记

1、二维数组中查找在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。解释：指针从右上开始，找到横向小于target的最大数，然后竖向寻找是否存在target。class Solution {public: bool Find(int target, vector<vector<int> > array) { i
复制链接

扫一扫