额外题目第2天｜234 143 141 面试题02.07相交链表 205

234 先计数List有多长 将前一半放在一个stack里面 如果奇数就跳过中间node 接着比较节点值与stack里面的数 遇到不同的就return false 直到比较完就true

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        int count=0;
        ListNode* dummy_head = new ListNode(0, head);
        ListNode* curr = dummy_head;
        while (curr->next!=nullptr) {
            curr = curr->next;
            count++;
        }

        stack stack;
        curr = head;
        for (int i=0; ival);
            curr = curr->next;
        }
        if (count%2==1) curr = curr->next;
        while (curr!=nullptr) {
            if (curr->val!=stack.top()) return false;
            curr = curr->next;
            stack.pop();
        }
        return true;
    }
};

143 反转list的后面一半 再将两个list穿插合并在一起

class Solution {
private: 
    ListNode* reverseList (ListNode* head) {
        if (head==nullptr) return nullptr;
        ListNode* temp=head->next;
        head->next = nullptr;
       
        ListNode* pre = head;
        ListNode* curr = temp;     

        while (curr!=nullptr) {
            temp = curr->next;
            curr->next = pre;
            pre = curr;
            curr = temp;
        }
        return pre;
    }
public:
    void reorderList(ListNode* head) {
        int count = 0;
        ListNode* curr = head;
        while (curr!=nullptr) {
            count++;
            curr = curr->next;
        }//calculate the length of the list
        curr = head;
        for (int i=0; inext;
        }
        ListNode* list2 = curr->next;
        curr->next=nullptr;
        ListNode* list1 = head;//list1 is the first half and list2 is the rest

        list2 = reverseList(list2);//reverse the second half
        
        ListNode* l1=list1;
        ListNode* l2=list2;
        while (l1!=nullptr && l2!=nullptr) {
            ListNode* temp1 = l1->next;
            l1->next = l2;
            l1 = temp1;
            ListNode* temp2 = l2->next;
            if (l1!=nullptr) l2->next=l1;//when the length is odd, list2 will be longer than list1
            l2=temp2;
        }//combine the two parts
        head = list1;
    }
};

141 之前做过一题找环形入口的 这题更简单 记得用快慢指针做就可以了！

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        bool flag = true;
        while (flag == true|| slow!=fast) {
            flag = false;
            if (fast==NULL || fast->next==NULL) return false;
            fast = fast->next->next;
            slow = slow->next;
        }
        return true;
    }
};

面试题02.07相交链表 做过的题这次记住了！（表扬自己

因为两个链表在末尾相交 算出两个链表的长度之后 为了右侧对齐 长的那条砍掉前面多出来的几个 然后一一比较 直到两个链表的节点相同 即是交点

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int count1=0; 
        ListNode* curr1 = headA;
        while (curr1!=NULL) {
            count1++;
            curr1 = curr1->next;
        }
        int count2=0;
        ListNode* curr2 = headB;
        while (curr2!=NULL) {
            count2++;
            curr2 = curr2->next;
        }

        if (count1>count2) {
            for (int i=0; inext;
            } 
        }
        else if (count2>count1) {
            for (int i=0; inext;
            }
        }
        while (headA!=headB) {
            headA=headA->next;
            headB=headB->next;
        }
        return headA;
    }
};

205 用umap来一一对应s里的字符在t的映射和t的字符在s里的映射 必须要互相都一一对应 所以要有两个umap来写！！

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        unordered_map  umap1;
        for (int i=0; i umap2;
        for (int i=0; i

简化后的代码如下 cr to 代码随想录

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        unordered_map  umap1;
        unordered_map  umap2;
        for (int i=0; i

1002 写过两遍的题 记得大致思路但是还是没自己写出来

卡住的地方有二：1.不记得有重复元素怎么取公共的 -> 用数组每个word都计数 取最小值

2. char转变成string！！！ string s(1, c); 前面1表示长度 c是char 重要重要！！

class Solution {
public:
    vector commonChars(vector& words) {
        vector hash(26,0);
        for (int j=0; j count(26, 0);
            for (int j=0; j result;
        for (int k=0; k<26; k++) {
            while(hash[k]>0) {
                string s(1, 'a'+k);
                result.push_back(s);
                hash[k]--;
            }
        }
        return result;
    }
};

925 以name为准 一个一个顺着在typed里面找 直到i和j任意一个走到末尾为止

如果相同 两个指针都往后走一个

如果不同 看j是否是因为连按停留在上一个字符 如果没停留在上一个字符或者j==0 就return false

出loop后看是i走完还是j走完 

如果i没走完一定false

如果j没走完 检测j后面剩下的是否都与name的最后一个字符相同 如果出现不同的就是false

class Solution {
public:
    bool isLongPressedName(string name, string typed) {
        int i=0; int j=0;
        while (j

844 我写的->用栈的思路

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        stack stack1;
        for (int i=0; i stack2;
        for (int i=0; i

cr to 代码随想录：

那么本题，确实可以使用栈的思路，但是没有必要使用栈，因为最后比较的时候还要比较栈里的元素，有点麻烦。

这里直接使用字符串string，来作为栈，末尾添加和弹出，string都有相应的接口，最后比较的时候，只要比较两个字符串就可以了，比比较栈里的元素方便一些。

class Solution {
private:
    string get_string (string s) {
        string s1;
        for (int i=0; i

用双指针来写 从后往前遍历 思路好想 但写起来不少很容易 标记一下 以后要来重新写一遍 这遍算边看边写的

要先把两个string的有后退格的都删掉 都停留在最后留下来的字符上

如果任意一个到头 return是否都到头

else 如果不相等return false 相等就都--

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int i=s.size()-1;
        int j=t.size()-1;

        int count1=0; int count2=0;
        while (1) {
            while (i>=0) {
                if (s[i]=='#')  {
                    i--;
                    count1++; 
                }
                else if (count1>0) {
                    i--; 
                    count1--;
                }  
                else break;     
            }
            while (j>=0) {
                if (t[j]=='#')  {
                    j--;
                    count2++;
                }
                else if (count2>0){
                    j--;
                    count2--;
                }
                else break;
            }
               
            if (i<0 || j<0) return i==-1 && j==-1;
            if (s[i]!=t[j]) return false;
            i--; j--;
        }
        return true;
    }
};

129 用回溯法先把每个到达子节点的path记下来 最后再加就可以了

class Solution {
    vector> results;
    
    void backtracking(TreeNode* root, vector& path) {
        if (root->left==nullptr && root->right==nullptr) {
            results.push_back(path);
            return;
        }

        if (root->left) {
            path.push_back(root->left->val);
            backtracking(root->left, path);
            path.pop_back();
        }
        if (root->right) {
            path.push_back(root->right->val);
            backtracking(root->right, path);
            path.pop_back();
        }
        
    }
public:
    int sumNumbers(TreeNode* root) {
        if (!root) return 0;
        vector path;
        path.push_back(root->val);
        backtracking(root, path);

        long sum=0;
        for (int i=0; i=0; j--) {
                num+=results[i][j]*unit;
                unit*=10;
            }
            sum+=num;
        }
        return sum;
    }
};

1382 先变成有序数组（用了递归，明天再试一下不用递归用stack的中序遍历 今天没写出来） 再通过有序数组建立平衡二叉树（这里用左闭右开）

class Solution {
private:
    vector vec;
    void traversal(TreeNode* root) {
        if (root->left) traversal(root->left); 
        vec.push_back(root->val);
        if (root->right) traversal(root->right);
    }
    TreeNode* getTree(vector vecvec, int start, int end) {
        if (start==end) return nullptr;
        int mid = (start+end)/2;
        TreeNode* root = new TreeNode(vecvec[mid]);
        root->left = getTree(vecvec, start, mid);
        root->right = getTree(vecvec, mid+1, end);
        return root;
    }
public:
    TreeNode* balanceBST(TreeNode* root) {
        traversal(root);
        TreeNode* new_tree = getTree(vec, 0, vec.size());
        return new_tree;
    }
};