Leetcode Day2

第4题： 

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) 
    {
        string result = "";
        int num = strs.size();
        string object = strs[0];
        int flag = 1;
        for(int i = 0;i<object.length();i++)
        {
            for(int j = 1;j<num;j++)
            {
                if(object[i] != strs[j][i])
                flag = 0;
            }
            if(flag == 1)
            result += object[i];
            if(flag == 0)
            break;
        }
        return result;
    }
};

要点：设置标记位！！！从而判断是否多个字符串符合条件。

第5题：

class Solution {
public:
    bool isValid(string s) 
    {
       stack<char> St;
    for(int i =0;i<s.length();i++)
    {
        if(s[i] == '(' || s[i] == '[' || s[i] =='{')
        St.push(s[i]);
        else if(s[i] == ')'&& !St.empty()&& St.top() == '(')
        St.pop( );
        else if(s[i] == ']'&& !St.empty()&& St.top() == '[')
        St.pop( );
        else if(s[i] == '}'&&  !St.empty()&& St.top() == '{')
        St.pop( );
        else 
        {
            return false;
        }
        
    }
    if( St.empty())
    return true;
    else 
    return false;
    }
};

收获：

1.stack有库代码，直接调用：

 2.在取栈顶元素以前，必须判断栈是否为空，如果空，就不能取，否则有内存不可读的问题；

3.可以不用在最后一句话返回，提前返回也可以，但最后的返回也不能忘记，要保证所有路径都可以返回。

第6题：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) 
    {
        ListNode dummy = ListNode(-1);
        ListNode* prev = &dummy;
        
        while(list1 != nullptr && list2 != nullptr)
        {
            if(list1->val< list2->val)
            {
                prev->next = list1;
                list1 = list1->next;
            }
            else
            {
                prev->next = list2;
                list2 = list2->next;
            }
            prev = prev->next;
        }
        prev->next = (list1==nullptr ?list2 : list1);
         return dummy.next;
    }
   
};

 收获：

1.不需要新分配空间，只要指向原有空间即可；

2.链表合并，有一个哑节点来保存首地址，因为随着链表的创建，指针最终指向了最后一个结构，因为需要保存起始位置来进行返回，也可以有一个指针来保存起始位置，；

4.*next就是指向该结构的指针，所以直接指向list1，而不是去指向list1->next;

5.最后通过一个三目运算符来判断指向哪个链条。