【LeetCode】Algorithms 题集（五）

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;    }};