[学习笔记-C++篇]数组和字符串

1. 中心下标查找程序。

---

v1.0版本

该版本最基础，分别计算第i个下标左、右的元素和进行比较。思路简单，但是遍历下标需要重复计算，运算时间太长。

class Solution {
public:
    int pivotIndex(vector<int>& nums) 
    {
        int midnum=-1;
        for (int i=0;i<nums.size();i++)
        {
            int sum_left=0;
            int sum_right=0;
            for (int j=0;j<i;j++)
            {
                sum_left=nums[j]+sum_left;
            }
            for (int k=i+1;k<nums.size();k++)
            {
                sum_right=nums[k]+sum_right;
            }
            if (sum_left==sum_right)
            {
                midnum=i;
                break;
            }
        }
        return midnum;
    }
};

---

v2.0版本

该版本改进了一点点，首先计算一个所有元素之和，每次遍历左边元素之和，右边元素和直接作差得到。时间上好了一点，但还是很长，算法还是太麻烦。想想每次遍历求和是最费时间的，如果可以简化这个步骤会快很多。
执行用时：716 ms。内存消耗：30.2 MB。

class Solution {
public:
    int pivotIndex(vector<int>& nums) 
    {
        int sum_all=0;//数组元素和
        for (int p=0;p<nums.size();p++)
        {
            sum_all+=nums[p];
        }

        int midnum=-1;
        for (int i=0;i<nums.size();i++)
        {
            int sum_left=0;
            int sum_right=0;
            for (int j=0;j<i;j++)
            {
                sum_left=nums[j]+sum_left;
            }
            sum_right=sum_all-sum_left-nums[i];
            
            if (sum_left==sum_right)
            {
                midnum=i;
                break;
            }
        }
        return midnum;
    }
};

---

v3.0版本

该版本大幅改进运算时间。将左边元素和变为每次累加中间下标元素的前一位元素，右边元素和变为所有元素和减去中间下标元素。内存消耗变大了，别看只大了0.1MB，但是一下就落后35%的人。
执行用时：16 ms。内存消耗：30.3 MB

class Solution {
public:
    int pivotIndex(vector<int>& nums) 
    {
        int sum_all=0;//数组元素和
        for (int p=0;p<nums.size();p++)
        {
            sum_all+=nums[p];
        }

        int midnum=-1;
        int sum_left=0;
        int sum_right=sum_all;

        for (int i=0;i<nums.size();i++)
        {
            if(i==0) sum_left=0;
            else sum_left=nums[i-1]+sum_left;
            sum_right-=nums[i];
            
            if (sum_left==sum_right)
            {
                midnum=i;
                break;
            }
        }
        return midnum;
    }
};

---

版本对比

果然车轮还是比较费时间和内存的。该作者也提供了这种思路左和*2+中心值=总和。时间会略长一点（16ms），内存消耗会更少（30.1MB）。
执行用时：12 ms。内存消耗：30.2 MB。
参考：https://leetcode-cn.com/leetbook/read/array-and-string/yf47s/?discussion=uyHT4S

class Solution {
public:
    int pivotIndex(vector<int>& nums) {
        if(nums.empty()) //先检查数组是否为空
        {return -1;}
        //先把左和以及右和计算出来
        //在后续遍历数组的过程中,我们计算左和以及右和只要在每次遍历中加/减当前元素的值即可
        int leftsum = 0;int rightsum =accumulate(nums.begin(),nums.end(),0);
        for(int i=0;i<nums.size();i++)
        {
            rightsum -= nums[i];
            if(leftsum == rightsum)
            {return i;}
            else
            {leftsum += nums[i];}
        }
        return -1;
    }
};

class Solution {
public:
    int pivotIndex(vector<int>& nums) {
        if(nums.empty())
        {return -1;}
        int leftsum = 0;int total =accumulate(nums.begin(),nums.end(),0);
        for(int i=0;i<nums.size();i++)
        {
            if(leftsum *2 +nums[i]== total)
            {return i;}
            else
            {leftsum += nums[i];}
        }
        return -1;
    }
};

2. 有序数列搜索插入位置

---

v1.0版本

该版本最基础，运算时间太长。叉腰。

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left=0;
        int right=nums.size()-1;
        int mid=floor((left+right)/2);

        while(nums[mid]!=target)
        {
            if(nums[mid]>target)
            {
                right=mid-1;
                if(right>left) return mid-1;
            }
            else
            {
                left=mid+1;
                if(right>left) return mid+1;
            }
            mid=floor((left+right)/2);
        }
        return mid;
    }
};

判断逻辑有点问题，如果数组中一直没有等于target的数，不就是死循环了吗。果然太久不做，逻辑都变差了。

v2.0版本

一个逻辑问题。小于第i个，则应该插在第i个；大于第j个，则应该插在第j+1个。

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left=0;
        int right=nums.size()-1;

        while(right>=left)
        {
            int mid=floor((left+right)/2);
            if(nums[mid]==target)  return mid;
            else if(nums[mid]>target) right=mid-1;
            else left=mid+1;
        }
        return left;
    }
};