Merge Two Sorted Lists
题意:
Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
思路:
合并两个链表,考察的是指针操作。多注意指针是否为空,指针操作需谨慎。有两种情况:
1.其中一个链表为空,则直接返回另一个链表。
2.合并过程中,一个链表已经走到了末尾,即移动到了空指针,但另一个链表还剩下一段,则把剩下的这段接到合并后列表的最后
剩下都就是合并过程中的指针的值的比较而已。
代码:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
/* 有一个为空,合并后为非空的另一个链表 */
if(l1 == NULL)
return l2;
if(l2 == NULL)
return l1;
ListNode *head = NULL, *cur = NULL;
/* 初始化头指针 */
if(l1->val < l2->val)
{
head = l1;
l1 = l1->next;
}
else
{
head = l2;
l2 = l2->next;
}
/* 当前指针 */
cur = head;
/* 要两个链表都非空才可以一直往后合并 */
while(l1 && l2)
{
if(l1->val < l2->val)
{
cur->next = l1;
cur = cur->next;
l1 = l1->next;
}
else
{
cur->next = l2;
cur = cur->next;
l2 = l2->next;
}
}
/* 其中一个为空之后,把另一个非空的链表接到合并后链表的最后 */
if(l1) cur->next = l1;
else if(l2) cur->next = l2;
return head;
}
};
Balanced Binary Tree
题意:
Given a binary tree, determine if it is height-balanced.
For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
思路:
判断一棵二叉树是否是平衡的,只要递归判断左右子树的高度。如果左右子树不再平衡,那么改变条件变量,递归返回。
代码:
/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isBalanced(TreeNode *root) {
height(root);
return flag;
}
private:
bool flag = true;
int height(TreeNode* root)
{
if(!flag) return -1;
if(!root) return 0;
int l = height(root->left);
int r = height(root->right);
if(abs(l - r) > 1) flag = false;
return (l>r?l:r) + 1;
}
};
Binary Tree Postorder Traversal
题意:
Given a binary tree, return the postorder traversal of its nodes' values.
For example:
Given binary tree {1,#,2,3}
,
1 \ 2 / 3
return [3,2,1]
.
Note: Recursive solution is trivial, could you do it iteratively?
思路:
非递归地遍历二叉树。坑爹...一开始用 if(!cur->left) 的形式来测试空指针...结果一直 runtime error....原来空指针的 bool 值不为 false 啊....
二叉树的前序和中序的非递归遍历比较好做,后序比较难想。不过思路还是用 stack 来解决的。我们需要思考一个问题,什么时候才可以访问一个元素(即遍历时处理到它)?
我们考虑对一个栈顶元素 cur ,如果:
- cur 的左右子树都是空的,那么可以对它进行出栈访问。
- 如果上个出栈的元素(被处理的元素)是 cur 的右子树,那么 cur 可以出栈访问,因为它的左右子树都被处理完了。
- 如果上个出栈的元素是 cur 的左子树,那么 cur 可以出栈访问,因为这意味着 cur 没有右子树而且左子树被处理完了。
代码:
/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<int> postorderTraversal(TreeNode *root) {
vector<int> ans;
stack<TreeNode*> node;
if(root == NULL) return ans;
node.push(root);
TreeNode* last = root;
while(!node.empty())
{
TreeNode* cur = node.top();
if(last == cur->right || last == cur->left || ((cur->right == NULL) && ( cur->left == NULL)))
{
ans.push_back(cur->val);
node.pop();
last = cur;
} else {
if(cur->right != NULL) node.push(cur->right);
if(cur->left != NULL) node.push(cur->left);
}
}
return ans;
}
};
Number of 1 Bits
题意:
Write a function that takes an unsigned integer and returns the number of ’1' bits it has (also known as the Hamming weight).
For example, the 32-bit integer ’11' has binary representation 00000000000000000000000000001011, so the function should return 3.
思路:
计算一个无符号 32 位整数的二进制表示有多少个 1. 只要每次取最后一位判断是否是 1, 然后进行右移操作就好。复杂度 O(32).
代码:
class Solution {
public:
int hammingWeight(uint32_t n) {
int ans = 0;
for(int i = 0;i < 32;++i)
{
if(n & 1) ans++;
n = n >> 1;
}
return ans;
}
};
Unique Paths
题意:
A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).
The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
How many possible unique paths are there?
Above is a 3 x 7 grid. How many possible unique paths are there?
Note: m and n will be at most 100.
思路:
机器人只能向右走和向下走,那么我们可以很容易想到,到一个点的路径数,是不是等于到这个点的左边的点的路径数,加上到达这个点的上边的点的路径数。
接下来考虑特殊情况,第一列的点,左边没有其他点,所以只能通过它上方的点到达。第一行的点,只能通过它左边的点到达,再想一下,第一行的点的路径数是不是只能为 1?
看到这里,你是不是想用二维数组?其实没有必要,因为我们不需要那么多状态的记录。我们仅仅需要的是上一次迭代的结果(也就是上一行)。假如我用一个长度为 n 的一维数组保存到达一行的点的路径数的话,那么用 m-1 次迭代(为什么用 m - 1?),每次迭代时数组一开始保存的就是上一行的计算结果,这时候我只要让这个点加等于它左边的点的路径数,就得到该点的结果了。
代码:
class Solution {
public:
int uniquePaths(int m, int n) {
int* dp = new int[n];
for(int i = 0;i < n;++i)
dp[i] = 1;
for(int i = 1;i < m;++i)
{
for(int j = 1;j < n;++j)
{
dp[j] += dp[j-1];
}
}
int ans = dp[n-1];
delete []dp;
return ans;
}
};