面试笔试杂项积累-leetcode 231-235

231.231-Power of Two-Difficulty: Easy

Given an integer, write a function to determine if it is a power of two.

方法一

思路

判断一个数是否是2的幂

除和取余，循环

public class Solution {
public bool IsPowerOfTwo(int n) {
if (n <= 0)
return false;
while (n > 1)
{
if (n % 2 != 0)
return false;
n = (int)(n * 0.5);

}
return true;
}
}

方法二

思路

位运算1

参考：
https://leetcode.com/discuss/78667/java-solution-with-explanation
public class Solution {

public boolean isPowerOfTwo(int n) {
if(n <= 0){ return false;}
int m = -n;

// m is completely different with n except the last position of 1.

// For example if n = 5, i.e., 0000 0101, m would be 1111 1011

m &= n;// m only have the last digit of n to be 1.
return m == n;
}

}

方法三

思路

位运算2

参考：
https://leetcode.com/discuss/78626/easy-java-bit-shift-solution
public class Solution {
public boolean isPowerOfTwo(int n) {
if(n < 1) return false;
if(n == 1) return true;
while((n & 1) != 1){
n >>= 1;
}
if(n > 1) return false;
else return true;
}
}

方法四

思路

一种投机的方法

超过测试数值平方的数，肯定能除开测试数值所有的二的幂

参考：
https://leetcode.com/discuss/83100/how-about-this-trick
bool isPowerOfTwo(int n) {
if(n<1) return false;
return 4294967296%n==0 ? 1: 0;
}

232.232-Implement Queue using Stacks-Difficulty: Easy

Implement the following operations of a queue using stacks.

push(x) -- Push element x to the back of queue.
pop() -- Removes the element from in front of queue.
peek() -- Get the front element.
empty() -- Return whether the queue is empty.
Notes:

You must use only standard operations of a stack -- which means only

push to top

,

peek/pop from top

,

size

, and

is empty

operations are valid.
Depending on your language, stack may not be supported natively. You may simulate a stack by using a list or deque (double-ended queue), as long as you use only standard operations of a stack.
You may assume that all operations are valid (for example, no pop or peek operations will be called on an empty queue).

思路

使用栈来模拟队列

同225题

在push中颠倒过来即可，其他操作不变

public class Queue {
Stack<int> stack = new Stack<int>();
// Push element x to the back of queue.
public void Push(int x)
{
if (Empty())
stack.Push(x);
else
{
Stack<int> temp = new Stack<int>();
while (stack.Count > 0)
temp.Push(stack.Pop());
stack.Push(x);
while (temp.Count > 0)
stack.Push(temp.Pop());

}

}

// Removes the element from front of queue.
public void Pop()
{
stack.Pop();
}

// Get the front element.
public int Peek()
{
return stack.Peek();
}

// Return whether the queue is empty.
public bool Empty()
{
return stack.Count <= 0 ? true : false;
}
}

233.233-Number of Digit One-Difficulty: Medium

Given an integer n, count the total number of digit 1 appearing in all non-negative integers less than or equal to n.

For example:

Given n = 13,

Return 6, because digit 1 occurred in the following numbers: 1, 10, 11, 12, 13.

Hint:

Beware of overflow.

方法一

思路

n以内所有含1的数

开始打算转换成string一个一个比对，理所当然的超时了。

这道题考查的是math

参考：
https://leetcode.com/discuss/64604/my-simple-and-understandable-java-solution
/**
* Calculate occurance on every digit, from
* least important digit to most important digit
* number = 1432
* One's digit: n/10=143 143*1+1
* Ten's digit: n/100=14 14*10+10
* Hun's digit: n/1000=1 1*100+100
* Tho's digit: 1432%1000+1=433
* Sum all occurance on digits together
*/
public static int countDigitOne(int k) {
int count = 0, factor = 1, n = k;
while(n>0){
int m = n/10, r = n%10, amount;

if(r == 0) amount = 0;
else if(r > 1) amount = factor;
else amount = k%factor+1;

count += m*factor + amount;
factor *= 10;
n = n/10;
}
return count;
}

方法二

思路

参考：
https://leetcode.com/discuss/64962/java-python-one-pass-solution-easy-to-understand
The idea is to calculate occurrence of 1 on every digit. There are 3 scenarios, for example

if n = xyzdabc

and we are considering the occurrence of one on thousand, it should be:

(1) xyz * 1000                     if d == 0
(2) xyz * 1000 + abc + 1           if d == 1
(3) xyz * 1000 + 1000              if d > 1

iterate through all digits and sum them all will give the final answer

public class Solution {
public int CountDigitOne(int n) {

if (n <= 0) return 0;
int q = n, x = 1, ans = 0;
do {
int digit = q % 10;
q /= 10;
ans += q * x;
if (digit == 1) ans += n % x + 1;
if (digit > 1) ans += x;
x *= 10;
} while (q > 0);
return ans;
}
}

234.234-Palindrome Linked List-Difficulty: Easy

Given a singly linked list, determine if it is a palindrome.

Follow up:

Could you do it in O(n) time and O(1) space?

方法一

思路

判断链表是否是回文

最容易想到的方法是找一个list存起来，再反过来与链表前一半比较，但是不符合in O(n) time and O(1) space

/**
* Definition for singly-linked list.
* public class ListNode {
* public int val;
* public ListNode next;
* public ListNode(int x) { val = x; }
* }
*/
public class Solution {
public bool IsPalindrome(ListNode head) {
IList<int> list = new List<int>();
ListNode temp = head;
while (temp != null)
{
list.Add(temp.val);
temp = temp.next;
}
temp = head;
for (int i = list.Count - 1; i > list.Count / 2-1; i--)
{
if (list[i] != temp.val)
return false;
temp = temp.next;

}
return true;
}
}

方法二

思路

递归

参考： https://leetcode.com/discuss/82586/share-my-short-c-recursive-solution-i-believe-its-o-1-space
class Solution {

public:
bool isPalindrome(ListNode* head) {
ListNode *cur = head;//this is the normal cursor
return judge(head, cur);
}
bool judge(ListNode *head, ListNode* &cur) {
if (!head) return true;
if (!judge(head->next, cur)) return false;
if (cur->val != head->val) return false;
else {cur = cur->next; return true;}
}
};

235.235-Lowest Common Ancestor of a Binary Search Tree-Difficulty: Easy

Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

According to the
definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow
a node to be a descendant of itself).”

_______6______
/              \
___2__          ___8__
/      \        /      \
0      _4       7       9
/  \
3   5

For example, the lowest common ancestor (LCA) of nodes

2

and

8

is

6

. Another example is LCA of nodes

2

and

4

is

2

, since a node can be a descendant of itself according to the LCA definition.

思路

最近相同根节点，在二叉搜索树中

两个节点，根据二叉搜索树的性质，遍历中节点大小在二节点之间的就是最近相同根节点

/**
* Definition for a binary tree node.
* public class TreeNode {
*     public int val;
*     public TreeNode left;
*     public TreeNode right;
*     public TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
TreeNode min = p.val <= q.val ? p : q;
TreeNode max = p.val > q.val ? p : q;
return printNode(root,min.val,max.val);
}
TreeNode printNode(TreeNode root, int min, int max)//夹在中间的就是共同的根节点
{
if (root.val >= min && root.val <= max)
return root;
else if (root.val > max)
return printNode(root.left, min, max);
else //if (root.val < min)
return printNode(root.right, min, max);
}
}