leetcode随笔

leetcode随笔杂谈

leetcode9道简单题目

1.Given an integer, write a function to determine if it is a power of two.
知识点：二进制的移位操作；能被2的n次幂数用二进制表示只有一个1
方法：
I.①将数字（n=1）与原数字进行与（&）操作②同时进行左移位（<<1）,③求出1的出现的个数。
II.原数字&（原数字-1），如果为2的倍数则结果为0（方法很巧妙）
2.Given an integer, write a function to determine if it is a power of three.
知识点：数学对数换底公式；float的差值是1e-10，其并没有精确值
方法：
将加上abs((int)(i+0.5)-i)进行强制int类型转换,与i值作比较差值小于1e-10则在是其幂次方。（i=log3(n)其对数形式）
3.Happy number
知识点：hashTable应用（c++ set只存储键值）
方法：
①将happy number的和存入set集合.②find set集合当中是否存在sum值（如果存在表明陷入到某个数的loop当中，说明不是happynumber;如果==1则返回true）
4.Ugly Number
知识点：数字找规律
方法：①判断输入值（n）是否能被num=2，3，5整除.②如果能，则updata n=n/num继续判断（终止条件为n是否小于等于7）。
5.Implement Queue using Stacks
知识点：栈的基本概念及操作；队列的基本概念及操作
方法：
I.一个栈作为辅助存储空间，并且始终保持为空。
II.一个栈作为入栈栈，另一个作为出栈栈。
因此知识点很重要，所以代码附到下面：

class Queue {
public:
    // Push element x to the back of queue.
    stack<int> stoSta1,stoSta2;
    void push(int x) 
    {
        if(stoSta2.empty())
            stoSta1.push(x);
        else
        {
            while(stoSta2.size()>0)
            {
                int temp=stoSta2.top();
                stoSta1.push(temp);
                stoSta2.pop();
            }
            stoSta1.push(x);
        }
    }

    // Removes the element from in front of queue.
    void pop(void) 
    {
       if(stoSta2.size()>0)
       {
           stoSta2.pop();
       }
       else
       {
           while(stoSta1.size()>0)
           {
               int temp=stoSta1.top();
               stoSta2.push(temp);
               stoSta1.pop();
           }
           stoSta2.pop();
       }

    }
    // Get the front element.
    int peek(void) 
    {
        if(stoSta2.size()>0)
       {
            return stoSta2.top();
       }
       else
       {
           while(stoSta1.size()>0)
           {
               int temp=stoSta1.top();
               stoSta2.push(temp);
               stoSta1.pop();
           }
           return stoSta2.top();
       }

    }

    // Return whether the queue is empty.
    bool empty(void) 
    {
       if(stoSta1.size()==0&&stoSta2.size()==0)
       return true;
       else
       return false;
    }
};

思路补充:出栈操作保证一个栈为空，入栈操作保证在队1和对2当中交替进行
6.Balanced Binary Tree
知识点：平衡二叉树的左右子树均为平横二叉树；二叉树的深度
方法：
①递归求解二叉树的深度②递归判断二叉树是否为平横二叉树
代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isBalanced(TreeNode* root) 
    {
       if(!root)
       {
           return true;
       }
       int l=pathLengthHeight(root->left);
       int r=pathLengthHeight(root->right);
       if(l-r>1||r-l>1)
       {
           return false;
       }
       return isBalanced(root->left)&&isBalanced(root->right);

    }
    int pathLengthHeight(TreeNode*root)
    {
        if(!root)
        {
            return 0;
        }
        int max1=pathLengthHeight(root->left)+1;
        int max2=pathLengthHeight(root->right)+1;
        return (max1>max2)?max1:max2;
    }
};

python 代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):

    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        if abs(self.depth(root.left)-self.depth(root.right))<=1:
            return self.isBalanced(root.left) and self.isBalanced(root.right)
        else:
            return False
    def depth(self,root):
        if not root:
            return 0
        if root and not root.left and not root.right:
            return 1
        return max(self.depth(root.left)+1,self.depth(root.right)+1)

7.Lowest Common Ancestor of a Binary Search Tree
知识点：二叉排序树的中序便利是有序数组；二叉排序树最低公共祖先的范围[min,max]之间
方法：递归判断二叉树的值是否在[min,max]之间
代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
    {
        int max;
        int min;
        if(p->val>q->val)
        {
            max=p->val;
            min=q->val;
        }
        else
        {
            max=q->val;
            min=p->val;
        }
        if(root->val<=max&&root->val>=min)
        {
            return root;
        }
        if(root->val<min)
        {
            return lowestCommonAncestor(root->right,p,q);
        }
        if(root->val>max)
        {
            return lowestCommonAncestor(root->left,p,q);
        }
    }
};

python 代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if(p.val>q.val):
            temp=p
            p=q
            q=temp
        if root.val>q.val:
            return self.lowestCommonAncestor(root.left,p,q)
        if root.val<p.val:
            return self.lowestCommonAncestor(root.right,p,q)
        return root

8.Climbing Stairs
知识点：动态规划（以后集中讲解）；数学找递归公式;递归与非递归的转换
方法：
①第一次爬一个阶梯则下面有f(n-1)种爬法； ②第一次爬两个阶梯则下面有f(n-2)中爬法③递推规律为：f(n)=f(n-1)+f(n-2);
代码如下：

class Solution {
public:
    int climbStairs(int n)
    {
   /*     if(n==1)
        {
            return 1;
        }
        if(n==2)
        {
            return 2;
        }
        return climbStairs(n-1)+climbStairs(n-2);
    }
    */
       vector<int> sta;
       sta.push_back(1);
        sta.push_back(2);
       for(int i=2;i<n;i++)
        {
           int temp=sta[i-1]+sta[i-2];
           sta.push_back(temp);
        }
        return sta[n-1];
    }
};

9.Roman to Integer
知识点：数学找Roman的规律；HashTable的应用
方法：
①将Roman数字表示的十进制数用HashTable存储（c++ map）②从右向左依次比较Roman数字的十进制值（小则加，大则减）③求出总体的和
代码如下：

class Solution {
public:
    int romanToInt(string s) 
    {
        map<char,int> hashTable;
        hashTable.insert(make_pair('I',1));
        hashTable.insert(make_pair('V',5));
        hashTable.insert(make_pair('X',10));
        hashTable.insert(make_pair('L',50));
        hashTable.insert(make_pair('C',100));
        hashTable.insert(make_pair('D',500));
        hashTable.insert(make_pair('M',1000));
        int sum = hashTable.find(s[s.size() - 1])->second;
        for (int i = s.size() - 1; i > 0; i--)
        {
            if (hashTable.find(s[i])->second <= hashTable.find(s[i - 1])->second)
            {
                sum += hashTable.find(s[i - 1])->second;
            }
            else
            {
                sum -= hashTable.find(s[i - 1])->second;
            }
        }
        return sum;
    }
};

总结

综上，I.我们需要不断储备基础知识：①找数字当中存在的规律②熟悉基本数据结构概念③掌握组成原理里面移位等操作；II.让我们我们一同努力，明天会更好！