剑指offer（36-40）编程题

• 两个链表的第一个公共结点
• 数字在排序数组中出现的次数
• 二叉树的深度
• 平衡二叉树
• 数组中只出现一次的数字

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

 class Solution1 {
 public:
     ListNode* FindFirstCommonNode(ListNode* pHead1, ListNode* pHead2) {
         ListNode* p = pHead1;
         ListNode* q = pHead2;
         unordered_set<ListNode*> us;
         while (p) {
             us.insert(p);
             p = p->next;
         }
         while (q) {
             if (us.find(q) != us.end()) {
                 return q;
             }
             q = q->next;
         }
         return nullptr;
     }
 };

 class Solution2 {
 public:
     ListNode* FindFirstCommonNode(ListNode* pHead1, ListNode* pHead2) {
         ListNode* p = pHead1;
         ListNode* q = pHead2;
         int n1 = , n2 = ;
         while (p) {
             n1++;
             p = p->next;
         }
         while (q) {
             n2++;
             q = q->next;
         }
         p = pHead1;
         q = pHead2;
         if (n1 > n2) {
             for (int i = ; i < n1 - n2; i++) {
                 p = p->next;
             }
         } else {
             for (int i = ; i < n2 - n1; i++) {
                 q = q->next;
             }
         }
         while (p) {
             if (p == q)
                 return p;
             else {
                 p = p->next;
                 q = q->next;
                 break;
             }
         }
         return p;
     }
 };

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

class Solution {
private:
     //not found ,return -1
    int getFirstK(vector<int>& data, int left, int right, int k) {
        if (left > right) return -;
        int mid = left + (right - left) / ;
        if (data[mid] > k) return getFirstK(data, left, mid - , k);
        else if (data[mid] < k) return getFirstK(data, mid + , right, k);
        else if (data[mid] == k && data[mid - ] == k)
            return getFirstK(data, left, mid - , k);
        else return mid;
    }
     //not found ,return -1
    int getLastK(vector<int>&data,int left,int right,int k){
        if(left > right) return -;
        int mid = left + (right-left)/;
        if(data[mid] < k) return getLastK(data,mid+,right,k);
        else if(data[mid] >k) return getLastK(data,left,mid-,k);
        else if(data[mid] == k && data[mid+] ==k)
            return getLastK(data,mid+,right,k);
        else return mid;
    }
public:
    int GetNumberOfK(vector<int>& data, int k) {
        int n = data.size();
        if(n == ) return ;
        //not found ,return -1
        int firstK = getFirstK(data, , n - , k);
        int lastK = getLastK(data,,n-,k);
        if(firstK == -) return ;
        return lastK - firstK + ;
    }
};

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

 /*
 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 == nullptr) return ;
         int level = ;
         queue<TreeNode*> q1;
         queue<TreeNode*> q2;
         q1.push(pRoot);
         while (!q1.empty()) {
             level++;
             while (!q1.empty()) {
                 TreeNode* tmp = q1.front();
                 q1.pop();
                 if (tmp->left) q2.push(tmp->left);
                 if (tmp->right) q2.push(tmp->right);
             }
             swap(q1, q2);
         }
         return level;
     }
 };

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

 class Solution {
 private:
     bool IsBalanced(TreeNode* pRoot, int& depth) {
         if (pRoot == nullptr) {
             depth = ;
             return true;
         }
         int leftDepth, rightDepth;

         if (IsBalanced(pRoot->left, leftDepth)
                 && IsBalanced(pRoot->right, rightDepth)) {
             if(abs(leftDepth - rightDepth)<){
                 depth = max(leftDepth,rightDepth)+;
                 return true;
             }
         }
         return false;
     }
 public:
     bool IsBalanced_Solution(TreeNode* pRoot) {
         if (pRoot == nullptr) return true;
         int depth = ;
         return IsBalanced(pRoot, depth);
     }
 };

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

 class Solution {
 public:
     void FindNumsAppearOnce(vector<int> data, int* num1, int *num2) {
         int n = data.size();
         int xorAll = ;
         for (int i = ; i < n; i++) {
             xorAll ^= data[i];
         }
         //find first bit is 1
         unsigned int index = ;
         //与或操作记得加括号
         while ((xorAll & ) ==  && index <  * sizeof(int)) {
             index++;
             xorAll = xorAll >> ;
         }
         *num1 = ;
         *num2 = ;
         int splitNum =  << index;
         for (int i = ; i < n; i++) {
             //与或操作要加括号
             if ((data[i] & splitNum) == ) {
                 *num1 ^= data[i];
             } else {
                 *num2 ^= data[i];
             }
         }
     }
 };