细节决定成败！华为面试题库刷题整理（三）

写在前面

华为面试题库刷题第三次整理。

203. 移除链表元素

删除链表中等于给定值 val 的所有节点。

示例:

输入: 1->2->6->3->4->5->6, val = 6

输出: 1->2->3->4->5

解法：题目不难，重点是用多钟解法来解题。

递归

从尾部开始删除就不需要特别记录前一个节点，利用递归在这一点上就很讨巧。

代码：

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(!head) return NULL;//递归边界
        head->next = removeElements(head->next,val);//递去：到底端再开始删除操作
        return head->val==val?head->next:head;//递归式
    }
};

迭代

遍历链表，删除节点。每次判断的都是下一位，这样方便删除，然后再最后return位置特判头。

代码：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(!head) return NULL;
        ListNode *curr, * del;
        curr = head;
        while(curr->next){
            if(curr->next->val==val){//删除下一位
                del = curr->next;
                curr->next = del->next;
                delete del;
            }
            else{
                curr = curr->next;
            }
        }
        return head->val==val?head->next:head;//头元素特判
    }
};

538. 把二叉搜索树转换为累加树

给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。

例如：

输入: 原始二叉搜索树:

        5

        /   \

      2   13

输出: 转换为累加树:

        18

        /   \

      20  13

解法：加上所有比这个节点大的，大的都在右边，所以从右往左遍历并累加就行了。

递归

代码：

/**
* 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 {
private:
    int sum = 0;
public:
    TreeNode* convertBST(TreeNode* root) {
        if(root){
            convertBST(root->right);//遍历右子树
            sum += root->val;//累加
            root->val = sum;//更新数值
            convertBST(root->left);//遍历左子树
        }
        return root;
    }
};

迭代

其实和递归大同小异，只不过把递归过程放进了循环里面。

代码：

class Solution {
public:
    TreeNode* convertBST(TreeNode* root) {
        int sum = 0;
        TreeNode* t = root;
        vector<TreeNode*> s;
        while(!s.empty()||t){
            while(t){
                s.push_back(t);
                t = t->right;
            }
            t = s.back();
            s.pop_back();
            sum += t->val;
            t -> val = sum;
            t = t -> left;
        }
        return root;
    }
};

820. 单词的压缩编码

给定一个单词列表，我们将这个列表编码成一个索引字符串 S 与一个索引列表 A。

例如，如果这个列表是 [“time”, “me”, “bell”]，我们就可以将其表示为 S = “time#bell#” 和 indexes = [0, 2, 5]。

对于每一个索引，我们可以通过从字符串 S 中索引的位置开始读取字符串，直到 “#” 结束，来恢复我们之前的单词列表。

那么成功对给定单词列表进行编码的最小字符串长度是多少呢？

提示：

1. 1 <= words.length <= 2000
2. 1 <= words[i].length <= 7
3. 每个单词都是小写字母 。

解法：

后缀字符串

一个数组如果是另外一个字符串的后缀字符串，就会被删除，因为数据的单词长度不超过7，穷举即可，为了方便除重和删除操作，我们这里利用set数据结构。

代码：

class Solution {
public:
    int minimumLengthEncodi