打卡leetcode第19天

目录

1.删除排序链表中的重复元素

2.二叉树的中序遍历

3. 相同的树

4.字符串相乘

---

1.删除排序链表中的重复元素

【题目】

【分析】

一次遍历

struct ListNode* deleteDuplicates(struct ListNode* head) {
    if (!head) {
        return head;
    }

    struct ListNode* cur = head;
    while (cur->next) {
        if (cur->val == cur->next->val) {
            cur->next = cur->next->next;
        }else{
            cur = cur->next;
        }
    }

    return head;
}

2.二叉树的中序遍历

【题目】给定一个二叉树的根节点 root ，返回它的 中序 遍历。

【分析】

法1：递归

void Traversal(struct TreeNode* root,int *returnNum,int* returnSize )
{
    if(root==NULL)
    {
        return; 
    }
    //左
    Traversal(root->left,returnNum,returnSize);

    //根
    returnNum[*returnSize]   = root->val;       
    *returnSize = *returnSize + 1;//这里不能写++，会发生错误

    //右
    Traversal(root->right,returnNum,returnSize);
}

int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
    //树中节点数目在范围 [0, 100] 内
    int *returnNum = (int *)malloc(sizeof(int)*101);
    *returnSize = 0;
    if(root == NULL)
    {
        return NULL;
    }
    Traversal(root,returnNum,returnSize);
    return returnNum;
}

法2：迭代(栈）

int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
    //树中节点数目在范围 [0, 100] 内
    *returnSize = 0;
    int* returnNum = (int*)malloc(sizeof(int) * 101);
    if (root == NULL)
    {
        return returnNum;
    }

    struct TreeNode* stack[101];
    struct TreeNode* nodeIt;
    int               top = 0;
    nodeIt = root;
    //中序遍历左根右
    while (top > 0 || nodeIt != NULL)
    {
        while (nodeIt != NULL)
        {
            //判断根左右结点关系
            stack[top++] = nodeIt;
            nodeIt = nodeIt->left;
        }
        nodeIt = stack[--top];
        returnNum[*returnSize] = nodeIt->val;
        *returnSize = *returnSize + 1;
        nodeIt = nodeIt->right;
    }
    return returnNum;
}

3. 相同的树

【题目】

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

 

【分析】

法1：先序遍历

bool Traversal(struct TreeNode* p,struct TreeNode* q){
    if(p==NULL&&q==NULL){
        return true;
    }
    if(p==NULL||q==NULL){
        return false;
    }
    if(p->val!=q->val){
        return false;
    }
    if(Traversal(p->left,q->left)==false){
        return false;
    }
    if(Traversal(p->right,q->right)==false){
        return false;
    }
    return true;
}

bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    
    bool isSame=true;
    isSame=Traversal(p,q);
    return isSame;
}

法2：递归

bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    if(!p && !q)
        return true;
    if(!p || !q)
        return false;
    if(p->val == q->val)
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    else
        return false;

}

4.字符串相乘

 【分析】

class Solution {
public:
    string multiply(string num1, string num2) {
        vector<int> A, B;
        int n = num1.size(), m = num2.size();
        for (int i = n - 1; i >= 0; i -- ) A.push_back(num1[i] - '0'); //反向存贮
        for (int i = m - 1; i >= 0; i -- ) B.push_back(num2[i] - '0');
        vector<int> C(n + m);
        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < m; j ++ )
                C[i + j] += A[i] * B[j];
        int t = 0;  //存贮进位
        for (int i = 0; i < C.size(); i ++ ) {
            t += C[i];
            C[i] = t % 10;
            t /= 10;
        }
        int k = C.size() - 1;
        while (k > 0 && !C[k]) k -- ;  //去除前导0
        string res;
        while (k >= 0) res += C[k -- ] + '0';  //反转
        return res;
    }
};