剑指OFFER11-20题

二进制中1的个数

class Solution {
public:
     int  NumberOf1(int n) {
         int ans=0;
         for(int i=0;i<=32;i++){
             if(1&(n>>i))ans++;
         }
         return ans;
     }
};

数值的整数次方

class Solution {
public:
    double Power(double base, int exponent) {
        return pow(base,exponent);
    }
};

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

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        vector<int>a,b;
        for(int i=0;i<array.size();i++){
            if(array[i]%2==1)a.push_back(array[i]);
            else b.push_back(array[i]);
        }
        array.clear();
        for(int i=0;i<a.size();i++){
            array.push_back(a[i]);
        }
        for(int i=0;i<b.size();i++){
            array.push_back(b[i]);
        }
    }
};

链表中倒数第k个结点

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    vector<ListNode*> tmp;
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        ListNode* p=pListHead;
        while(p!=NULL){
            tmp.push_back(p);
            p=p->next;
        }
        if(tmp.size()<k)return NULL;
        return tmp[tmp.size()-k];
    }
};

反转链表

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    vector<ListNode*> tmp;
    ListNode* ReverseList(ListNode* pHead) {
        if(pHead==NULL)return NULL;
        ListNode* p=pHead;
        while(p!=NULL){
            tmp.push_back(p);
            p=p->next;
        }
        for(int i=tmp.size()-1;i>=1;i--){
            tmp[i]->next=tmp[i-1];
        }
        tmp[0]->next=NULL;
        return tmp[tmp.size()-1];
    }
};

合并两个排序的链表

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    //ListNode* tmp[100003];
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2){
        if(pHead1==NULL)return pHead2;
        if(pHead2==NULL)return pHead1;
        
        ListNode* p1=pHead1;
        ListNode* p2=pHead2;
        ListNode* head = new ListNode(0) ;
        if(p1->val<=p2->val)head->val=p1->val,p1=p1->next;
        else head->val=p2->val,p2=p2->next;
        
        ListNode* p = head ;
        while(p1!=NULL&&p2!=NULL){
            ListNode* s = new ListNode(0) ;
            if(p1->val<=p2->val){
                s->val=p1->val;
                p1=p1->next;
            }
            else{
                s->val=p2->val;
                p2=p2->next;
            }
            p->next=s;
            p=s;
        }
        while(p1!=NULL){
            ListNode* s = new ListNode(p1->val) ;
            p1=p1->next;
            p->next=s;
            p=s;
        }
        while(p2!=NULL){
            ListNode* s = new ListNode(p2->val) ;
            p2=p2->next;
            p->next=s;
            p=s;
        }
        p->next=NULL;
        return head;
    }
};

树的子结构

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    bool dfs(TreeNode* r1,TreeNode* r2){
        if(r2==NULL)return true;
        if(r1==NULL)return false;
        if(r1->val==r2->val){
            if( dfs(r1->left,r2->left) && dfs(r1->right,r2->right) ) return true;
        }
        if( dfs(r1->left,r2) ) return true;
        if( dfs(r1->right,r2) ) return true;
        return false;
    }
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(pRoot1==NULL || pRoot2==NULL)return false;
        return dfs(pRoot1,pRoot2);

    }
};

二叉树的镜像

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void dfs(TreeNode* r){
        if(r==NULL)return ;
        TreeNode* tmp=r->left;
        r->left=r->right;
        r->right=tmp;
        dfs(r->left);
        dfs(r->right);
    }
    void Mirror(TreeNode *pRoot) {
        dfs(pRoot);
    }
};

顺时针打印矩阵

class Solution {
public:
    int dy[4]={1,0,-1,0};
    int dx[4]={0,1,0,-1};
    int dir=0,x=0,y=0,nx,ny;
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> ans;
        ans.push_back(matrix[x][y]);
        matrix[x][y]=-1;
        while(1){
            nx=x+dx[dir],ny=y+dy[dir];
            //如果撞墙就转方向
            if( nx<0 || nx>=matrix.size() || ny<0 || ny>=matrix[0].size() || matrix[nx][ny]==-1 ){
                dir=(dir+1)%4;
                nx=x+dx[dir],ny=y+dy[dir];
                //再判转方向后的点如果还是撞就跳出
                if( nx<0 || nx>=matrix.size() || ny<0 || ny>=matrix[0].size() || matrix[nx][ny]==-1 ){
                    return ans;
                }else{//没有撞的话就继续移动
                    x=nx;
                    y=ny;
                    ans.push_back(matrix[x][y]);
                    matrix[x][y]=-1;
                }
            }else{//没有撞的话就继续移动
                x=nx;
                y=ny;
                ans.push_back(matrix[x][y]);
                matrix[x][y]=-1;
            }
        }
        return ans; 
    }
};

包含min函数的栈

class Solution {
public:
    //开一个数组维护到当前深度下的栈里值的最小值
    vector<int> ans;
    stack<int> sk;
    void push(int value) {
        sk.push(value);
        if(ans.size()==0)ans.push_back(value);
        else ans.push_back(ans[ans.size()-1]<value?ans[ans.size()-1]:value);
    }
    void pop() {
        sk.pop();
        ans.resize(ans.size()-1);
    }
    int top() {
        return sk.top();
    }
    int min() {
        return ans[ans.size()-1];
    }
};