代码随想录DAY64

class Solution {

public:

    int searchInsert(vector<int>& nums, int target) {

        int left=0;

        int right=nums.size()-1;

        for(;left<=right;){

            int mid=(left+right)/2;

            if(target>nums[mid]){

                left=mid+1;

            }

            else if(target<nums[mid]){

                right=mid-1;

            }

            else{

                return mid;

            }

        }

        if(left==nums.size()){

            return left;

        }

        if(right==-1){

            return 0;

        }

            return right+1;

    }

};

这个题还是很简单的 几乎是一遍过 但是要注意几个点

1 

if(left==nums.size()){

            return left;

        }

        if(right==-1){

            return 0;

        }

其实完全不用写 直接return right+1就好了 

因为找不到的话 left和right永远会相差一 也就是把元素刚好夹住 nums[right]在左边 小于元素 nums[left]在右边大于元素 找到的话 像之前那个边界题 肯定就相差大于1了

class Solution {

public:

    ListNode* swapPairs(ListNode* head) {

     ListNode * prehead=new ListNode;

     prehead->next= head;

     ListNode* p=head;

     ListNode* pre=prehead;

     while(p!=NULL && p->next!=NULL){

         pre->next=p->next;

         ListNode* temp=p->next->next;

         p->next->next=p;

         p->next=temp;

       

         pre=p;

         p=p->next;

     }

     ListNode* temp=prehead->next;

     delete(prehead);

     return temp;

     

    }

};

做过的题 就是要注意下边界条件 其他的还是一遍过的 简单

 

class Solution {

public:

    bool isPalindrome(ListNode* head) {

         if (head->next == nullptr) return true;

        ListNode*p=head;

        ListNode*fast=head;

        ListNode*pre=NULL;

        while(fast!=NULL&&fast->next!=NULL){

            fast=fast->next->next;

            pre=p;

            p=p->next;

        }

        pre->next=NULL;

        ListNode*q=NULL;

        while(p!=NULL){

            ListNode*temp=p->next;

            p->next=q;

            q=p;

            p=temp;

        }

        pre=head;

        while(pre!=NULL){

            if(q->val!=pre->val)

                return false;

            q=q->next;

            pre=pre->next;

        }

        return true;

        }

};

 

还是练习的不够啊 还是得多练啊

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        vector<int> vec;
        ListNode* cur  = head;
        while (cur) {
            vec.push_back(cur->val);
            cur = cur->next;
        }
        // 比较数组回文
        for (int i = 0, j = vec.size() - 1; i < j; i++, j--) {
            if (vec[i] != vec[j]) return false;
        }
        return true;
    }
};

 

class Solution {

public:

    bool isPalindrome(ListNode* head) {

        ListNode*p=head;

        vector<int>result;

        while(p!=NULL){

            result.push_back(p->val);

        }

        for(int i=0;i<result.size();i++){

            if(result[0]!=result[result.size()-1])

                return false;

        }

            return true;

    }

};

 

class Solution {

public:

    bool isPalindrome(ListNode* head) {

        ListNode*p=head;

        vector<int>result;

        while(p!=NULL){

            result.push_back(p->val);

            p=p->next;

        }

        for(int i=0;i<result.size()/2;i++){

            if(result[i]!=result[result.size()-i-1])

                return false;

        }

            return true;

    }

};