部分剑指offer习题解析

 

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

class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
    if(!pRoot)
        return 0;
        return max(1+TreeDepth(pRoot->left),1+TreeDepth(pRoot->right));
    }
};

代码解释：

假如是空节点，则返回0；
否则，原树的深度由左右子树中深度较的深度加1，为原树的深度。

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

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

代码解释：每次都交换左右节点的值，然后进行递归。

3.输入两个链表，找出它们的第一个公共结点。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        ListNode *p,*q;
         for(p=pHead1;p!=NULL;p=p->next)
            for(q=pHead2;q!=NULL;q=q->next)
                if(p->val==q->val)
                    return p;
                    return p;
        
    }
};

代码解释：用两个变量分别控制，遇到相同的节点就返回，否则就返回空。

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

题目解析：这可以看作是位运算，我们可以用一个变量控制，初值为1，每次左移一位。

class Solution {
public:
     int  NumberOf1(int n) {
         int sum=0;
    int index=1;
    while (index!=0){
        if ((n&index)!=0){
            sum++;
        }
        index=index<<1;
    }
    return sum;
         
     }
};

5.请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。

class Solution
{
public:
   string str;
    int appear[256] = {0};
      
  //Insert one char from stringstream
    void Insert(char ch)
    {
        str += ch;
        appear[ch]++;
    }
  //return the first appearence once char in current stringstream
    char FirstAppearingOnce()
    {
        int size = str.size();
        for( int i=0; i<size; i++){
            if( appear[ str[i] ] == 1){
                return str[i];
            }
        }
        return '#';
    }
};

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

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
      if(pHead1 == NULL)
            return pHead2;
        if(pHead2 == NULL)
            return pHead1;
        ListNode* Head = NULL;
        if(pHead1->val < pHead2->val){
            Head = pHead1;
            Head->next=Merge(pHead1->next,pHead2);
        }
        else{
            Head = pHead2;
           Head->next=Merge(pHead1,pHead2->next);
        }
        return Head;
    }
        
    
};