剑指offer总结

1 剑指Offer

面试的三个环节

1 行为面试

1 自我介绍

30秒到1分钟时间介绍学习工作经历

2 项目经验

• 项目背景：项目规模，软件功能，目标用户
• 自己完成的任务：如何使用参与和负责
• 行动：项目的完成做了哪些工作
  • 系统：解释系统架构特点
  • 软件开发：基于工具，平台，使用哪些技术
  • 测试：手工测试，还是自动化测试，白盒测试还是黑盒测试

3 应聘者掌握的技能

技术掌握程度：了解，熟悉，精通三者的区别

2 技术面试

1 扎实的基础知识

1 编程语言

2 数据结构

• 链表，树，栈，队列，哈希表的操作

3 算法

• 查找，排序算法：二分查找，归并排序，快速排序

2 高质量的代码

问题：

• 字符串转换为整数
  • 特殊字符：正负号，非数字字符
  • 最大整数和最小负整数，溢出问题
• 链表中倒数第k个节点
  • k=0的问题
  • 空指针问题
  • 链表节点数量不足k个问题

代码的鲁棒性和完备性

• 边界条件
• 特殊输入（空指针，空字符串）
• 错误处理

解决方式：

• 编写代码前，先思考测试用例
• 写完代码后，暂时先头脑运行，不用马上给面试官

3 清晰思路

背景：

面试官提出较难问题，面试官并不期待在1小时内给出答案，而是观察应聘者是否有缜密的思路

解决：

• 画图：使得抽象的问题形象化
• 举例：使得抽象的问题具体化
• 分解：使得复杂问题简单化

4 优化效率的能力

优化时间复杂度和空间复杂度

• 善于使用不同的数据结构解决问题
  • 哈希表
  • 红黑树
  • 最大堆
• 善于使用不同的算法优化查找
  • 二分法
  • 动态规划
  • 分治法

5 优秀的综合能力

• 沟通能力

• 学习能力

• 知识迁移能力

  先问一个简单问题，然后问一个复杂问题，判断是否能够根据知识迁移能力找出解法

• 抽象建模能力

  • 善于将生活中的例子使用数据结构表示，最终找到其中的规律

• 发散思维的能力，打开思路从多角度分析问题

3 应聘者提问环节

暂时没想好问题

避雷：

• 不要问与自身职位相差很大的问题

2 编程语言

• 《Effective C++》C++的常见问题，适合面试前突击
• 《深度探索C++对象模型》了解C++对象的内部
• 《C++ primer》了解C++的语法
• 《the C++ programing language》深入掌握C++

2 数据结构

1 寻找重复数字

找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：

输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3

解法一：暴力求解

核心：双重遍历数组，找到相同数字

复杂度分析：

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

int findRepeatNumber(vector<int>& nums) {
        if(nums.size()<=0)
            return -1;
        
        for(int i=0;i<nums.size();i++)
        {
            for(int j=i+1;j<nums.size();j++)
            {
                if(nums[i]==nums[j])
                    return nums[i];
            }
        }
        return -1;
    }

排序解法：

分析：

• 将原数组按照从小到大排序
• 遍历原数组，查找相同元素

复杂度分析：

• 时间复杂度：O(nlogn)
• 空间复杂度：O(1)

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        if(nums.size()<=0)
            return -1;
        sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size()-1;i++)
        {
            if(nums[i]==nums[i+1])
                return nums[i];
        }
        return -1;
    }
};

哈希查找

分析：

• 针对暴力求解的方案，查找元素存在可改进为O(1)的复杂度。
• 核心：使用哈希表代替查找操作。空间交换时间。

哈希表（unordered_map）	使用
插入	hash[“abc”]=5.45
查询	hash[“abc”] 返回5.45
判断key是否存在	hash.count(“ABC”) != 0 或 hash.find(“ABC”) != hash.end()

int findRepeatNumber(vector<int>& nums) {
    if(nums.size()<=0)
        return -1;
    unordered_map<int,bool> n_map;
    //数组遍历
    for(int i=0;i<nums.size();i++)
    {
        if(n_map[nums[i]])
            return nums[i];
        n_map[nums[i]]=true;
    } 
    return -1;
}

复杂度分析：

• 时间复杂度：O(n)
• 空间复杂度：O(n)

数组代替哈希表,类似桶排序

分析：

• 数组元素的大小范围在0-n-1内，因此，可以申请一个空间为n的数组。
• 将i元素，放到下标为i的数组中，标识i元素在原数组中存在

int findRepeatNumber(vector<int>& nums) {
        if(nums.size()<=0)
            return -1;
        //使用桶做标记
        vector<int> new_nums(nums.size(),-1);
        for(int i=0;i<nums.size();i++)
        {
            if(new_nums[nums[i]]==1)
                return nums[i];
            new_nums[nums[i]]=1;
        }
        return -1;
    }

原地置换法

分析：

• 数组中每一个元素num[i]，放到他在数组中下标为num[i]的位置，当出现冲突时，数字重复。

步骤：

• 遍历数组 numsnums ，设索引初始值为 i = 0 :

  • 若 nums[i] = i ： 说明此数字已在对应索引位置，无需交换，因此跳过；
  • 假如：nums[nums[i]]==nums[i]，则找到一组重复值。
  • 否则： 交换索引为 ii 和 nums[i]nums[i] 的元素值，将此数字交换至对应索引位置。

• 若遍历完毕尚未返回，则返回 -1−1 。

复杂度分析：

• 时间复杂度：O(n)
• 空间复杂度：O(1)

int findRepeatNumber(vector<int>& nums) {
    if(nums.size()<=0)
        return -1;
    int i=0;
    while(i<nums.size())
    {
        if(nums[i]==i)
        {
            i++;
            continue;
        }
        if(nums[nums[i]]==nums[i])
            return nums[i];
        else
            swap(nums[i],nums[nums[i]]);
    }
    return -1;
}

二分法（无交换，不需要辅助空间）

分析：

• 统计元素[1,n]的数量，如果元素数量大于n，则元素出现重复。
• 使用二分法不断缩小检索空间。

复杂度：

• 时间复杂度：O(nlogn)，数量统计需要O(n)时间，然后该函数被调用O(logn)次

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        if(nums.size()<=0)
            return -1;
        
        int start=0;
        int end=nums.size()-1;
        //二分法开始
        while(start<=end)
        {
            int mid=((end-start)>>1)+start;
            int count=countRange(nums,start,mid);//计算start到end之间的数量
            if(start==end)//二分到最后一个数字
            {
                if(count>1)
                    return start;
                else
                    break;
            }
            if(count>(mid-start+1))
                end=mid;
            else
                start=mid+1;
        }
        return -1;
    }
    
    //计算数字范围在[start,end]在数组中出现的次数
    int countRange(const vector<int> &nums,int start,int end)
    {
        int count=0;
        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]>=start&&nums[i]<=end)
                count++;
        }
        return count;
    }
};

2二维数组中的查找

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:

现有矩阵 matrix 如下：

[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

暴力求解

分析：

• 直接遍历整个矩阵

复杂度分析：

• 时间复杂度：O(nm)
• 空间复杂度O(1)

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        if(matrix.size()==0||matrix[0].size()==0)
            return false;
        int n=matrix.size();
        int m=matrix[0].size();
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(target==matrix[i][j])
                    return true;
            }
        }
        return false;    
    }
};

二叉搜索树

分析：根据矩阵的性质，从右上角开始，左下小，右下大。使用二叉搜索树进行搜索。

https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/solution/mian-shi-ti-04-er-wei-shu-zu-zhong-de-cha-zhao-zuo/

复杂度分析：

• 时间复杂度：O(m+n)
• 空间复杂度：O(1)

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        if(matrix.size()==0||matrix[0].size()==0)
            return false;
        int n=matrix.size()-1;
        int m=matrix[0].size()-1;
        
        int row=0;
        int col=matrix[0].size()-1;
        //使用搜索树搜索
        while(col>=0&&row<=n)
        {
            if(target==matrix[row][col])
                return true;
            else if(target<matrix[row][col])
                col--;
            else
                row++;
        }
        return false;
    }
};

二分搜索

分析：

• 为了加快搜索速度，使用二分查找对于每一行和每一列进行搜索
• 迭代方向选用对角线的方向

复杂度分析：

• 时间复杂度：O(k（log m+log n）)，k=,min(m,n)

  k:迭代的次数最多为m和n的最小值需要k次迭代，

  logn+logm：每一次迭代需要（logn+logm）的复杂度，水平二分和垂直二分的总复杂度

• 空间复杂度O(1)

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        if(matrix.size()==0||matrix[0].size()==0)
            return false;
        int n=matrix.size();
        int m=matrix[0].size();
        int k=min(m,n);
        for(int i=0;i<k;i++)
        {
            if(vertical_search(matrix,target,i,i))
                return true;
            if(herizontal_search(matrix,target,i,i))
                return true;
        }
        return false;
       
    }
	//垂直搜索
    bool vertical_search(const vector<vector<int>> &matrix,int target,int row,int col)
    {   
        int m=matrix.size();
        int start=row;
        int end=m-1;
        while(start<=end)
        {
            int mid=((end-start)>1)+start;
            if(matrix[mid][col]==target)
                return true;
            else if(target<matrix[mid][col])
                end=mid-1;
            else
                start=mid+1;
        }
        return false;

    }
    //水平搜索
    bool herizontal_search(const vector<vector<int>> &matrix,int target,int row,int col)
    {
        int n=matrix[0].size();
        int start=col;
        int end=n-1;
        while(start<=end)
        {
            int mid=((end-start)>1)+start;
            if(matrix[row][mid]==target)
                return true;
            else if(target<matrix[row][mid])
                end=mid-1;
            else
                start=mid+1;
        }
        return false;
    }
};

递归

https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/solution/gao-su-jie-fa-qing-xi-tu-jie-by-ml-zimingmeng/

矩阵中的元素的性质：

• 该元素左上角的元素比该元素小
• 该元素有下角的元素比该元素大

关键点：找到一个元素matrix[row][mid]使得，matrix[row-1][mid]<target<matrxi[row][mid]

• 当target>9时，可以排除9的左上侧
• 当target<14时，可以排除14的右下侧
• 因此，最终的寻找区间，变为，9的右上侧和14的左下侧。

其中，找到黄色点的方法如下：

1. 列索引 mid采用二分查找;
2. 行索引沿 mid列从上向下移动，并保持该位置元素小于 target。

复杂度分析：

• 时间复杂度：O(nlogn)，

  递归需要logn次，然后每一次递归的时间为O(n)

• 空间复杂度：O(logn)，递归时，栈需要存储每次递归的中间数据

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        if(matrix.size()==0||matrix[0].size()==0)
            return false;
        int row=matrix.size();
        int col=matrix[0].size();
        return search_block(matrix,target,0,col-1,0,row-1);
       
    }
	//在矩形(left,right,up,down)中寻找对应元素
    bool search_block(const vector<vector<int>>& matrix,int target,int left,int right,int up, int down)
    {
        //边界条件分析
        if(left>right||up>down)
            return false;
        if(target<matrix[up][left]||target>matrix[down][right])
            return false;
		
        //寻找matrix[row][mid]的点
        int mid=left+((right-left)>>1);
        int row=up;
        while(row<=down&&target>=matrix[row][mid])
        {
            if(target==matrix[row][mid])
                return true;
            row++;
        }
        //返回对应块的结果
        return search_block(matrix,target,left,mid-1,row,down)||search_block(matrix,target,mid+1,right,up,row-1);
    }   
};

3剑指 Offer 05. 替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = “We are happy.”
输出：“We%20are%20happy.”

分析：

• java和python中的字符串是不可变类型，必须新建字符串，进行字符串拼接
• C++中字符串为可变类型，因此可以原地修改。

字符串拼接

分析：

• 使用字符串重载的+号运算符，对字符串进行拼接处理

复杂度分析

• 时间复杂度：O(N)
• 空间复杂度：O(1)

class Solution {
public:
    string replaceSpace(string s) {
        if(s.size()==0)
            return s;
        string new_s;
        for(int i=0;i<s.size();i++)
        {
            if(s[i]==' ')
                new_s=new_s+"%20";
            else
                new_s=new_s+s[i];
        }
        return new_s;
    }
};

字符串扩充替换

分析：

• 先将字符串扩充到合适大小，然后从尾到头进行遍历，将字符串替换

复杂度分析：

• 时间复杂度：O(N)
• 空间复杂度O(1)

class Solution {
public:
    string replaceSpace(string s) {
        if(s.size()==0)
            return s;
        //计算空格的数量
        int count=0;
        for(int i=0;i<s.length();i++)
        {
            if(s[i]==' ')
                count++;
        }
        int length=s.length();
        int new_length=s.length()+(count<<1);
        s.resize(new_length);//重新设置字符串的大小
        //从后向前遍历，替换空格
        for(int i=new_length-1,j=length-1;j>=0;i--,j--)
        {
            if(s[j]==' ')
            {
                s[i-2]='%';
                s[i-1]='2';
                s[i]='0';
                i=i-2;
            }
            else
                s[i]=s[j];          
        }
        return s;
    }
};

4 剑指 Offer 06. 从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2]
输出：[2,3,1]

首尾双指针

分析：

• 尾指针指向链表结尾，首指针遍历链表，记录尾指针上一个结点

复杂度分析：

• 时间复杂度：O(N^2) 每存储一个元素，需要遍历链表一次
• 空间复杂度:O(N) 需要一个vector数组

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> re_vec;
        if(head==NULL)
            return re_vec;
        ListNode *rp=head;
        while(rp->next!=NULL)
            rp=rp->next;
		//从尾指针不断插入结点
        ListNode *p=head;
        while(rp!=head)
        {
            while(p->next!=rp)
                p=p->next;
            re_vec.push_back(rp->val);
            rp=p;
            p=head;
        }
        //添加最后一个头结点
        re_vec.push_back(head->val);
        return re_vec;
        
    }
};

vector 反转

分析：

• 将链表元素遍历到数组中，然后将数组反转

复杂度分析：

• 时间复杂度：O(n);

  遍历链表O(N)

  数组反转O(N) 两者相加

• 空间复杂度O(N)；需要一个vector数组

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> re_vec;
        if(head==NULL)
            return re_vec;
        //遍历
        for(ListNode *p=head;p!=NULL;p=p->next)
        {
            re_vec.push_back(p->val);
        }
        //反转
        reverse(re_vec.begin(),re_vec.end());
        return re_vec;     
    }
};

递归

分析：假设head->next已经插入，那么只要将head插入即可

• 递推：将反转链表工作一直递推到最后一个节点
• 回溯：由最后一个节点回归，将val插入vector中。

复杂度分析：

• 时间复杂度；O(N)

  递归N次。时间复杂度O(N)

  每次递归的操作时间复杂度为O(1),

  总时间复杂度：O(n)*O(1)=O(N)

• 空间复杂度：O(N)：递归将占用链表长度的栈空间

class Solution {
public:
    vector<int> re_vec;
    vector<int> reversePrint(ListNode* head) { 
        if(head==NULL)
            return re_vec;
        reversePrint(head->next);
        re_vec.push_back(head->val);
        return re_vec;
    }
};

利用栈

分析：

• 利用堆栈先进后出的特点，先依次将元素压入堆栈中，然后将所有元素从堆栈中弹出，即可实现反转。

复杂度分析：

• 时间复杂度：O(n)

  push的时间复杂度O(n), pop的时间复杂度O(n)

• 空间复杂度：O(n),使用额外的res和堆栈

class Solution {
public:
    vector<int> re_vec;
    stack<int> sta;
    vector<int> reversePrint(ListNode* head) { 
        if(head==NULL)
            return re_vec;
        ListNode* p=head;
        //入栈
        while(p!=NULL)
        {
            sta.push(p->val);
            p=p->next;
        }
        //出栈
        while(!sta.empty())
        {
            int top=sta.top();
            re_vec.push_back(top);
            sta.pop();
        }
        return re_vec;
    }
};

剑指 Offer 07. 重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

递归（先序遍历）

• preorder的头结点元素就是根节点
• 然后找出左子树的先序序列和中序序列，找出有子树的先序序列和中序序列

类似二叉树的先序递归遍历，进行编码

• 根节点的建立
• 递归左子树
• 递归有子树

复杂度分析：

• 时间复杂度：O(n)，每一个节点作为根节点进行一次递归

  递归建立N个节点，每层递归中的节点建立、搜索操作占用 O(1) ，因此使用 O(N) 时间。

• 空间复杂度：O(n)

  O(n)=O(n)+O(h)；

  O(n)：存储哈希表需要的空间

  O(h)：h为树的高度。进行递归需要的递归栈需要的空间

class Solution {
private:
    unordered_map<int,int> index_mp;//哈希表存储索引
public: 
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        //遍历中序序列，将中序序列的元素用哈希表存储索引
        int n=inorder.size();
        for(int i=0;i<n;i++)
        {
            index_mp[inorder[i]]=i;
        }
        TreeNode* root=recur_buildTree(preorder,inorder,0,n-1,0,n-1);
        return root;
    }
	//类型先序遍历建立递归树
    //（先序数组，中序数组，先序左端点，先序右端点，中序左端点，中序右端点）
    TreeNode* recur_buildTree(const vector<int> &preorder,const vector<int> &inorder,int pre_left_index,int pre_right_index,int in_left_index,int in_right_index)
    {
        if(pre_left_index>pre_right_index)
            return nullptr;
        
        int root_val=preorder[pre_left_index];
        int root_inorder_index=index_mp[root_val];
        TreeNode *root=new TreeNode(root_val);
        int left_length=root_inorder_index-in_left_index;
        
		//递归左子树
        root->left=recur_buildTree(preorder,inorder,pre_left_index+1,pre_left_index+left_length,
                                   in_left_index,root_inorder_index-1);
        //递归右子树
        root->right=recur_buildTree(preorder,inorder,pre_left_index+left_length+1,pre_right_index,
                                    root_inorder_index+1,in_right_index);
        return root;
    }
};

迭代