剑指offer面试题11-20

最新推荐文章于 2020-06-27 17:11:58 发布

海马HiMark

最新推荐文章于 2020-06-27 17:11:58 发布

阅读量194

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/yu876876/article/details/82590900

版权

C++ 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

#11二进制中1的个数
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

思想：

//定义一个标志位flag，依次将flag向左移位，然后与数组的数字进行按位&
//如果按位与的结果为1则说明输入数的二进制位的值为1
//直到移位到最左端（int 32位）

class Solution {
public:
     int  NumberOf1(int n) {
        unsigned int flag=1;
         int count=0;
        while(flag)
        {
            if(n&flag)
                count++;
            flag=flag<<1;
        }
         return count;
     }
};

思想：
n&(n-1)，第一次按位&后，输入数字的二进制位从右向左少了一个1
直到n的值小于零则循环结束.
这里写图片描述

class Solution {
public:
     static int NumberOf1(int n) {
        int count=0;
         while(n!=0)  //当n不为0时，说明有二进制位为1
         {
             count++;
             n=n&(n-1);    //按位与一次二进制少一个1
         }
         return count;
    }
};

#12数的整数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

思想：分情况讨论
这里写图片描述

class Solution {
public:
    double Power(double base, int exponent) {
        double result=1;
        if(base==0)
            return 0;
        else if(exponent==0)
        {
            return 1;
        }
        else if(exponent<0)
        {
            for(int i=1;i<=(-exponent);i++)
            {
                result*=base;
            }
            return 1/result;
        }
        else
        {
            for(int i=1;i<=exponent;i++)
            {
                result*=base;
            }
            return result;
        }
    }
};

#13调整数组顺序使得奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

思想：定义两个vector，
将第一次遍历出奇数插入到vector
将第二次遍历出偶数插入到vector
然后将vector的值拷贝到数组中

class Solution {
public:
    void reOrderArray(vector<int> &array) {
       //定义一个vector，第一次遍历将奇数插入，第二次遍历将偶数插入
        //然后将vector的值赋值给数组
        vector<int> result;
        for(int i=0;i<array.size();i++)
        {
            if(array[i]%2==1)
                result.push_back(array[i]);
        }
        for(int i=0;i<array.size();i++)
        {
            if(array[i]%2==0)
                result.push_back(array[i]);
        }
        array=result;
    }
};

#14链表倒数第K个结点
输入一个链表，输出该链表中倒数第k个结点。

思想：指针1先走K步，指针2再出发，注意K的合法性检验

这里写图片描述

class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        while(pListHead==NULL||k==0)
            return NULL;
        ListNode* key1=pListHead;
        ListNode* key2=NULL;
        for(int i=1;i<k;i++)   //key1先走K步
        {
            if(key1->next!=NULL)
                key1=key1->next;
            else
                return NULL;
        }
        key2=pListHead;
        while(key1->next!=NULL)  
   //key1，key2同时出发，当key1走到结尾则此时key2的位置就是倒数第K个结点
        {
            key1=key1->next;
            key2=key2->next;
        }
        return key2;
    }
};

#15链表的反转
输入一个链表，反转链表后，输出新链表的表头。
思想：
定义一个新链表，定义一个栈
将旧链表中的结点值入栈，然后将栈中值出栈，插入到新链表中。

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        //借助栈实现，
        //将链表结点插入栈中，将栈中结点插入新结点中
        std::stack<ListNode*> st;
        if(pHead==nullptr||pHead->next==nullptr)
            return pHead;
        ListNode* cur=pHead;
        
        while(cur->next!=nullptr)  //入栈
        {
            st.push(cur);
            cur=cur->next;
        }
        
        ListNode* newhead=cur;
        while(!st.empty()) //出栈
        {
            cur->next=st.top();
            cur=cur->next;
            st.pop();
        }
        cur->next=nullptr;  //下一个置空
        return newhead;        
    }
};

#16合并两个排序链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

思想：
//定义一个新头结点
//比较两个链表结点大小，比较小的结点插入到新头结点中
//递归比较剩下的结点值大小

class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
        //定义一个新的头结点
        //比较两个结点的值，较小值插入新头节点（递归插入）
    {
        if(pHead1==NULL)
            return pHead2;
        if(pHead2==NULL)
            return pHead1;
        ListNode* head;
        if(pHead1->val<pHead2->val) 
        {
            head=pHead1;  
            pHead1->next=Merge(pHead1->next,pHead2);
        }
        else
        {
            head=pHead2;
            pHead2->next=Merge(pHead1,pHead2->next);
        }
        return head;
    }
};

#17树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

思想：
//合法性检验
//选择那个两个结点进行比较
//在Tree1中查找Tree2的结点
//如果Tree2为空说明找到了找完了，如果Tree1为空说明没找到
//如果Tree1和Tree2根结点相同再递归访问左右子树

class Solution {
public:
    bool isSubtree(TreeNode *Tree1, TreeNode *Tree2){
        if(Tree2==NULL) return true;
        if(Tree1==NULL && Tree2!=NULL) return false;
        if(Tree2->val == Tree1->val){
            bool lTree = isSubtree(Tree1->left, Tree2->left);
            bool rTree = isSubtree(Tree1->right, Tree2->right);
            return lTree && rTree;
        }else return false;
    }
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(pRoot1 == NULL || pRoot2 == NULL) return false;
        return isSubtree(pRoot1, pRoot2) || HasSubtree(pRoot1->left, pRoot2)|| HasSubtree(pRoot1->right, pRoot2);
    }
};

#18二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。

思想：
//合法性检验
//定义一个指针，交换根结点左右孩子的地址
//递归遍历根结点的左右孩子结点

class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        //合法性检验
        if(pRoot==NULL)
            return ;
        TreeNode* tmp; //交换左右结点的地址
        tmp=pRoot->left;
        pRoot->left=pRoot->right;
        pRoot->right=tmp;
        
        Mirror(pRoot->left);//递归遍历左子树（其实是右子树）
        Mirror(pRoot->right);//递归遍历右子树（其实是左子树）
        return ;
    }
};

#19顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

思想：
//合法性检验
//定义数组存储序列
//定义上下左右四种边界值，作为循环条件
//判断循环条件（从左到右，从上到下，从右到左，从下到上）

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > mat) {
        int row=mat.size();
        int col=mat[0].size();
        vector<int> ret;  //定义一个数组存储
        if(row==0||col==0) //合法性检验
            return ret;
        int left=0; 
        int right=col-1;
        int top=0;
        int bottom=row-1;
        while(left<=right&&top<=bottom)  //循环条件
        {
            //从左到右插入
            for(int i=left;i<=right;i++) ret.push_back(mat[top][i]);
            //从上到下插入
            for(int i=top+1;i<=bottom;i++) ret.push_back(mat[i][right]);
            //从右到左插入
            for(int i=right-1;i>=left&&top<bottom;i--) ret.push_back(mat[bottom][i]);
            //从下到上插入
            for(int i=bottom-1;i>top&&left<right;i--) ret.push_back(mat[i][left]);
            left++,top++,right--,bottom--;
        }
        return ret;
    }
};

#20包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

思想
栈 3，4，2，5，1
栈 3， 4 ，3 ，2，2，5，2，1，1
//入栈之前先判断如果小于栈顶元素插入两次
//判断如果大于栈顶元素，先插入该元素，再插入旧栈顶元素
//出栈时出栈两次即可

思想2
栈 3，4，2，5，1
辅助栈 3，3，2，2，1
//重新定义一个栈，入栈前先比较如果小于栈顶元素插入到新栈中，再入栈
//如果当前值大于栈顶元素，则入栈然后，将栈顶元素入到新栈
//出栈时辅助栈也出栈，保证辅助栈顶为最小值

class Solution {
public:
    stack<int> datast,minst;
    void push(int value) {
	    datast.push(value);
        if(minst.empty())
            minst.push(value);
        else
            int min=minst.top();  //入栈时入较小值
            value<=min? minst.push(value):minst.push(min);
    }
    void pop() {  //出栈时两个栈都出栈操作
        minst.pop();
        datast.pop();
    }
    int top() {    //正常栈的栈顶元素
        return datast.top();
    }
    int min() {   //最小栈的栈顶元素为最小值
        return minst.top();
    }
};

海马HiMark

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指offer面试题11-20

11二进制中1的个数输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。思想：//定义一个标志位flag，依次将flag向左移位，然后与数组的数字进行按位&amp;amp;amp;amp;amp; //如果按位与的结果为1则说明输入数的二进制位的值为1 //直到移位到最左端（int 32位）class Solution {public: int NumberOf1(int n) {...
复制链接

扫一扫