剑指offer——解决面试题的思路

最新推荐文章于 2021-10-24 19:46:04 发布
最新推荐文章于 2021-10-24 19:46:04 发布
阅读量277 收藏
点赞数
分类专栏： 剑指offer 文章标签： 剑指offer

# 剑指offer——解决面试题的思路

1. 画图让抽象问题形象化

面试题19：二叉树的镜像

struct BinaryTreeNode{
    int m_nValue;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
};
/*前序遍历树的每个结点，若遍历到的结点有子结点，就交换他的两个子结点；当交换完所有非叶子结点的左右子结点后，就得到了树的镜像。*/
void MirrorRecursively(BinaryTreeNode* pNode){
    if (pNode==NULL)
        return;
    if (pNode->m_pLeft==NULL && pNode->m_pRight==NULL)
        return;
    BinaryTreeNode *pTemp = pNode->m_pLeft;
    pNode->m_pLeft = pNode->m_pRight;
    pNode->m_pRight = pTemp;
    if (pNode->m_pLeft)
        MirrorRecursively(pNode->m_pLeft);
    if (pNode->m_pRight)
        MirrorRecursively(pNode->m_pRight);
}
//循环解法
void Mirror(TreeNode *pRoot) {
    if (pRoot == nullptr || (pRoot->left == nullptr && pRoot->right == nullptr))
        return;

    stack<TreeNode*> stackNodes;
    stackNodes.push(pRoot);

    while (stackNodes.size() > 0)
    {
        TreeNode *pNode = stackNodes.top();
        stackNodes.pop();
        TreeNode *pTemp = pNode->left;
        pNode->left = pNode->right;
        pNode->right = pTemp;

        if (pNode->left != nullptr)
            stackNodes.push(pNode->left);
        if (pNode->right != nullptr)
            stackNodes.push(pNode->right);
    }

}

面试题20：顺时针打印矩阵

考虑情况：数组的行列数（相等；行数大于列数；行数小于列数）

void PrintMatrixClockwisely(int** number,int columns,int rows){
    if (number==NULL || columns<=0 || rows<=0)
        return;
    int start=0;
    while (rows>start*2 && columns>start*2){
        PrintMatrixCircle(number,columns,rows,start);
        start++;
    }   
}
void PrintMatrixCircle(int** number,int columns,int rows,int start){
    int endY = columns-start-1;
    int endX = rows-start-1;
    //从左到右打印一行
    for (int i=start;i<=endY;++i){
        int num = number[start][i];
        printNumber(number);
    }
    //从上到下打印一行
    if (start<endX){
        for (int i=start+1;i<=endX;++i){
            int num = number[i][endY];
            printNumber(number);
        }
    }
    //从右到左打印一行
    if (start<endX && start<endY){
        for (int i=endY-1;i>=start;--i){
            int num = number[endX][i];
            printNumber(number);
        }
    }
    //从下到上打印一行
    if (start<endX && start<endY){
        for (int i=endX-1;i>=start+1;--i){
            int num = number[i][startY];
            printNumber(number);
        }
    }
}

2. 举例让抽象问题具体化

面试题21：包含min函数的栈（定义栈的数据结构，调用min，pop，push的时间复杂度均为O(1)）

/*使用辅助栈存储栈每次进栈后对应的最小元素*/
//m_data是数据栈，m_min是辅助栈
template <typename T> void StachWithMin<T>::push(const T &value){
    m_data.push(value);
    if (m_min.size()==0 || value <m_min.top())
        m_min.push(value);
    else
        m_min.push(m_min.top());
}
template <typename T> void StachWithMin<T>::pop(){
    assert(m_data.size()>0 && m_min.size()>0)
    m_data.pop();
    m_min.pop();
}
template <typename T> const T& StachWithMin<T>::min() const{
    assert(m_data.size()>0 && m_min.size()>0)
    return m_min.top();
}

面试题22：栈的压入，弹出序列（给定两个序列，压入序列，判断另一个是否为弹出序列）

/*建立辅助栈，按第一个序列将数字压入栈，并按第二个序列一次从栈中弹出数字。若即将弹出的元素是栈顶元素，则直接弹出；否则把压入序列的数字进栈直到栈顶元素是要弹出的数字；若所有数字均已入栈还没找到要弹出的数字，那么该序列不可能是一个弹出序列。*/
bool IsPopOrder(const int *pPush,const int *pPop,int nLength){
    bool bPossible = false;
    if (pPush!=NULL && pPop!=NULL && nLength>0){
        const int* pPushNext = pPush;
        const int* pPopNext = pPop;
        stack<int> stackData;
        while (pPopNext-pPop<nLength){
            while (stackData.empty() || stackData.top()!=*pPopNext){
                if (pPushNext-pPush)<nLength)
                    break;
                stackData.push(*pPushNext++);
            }
            if (stackData.top()!=*pPopNext)
                break;
            stackData.pop();
            pPopNext++;
        }
        if (stackData.empty() && pPopNext-pPop==nLength)
            bPossible = true;
    }
    return bPossible;
}

面试题23：从上往下打印二叉树（层序遍历,广度优先遍历）

struct BinaryTreeNode{
    int m_nValue;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
};
/*从根结点开始，若打印的结点有子结点，将子结点压入队尾；接下来打印队首结点元素，重复前面，直到队列为空。*/
void PrintFromTopToBottom(BinaryTreeNode* pTreeRoot){
    if (pTreeRoot==NULL)
        return;
    deque<BinaryTreeNode*} dequeTreeNode;
    dequeTreeNode.push(pTreeRoot);
    while (!dequeTreeNode.empty()){
        BinaryTreeNode* pNode = dequeTreeNode.front();
        dequeTreeNode.pop_front();
        printf("%d ",pNode->m_nValue);
        if (pNode->m_pLeft!=NULL)
            dequeTreeNode.push_back(pNode->m_pLeft);
        if (pNode->m_pRight!=NULL)
            dequeTreeNode.push_back(pNode->m_pRight);
    }
}

举一反三：广度优先遍历有向图或树，利用队列：把起始结点（树的根结点）放入队列。接下来每一次从队列的头部取出一个结点，遍历这个结点能达到的结点（树中的子结点）都依次放入队列。重复上述过程，直到队列为空。

面试题24：判断数组是否是二叉搜索树的后序遍历序列

/*后序遍历的最后一个元素为根结点，前面的数字应该可以分为两部分：小于根结点（左子树），大于根结点（右子树）；再递归判断两个子数组即可*/
bool VerifySquenceofBST(int sequence[],int lenght){
    if (sequence==NULL || length<=0)
        return false;
    int root = squence[length-1];
    //搜索左子树：在二叉搜索树中左子树结点小于根结点
    int i=0;
    for (;i<length-1;++i){
        if (squence[i]>root)
            break;
    }
    //搜索右子树：在二叉搜索树中右子树结点大于根结点
    int j=i;
    for (;j<length-1;++j){
        if (squence[i]<root)
            return false;
    }
    //判断左子树是不是二叉搜索树
    bool left = true;
    if (i>0)
        left = VerifySquenceofBST(sequence,i);
    //判断右子树是不是二叉搜索树
    bool right = true;
    if (i>0)
        right = VerifySquenceofBST(sequence+i,length-1-i);
    return (left && right);
}

面试题25：打印二叉树中和为某一值的所有路径（从根结点到叶子结点经过的结点形成一条路径）

/*采用前序遍历和栈：将遍历到结点压入栈，并累加值得和；若当前结点为叶子结点且累加和等于给定值，则打印出来；若当前结点不是叶子结点，继续访问其子结点；当前结点访问结束后，回到其父结点并从栈中弹出当前结点并减去其值*/
struct BinaryTreeNode{
    int m_nValue;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
};
void FindPath(BinaryTreeNode *pRoot,int expectedSum){
    if (pRoot==NULL)
        return;
    vector<int> path;
    int currentSum = 0;
    FindPath(pRoot,expectedSum,path,currentSum);
}
void FindPath(BinaryTreeNode *pRoot,int expectedSum,vect<int> & path,int currentSum){
    currentSum += pRoot->m-nValue;  
    path.push_back(pRoot->m-nValue);
    bool isLeafNode = (pRoot->m_pLeft==NULL) && (pRoot->m_pRight==NULL);
    //若当前结点为叶子结点且累加和等于给定值，则打印出来
    if (currentSum == exceptedSum && isLeaf){
        printf("A Path is found: ");
        vector<int>::iterator iter = path.begin();
        for (;iter!=path.end();++iter)
            printf("%d\t",*iter);
        printf("\n");
    }
    //若当前结点不是叶子结点，则继续访问其子结点
    if (pRoot->m_pLeft!=NULL)
        FindPath(pRoot->m_pLeft,exceptedSum,path,currentSum);
    if (pRoot->m_pRight!=NULL)
        FindPath(pRoot->m_pRight,exceptedSum,path,currentSum);
    //在返回父结点前，在路径上删除当前结点
    path.pop_back();
    currentSum -= pRoot->m-nValue;
}

3. 分解让复杂问题简单化（分治法）

面试题26：复杂链表的复制

struct ComplexListNode{
    int m_nValue;
    ComplexListNode *m_pnext;//下一个结点
    ComplexListNode *m_pSibling;//兄弟    
}
//第一步：复制原始链表的每个结点N创建新结点N'链接到N的后面
void CloneNodes(ComplexListNode *pHead){
    ComplexListNode *pNode = pHead;
    while (pHead!=NULL){
        ComplexListNode *pCloned = new ComplexListNode();
        pClone->m_nValue = pNode->m_nValue;
        pClone->m_pNext = pNode->m_pNext;
        pClone->m_pSibling = NULL;
        pNode->m_pNext = pCloned;
        pNode = pNode->m_pNext;     
    }
}
//第二步：如果原始链表的结点N的m_pSibling指向结点S,则它对应的复制结点N'的m_pSibling指向结点S'
void ConnectSiblingNodes(ComplexListNode *pHead){
    ComplexListNode *pNode = pHead;
    while (pNode!=NULL){
        ComplexListNode *pCloned = pNode->m_pNext;  
        if (pNode->m_pSibling!=NULL){
            pCloned->m_pSibling = p->m_pSibling->m_pNext;
        }
        pNode = pClone->m_pNext;
    }
}
//第三步：将第二步得到的链表拆分为两个链表：奇数位置上的结点组成原始链表，偶数位置上的结点组成复制链表
ComplexListNode * ReConnectNodes(ComplexListNode* phead){
    ComplexListNode *pNode = pHead;
    ComplexListNode *pClonedHead = NULL;
    ComplexListNode *pClonedNode = NULL;
    if (pNode！=NULL){
        pClonedHead = pClonedNode = pNode->m_pNext;
        pNode->m_pNext = pClonedNode->m_pNext;
        pNode = pNode->m_pNext;
    }
    while (pNode!=NULL){
        pClonedNode->m_pNext = pNode->m_pNext;
        pClonedNode = pClonedNode->m_pNext;
        pNode->m_pNext = pClonedNode->m_pNext;
        pNode = pNode->m_pNext;
    }
}
//完整过程
ComplexListNode * Clone(ComplexListNode * pHead){
    CloneNodes(pHead);
    ConnectSiblingNodes(pHead);
    return ReConnectNodes(phead);
}

面试题27：二叉搜索树调整指针指向构成排序的双向链表

struct BinaryTreeNode{
    int m_nValue;
    BinaryTreeNode * m_pLeft;
    BinaryTreeNode * m_pRight;
};
BinaryTreeNode * Convert(BinaryTreeNode * pRootOfTree){
    BinaryTreeNode * pLastNodeInList = NULL;
    ConvertNode(pRootOfTree,&pLastNodeInList);
    BinaryTreeNode * pHeadOfList = pLastNodeInList;
    while (pHeadOfList!=NULL && pHeadOfList->m_pLeft!=NULL)
        pHeadOfList = pHeadOfList->m_pLeft;
    return pHeadOfList;
}
void ConvertNode(BinaryTreeNode * pNode,BinaryTreeNode **pLastNodeInList){
    if (pNode==NULL)
        return;
    BinaryTreeNode * pCurrent = pNode;
    if (pCurrent->m_pLeft!=NULL)
        ConvertNode(pCurrent->m_pLeft,pLastNodeInList);
    pCurrent->m_pLeft = *pLastNodeInList;
    if (*pLastNodeInList!=NULL)
        (*pLastNodeInList)->m_pRight = pCurrent;
    *pLastNodeInList = pCurrent;    
    if (pCurrent->m_pRight!=NULL)
        ConvertNode(pCurrent->m_pRight,pLastNodeInList);
}

面试题28：字符串的排列

/*将字符串分为两部分：第一个字符与剩余字符串，再求其他字符串的排列；逐个交换第一个字符与后面的字符*/
void Permutation(char* pStr){
    if (pStr==NULL)
        return;
    Permutation(pStr,pStr);
}
void Permutation(char* pStr,char* pBegin){
    if (*pBegin=='\0')
        printf("%s\n",pStr);
    else{
        for (char *pCh = pBegin;*pCh!='\0';++pCh){
            char temp = *pCh;
            *pCh = *pBegin;
            *pBegin = temp;
            Permutation(pStr,pBegin+1);
            temp = *pCh;
            *pCh = *pBegin;
            *pBegin = temp;
        }
    }
}
//abc acb bac bca cba cab

举一反三：如果面试题是按照一定要求摆放若干个数字，可以先求出这些数的所有排列，再一一判断哪些排列符合要求（比如：象棋的摆放）

xmpp10
关注
专栏目录
《剑指offer》全解（图文结合，通俗易懂，一篇看爽）
weixin_44232942的博客
07-24 3283
3. 数组中重复的数字 题目链接 牛客网 题目描述 在一个长度为 n 的数组里的所有数字都在 0 到 n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的，也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 Input: {2, 3, 1, 0, 2, 5} Output: 2 解题思路 要求时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。 对于这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置
Leetcode、剑指Offer——名企面试官精讲典型编程题.zip
02-04
《LeetCode与剑指Offer——名企面试官精讲典型编程题》是一个针对程序员面试准备的重要资源包。它包含了来自LeetCode平台以及《剑指Offer》书籍中的经典编程题目，这些题目广泛应用于各大知名企业的面试过程中，是...
剑指offer常见面试题（思路）
wengmq的博客
02-27 599
剑指offer常见面试题（思路） 1.判断两个单向链表是否相交，如果相交，求出交点 判断两个单向链表是否相交？判断两个链表的最后一个节点是否相同 求相交链表的节点： 暴力解决：在第一个链表上顺序遍历每一个节点，每遍历到一个节点，就在第二个链表上顺序遍历每个节点。如果在第二个链表上有一个节点与第一个链表上的节点一样，则说明两个链表在这个节点上重合，于是就找到了他们的公共节点。 简便解法：首先遍历...
剑指Offer面试题思路解析
Just The Way You Are
04-18 257
面试题58：二叉树的下一个节点 给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。 思路分析： 1.如果二叉树为空，返回空 2.如果二叉树的右子树不为空，那么返回右子树的最左孩子节点 3.如果二叉树的右子树为空，那么寻找第一个节点是父节点左孩子的节点，返回其父节点，既是当前节点的下一个节点。 p...
剑指Offer LeetCode 面试题53 - II. 0～n-1中缺失的数字
TrueDei
05-25 1032
剑指Offer LeetCode 面试题53 - II. 0～n-1中缺失的数字
YYDS《剑指Offer》再续新篇，百万程序员人手一册
程序猿DD
08-14 350
程序员面试应该看什么书？博文菌必须毫不犹豫地首推《剑指Offer》这本程序员面试圣经。这可不是博文菌信口拈来的回答，看看广大网友们的反馈，就知道这是经过读者朋友们认证的事实！在知乎上，一篇...
读书笔记：剑指offer——名企面试官精讲典型编程题.zip
07-25
读书笔记：剑指offer——名企面试官精讲典型编程题
读书笔记：剑指Offer——名企面试官精讲典型编程题C#版.zip
最新发布
07-25
读书笔记：剑指Offer——名企面试官精讲典型编程题C#版
读书笔记：剑指Offer——名企面试官精讲典型编程题 Javascript版本.zip
07-25
读书笔记：剑指Offer——名企面试官精讲典型编程题 Javascript版本
读书笔记：Leetcode、剑指Offer——名企面试官精讲典型编程题.zip
07-19
读书笔记：Leetcode、剑指Offer——名企面试官精讲典型编程题
剑指Offer
GoJawee的博客
03-09 817
http://m.blog.csdn.net/article/details?id=13000431 找工作是一个长期准备的过程，突击是没什么效果的。准备时间越长，准备就越充分，就越容易拿到好的offer。我基本上从研究生一入学就一直在准备找工作的东西，看书、研究研究笔试面试题、在线编程训练、参加实习招聘等等。当然，其实主要还是研二开始准备的，也算不上多认真，反正一天一天的积累吧。这里我把
剑指offer
没有最好，只有更好！
09-10 4196
剑指offer所有题目总结： 二维数组中的查找 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 class Solution { public: bool Find(vectorvectorint> > array,int target) {
剑指offer-找工作必看的书
xp215774576的专栏
05-28 3997
书的由来：作者海涛2011年9月，发了60篇关于面试的博客，当时点击量超过了70万，网址http://zhedahht.blog.163.com/，后来整理成书，剑指offer,马上要找工作高潮了，准备准备以防不测。1 共享桌面远程面试 是指应聘者把桌面远程传给面试官看。 这时要注意几个问题：(1)思考清楚再写代码。这样就可以少再代码完成以后，修改。要考虑好时间复杂度，空间复制度，有些什么特殊情
剑指offer-----------------------参考推荐
十里の清风
05-08 1601
剑指offer终于第二遍刷完了！ 在这里我要特别的感谢一个博客。 -----------------------（づ￣3￣）づ╭❤～------------------------------ 一首<<The Phoenix>>送给大家，大家学习路上加油！ヾ(◍°∇°◍)ﾉﾞ （传送门：https://music.163.com/#/song?...
剑指Offer——你真的看懂无领导小组面试了吗？
热门推荐
IT全栈 华强工作室
02-18 5万+
剑指Offer——你真的看懂无领导小组面试了吗？什么是无领导小组面试？  “无领导小组讨论”一般会将一定数量的被评人集中起来，不设主持人，让他们就给定的问题进行一定时间长度的讨论。  规则：在讨论过程中，考官只作为旁观者，不参与讨论，不发表任何意见，完全由组员自主进行。在讨论开始后，不得再向考官询问任何问题。  时间：一般为40分钟左右，讨论中各个成员处于平等的地位，并不指定小组的领导者。评委根据被
关于剑指Offer刷题的一些个人理解
呼吸
10-31 614
题目不在于多，而对于精，你可能把这些题都写了一遍，但下次不一定能答上来。我就卡在之字形打印树和反转链表这两道题上（当时有点沙雕了）。 另外不管你把这些题写了几遍，看一看剑指offer这本书还是会受益匪浅的。 我觉得如果把剑指offer真的写会了，直接去刷LeetCode上的hard题就可以了。 ...
1024程序员节推荐书--《剑指Offer》专题突破版
宇宙之一粟的技术漂泊之旅
10-24 3315
《剑指Offer》书评 众所周知，在互联网招聘中，总少不了笔试这一环节。而说到笔试，肯定有一本书会被每一个童鞋提及——那就是《剑指Offer》，在更新了两版后，终于在2021年的夏天这本书也更新了——《剑指Offer》专题突破版。 第一时间拿到这本书后已经开始慢慢阅读起来了。刚好去年也在校招前买了之前的版本，说一下我拿到这本第一感受就是何海涛大佬更用心了。如书名的副标题——专项突破，专题大概可分为两大块：数据结构 + 算法。 可千万别觉得数据结构和算法就此分开了，其实算法的解题套路也是需要一个个数据结构中
二叉树深度计算与剑指Offer面试题解
在《剑指Offer》这本经典的Java面试题集里，第39题涉及的是求解二叉树的深度问题。这个问题的主要目标是给定一棵二叉树，计算从根节点到最远叶子节点的最长路径长度，也就是树的深度。深度定义为从根节点到最远叶子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值