【刷题】剑指offer 11~20

JZ11 二进制中1的个数

题目

知识

利用一个结论
原二进制数与该二进制数-1相与会去除最右边的1
假设val=11010101 val-1 = 11010100 而val&（val-1）=11010100
相与是二进制中的计算

问：如果是负数怎么办？负数的相与也是这样吗？补码？
答：是的。例如，-10的二进制表示有30个1（32-2）

代码

class Solution {
public:
    int  NumberOf1(int n) {
        
        int count=0;
        while(n!=0){
            count++;
            n &= (n-1);
        }
        return count;
    }
};

JZ12 数值的整数次方

题目

代码

class Solution {
public:
    double Power(double base, int exponent) {
        // 分两种情况   exponent为正数  或者为负数
        if(exponent<0){ // 若为负数
            base = 1/base;
            exponent = -exponent;
        }
        for(int i =0;i<exponent;++i){
            result *=base;
        }
        
        return result;
    }
};

JZ13 调整数组顺序使奇数位于偶数前面

问题

代码

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param array int整型vector
     * @return int整型vector
     */

    vector<int> reOrderArray(vector<int>& array) {
        // 将奇数放到前面  偶数放到后面
        int length = array.size();
        vector<int> result;
        // 先放奇数
        for (int i = 0; i < length; ++i) {
            if(array[i]%2!=0){
                result.push_back(array[i]);
            }

        }

        // 再放偶数
        for (int j = 0; j < length; ++j) {
            if(array[j]%2==0){
                result.push_back(array[j]);
            }
        }

        return result;
    }
};

JZ14 链表中倒数最后k个结点

题目

代码

// 定义链表
struct ListNode{
    int val;
    struct ListNode * next;
    ListNode(int x):val(x),next(nullptr){}
};

ListNode* FindKthToTail(ListNode* pHead, int k) {
        // 输入 头节点  倒数第K个节点
        // 1.先求链表长度
        int length=0;
        ListNode * cur;
        cur = pHead;
        while(cur){
            length++;
            cur = cur->next;
        }
        // 2.如果链表长度小于k 返回长度为0的链表  直接返回0就可以了  
        if(length<k){
            return 0;
        }

        int i=0;
        while(i!=length-k){
            pHead=pHead->next;
            i++;
        }
        return pHead->next;
    }
};

JZ15

题目

代码

// 与JZ03一样
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode * prev = nullptr;
        ListNode * curr = pHead;
		
		// cur 指向pHead 再向后遍历
        while(curr){
            ListNode * next = curr->next;  // 事先储存下一个节点
            curr->next = prev;  // 将curr指向prev
            // 将prev 和curr同时向后移动
            prev = curr;
            curr = next;
        }
        
        return prev;

    }
};

JZ16 合并两个排序的链表

题目

代码

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        ListNode *vhead = new ListNode(-1);
        ListNode * cur = vhead;
        
        while(pHead1 && pHead2){
            // 判断哪个值比较小
            if(pHead1->val <= pHead2->val){
                cur->next = pHead1;
//                 cur = cur->next;
                pHead1 = pHead1->next;
            }else{
                cur->next = pHead2;
//                 cur = cur->next;
                pHead2= pHead2->next;
            }
             cur = cur->next;
        }
        
        if(pHead1){
            cur->next = pHead1;
        }
        
        if(pHead2){
            cur->next = pHead2;
        }
        
        return vhead->next;
        
        
    }
};

JZ17 树的子结构（不是太理解）

题目

参考:树的子结构.

代码

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    
    /*
     * 第1：在树A中找到和树B的根节点的值一样的节点R，注意树的节点值可以有多个相同的值。
     * 第2：判断树A中以R为根节点的子树是不是包含和B一样的树结构。
     */

    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) { // 输入两个树的根节点
        if(!pRoot1||!pRoot2) return false; //  如果一方为空 返回false
        //  !pRoot1 和pRoot==NULL 有什么区别

        if (isPart(pRoot1,pRoot2)) return true;   //判断树B是不是A的子结构 如果是的话 返回true

        return HasSubtree(pRoot1->right,pRoot2)|| HasSubtree(pRoot1->left,pRoot2);
        //递归树A的左右儿子节点 直到找到或者pRoot变为NULL

    }
    // 判断t1 t2 能不能构成条件  即 比较t1、t2为根节点的树
    bool isPart(TreeNode* t1,TreeNode* t2){
        if(!t2) return true;  //t2已经遍历到了叶节点结束

        if(!t1||t1->val!=t2->val) return false;

        //比较左右子孩子
        return isPart(t1 -> left, t2 -> left) && isPart(t1 -> right, t2 -> right);
        //否则，当t1和t2的根节点相同时，比较孩子是否相同

    }
};

JZ18 二叉树的镜像

题目

代码

class Solution {
public:
    TreeNode* Mirror(TreeNode* pRoot) {
        if(!pRoot) return pRoot;// 递归结束
        
        // 将pRoot的左右节点交换
        TreeNode * temp = pRoot->left;
        pRoot->left = pRoot->right;
        pRoot->right = temp;
        
        // 递归根节点的孩子节点
        Mirror(pRoot->left);
        Mirror(pRoot->right);
        
        // 返回根节点
        return pRoot;
        
        
    }
};

JZ19 顺时针打印矩阵

题目

代码

class Solution {
public:
    void print(vector<vector<int> > matrix, vector<int> &result, int leftX, int leftY, int rightX, int rightY) {
        int i, j;
        for (i = leftX; i <= rightX; i++) {
            result.push_back(matrix[leftY][i]);
        }
        for (j = leftY + 1; j <= rightY; j++) {
            result.push_back(matrix[j][rightX]);
        }
        if (rightY - leftY > 0)
            for (i = rightX - 1; i >= leftX; i--) {
                result.push_back(matrix[rightY][i]);
            }
        if (rightX - leftX > 0)
            for (j = rightY - 1; j >= leftY + 1; j--) {
                result.push_back(matrix[j][leftX]);
            }
    }
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> result;
        if (matrix.empty()) return result;
        int leftX = 0, leftY = 0;
        int rightX = matrix[0].size() - 1;
        int rightY = matrix.size() - 1;
        while (leftX <= rightX && leftY <= rightY) {
            print(matrix, result, leftX++, leftY++, rightX--, rightY--);
        }
        return result;
    }
};

JZ20 包含min函数的栈

题目

代码

class Solution {
public:
// 包含min函数的栈
// 开辟两个栈 一个正常实现栈的功能 一个是实现min函数的功能
    stack<int> normal,minval;
    void push(int value) {
        normal.push(value);
        if(minval.empty()){  // 如果是空的
            minval.push(value);
        }
        else{
            if(value<=minval.top()){  //不是空的，则保证当前最小的数在minval.top()
                minval.push(value);
            }
            else{
                minval.push(minval.top());
            }
        }
    }
    void pop() {
        normal.pop();
        minval.pop();
    }
    int top() {
        return normal.top();
    }
    int min() { // 获取最小值
        return minval.top();
    }
    
    
};