剑指offer 算法 （知识迁移能力）

题目描述

统计一个数字在排序数组中出现的次数。

解析：采用二分查找，搜到数字后在其前后判断并计数

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        int length=data.size();
        if(length <= 0)
            return 0;
        int cnt=0;
        int left=0;
        int right=length-1;
        int mid=(left + right)/2;
        while(k != data[mid] && left < right)
        {
            if(k<data[mid])
            {
                right=mid-1;
                mid=(left + right)/2;
            }
            if(k>data[mid])
            {
                left=mid+1;
                mid=(left + right)/2;
            }
        }
        int flag=0;//搜索标志 找到时为1
        if(k == data[mid])
        {
            cnt++;
            flag=1;
        }
        int pos=mid;
        if(flag)
        {
            int i=mid-1;
            while(data[i]==k)
            {
                cnt++;
                i--;
            }
            i=mid+1;
            while(data[i]==k)
            {
                cnt++;
                i++;
            }
        }
        return cnt;
    }
};

题目描述

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

解析：递归计算结点的左右结点

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
    	if(pRoot==NULL)
            return 0;
        int left=TreeDepth(pRoot->left);
        int right=TreeDepth(pRoot->right);
        return left>right?left+1:right+1;
    }
};

题目描述

输入一棵二叉树，判断该二叉树是否是平衡二叉树。

解析：后序遍历，每遍历一个结点时保存该结点的深度，当某结点不满足条件时返回假

class Solution {
public:
    bool IsBalanced_Solution(TreeNode* pRoot) {
		int depth=0;
        return isBalance(pRoot,&depth);
    }
    bool isBalance(TreeNode* pRoot,int* depth)
    {
        if(pRoot==NULL)
        {
            *depth=0;
            return true;
        }
        int left,right;
        if(isBalance(pRoot->left,&left) && isBalance(pRoot->right,&right))
        {
            int dif=left-right;
            if(dif<=1 && dif>=-1)
            {
                *depth = left > right ? left+1 : right+1;
                return true;
            }
        }
        return false;
    }
};题目描述

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

题目描述

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

解析：亦或处理：相同数字异或结果为零，把数组遍历全部异或，结果必为两个只出现一个的数字的异或结果，由于两个数字不同，必然异或的数存在至少一位为1，找到一位，并以这一位所在数字为0或为1，把整个数组重新分为两个子数组，这样两个不同的数就分到了两个子数组中，再分别遍历异或两个子数组就能得到唯二的两个单独出现的数字

class Solution {
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
		int length=data.size();
        if(length==0 || length==1)
        {
            *num1=0;
            *num2=0;
            return;
        }
        int exclusive=resultExclusive(data);
        int num=1;
        while(exclusive < (num ^ exclusive) )
            num = (num << 1);
   		vector<int> data1;
        vector<int> data2;
        for(int i=0;i<length;i++)
        {
            if((data[i] ^ num) > data[i])
                data1.push_back(data[i]);
            else
                data2.push_back(data[i]);
        }
        *num1=resultExclusive(data1);
        *num2=resultExclusive(data2);
    }
    int resultExclusive(vector<int> data)
    {
        int length=data.size();
        if(length==0)
            return 0;
        int result=0;
        for(int i=0;i<length;i++)
    	{
            result=(result ^ data[i]);
        }
        return result;
    }
};