寻找数组中心索引
思路一：
外循环i、内循环j+变量left_sum+right_sum
i爬整个表，j爬0-i-1个元素，然后得出left_sum,接着j=i+1,一直爬到末尾，得出right_sum;
（如果都是正数的话，可以做到left>right就可以不做了，因为左边再加肯定比右边大）
如果仅仅是这样的话，那么还是相当复杂，
那我只算第一次的left_sum=0，right_sum=数组全部元素和，
与此同时我再设置temp和next变量
这样子我后面每次迭代，left_sum+=temp;right_sum-=next;
int pivotIndex(int* nums, int numsSize){
int left_sum=0,right_sum=0;
int i,j;
int temp,next;
"完成1到末尾的求值"
for(i=1;i<numsSize;i++)"注意这里是i=1"
right_sum+=nums[i];
"开始查找"
for(i=0;i<numsSize-1;i++){"设置成numsSize-1是因为防止nums[i+1]下标越界"
if(left_sum==right_sum)
return i;
else{
//迭代、更新
temp=nums[i];
next=nums[i+1];
left_sum+=temp;
right_sum-=next;
}
}
"判断最后一个位置的元素"
if(left_sum==right_sum)
return numsSize-1;
else
return -1;
}思路二：
先计算总和，然后遍历计算left总和，如果left总和×2加当前值等于总和，就返回当前值~
int pivotIndex(int *nums, int numsSize)
{
int i, totalNums = 0, leftNums = 0;
for (i = 0; i < numsSize; i++)
totalNums += nums[i] ;"求总和"
for (i = 0; i < numsSize; i++)
{
if (leftNums * 2 + nums[i] == totalNums)"注意这边先判断再更新左和"
return i;
leftNums += nums[i];
}
return -1;
}
搜索插入位置（二分查找)
int searchInsert(int* nums, int numsSize, int target){
int mid ,left=0, right=numsSize-1;
mid=numsSize/2;
while(left<=right){
if(target>nums[mid])
left=mid+1;
else if(target<nums[mid])
right=mid-1;
else
return mid;
mid=(left+right)/2;
}
return left;"或者right+1"
}合并区间
这题c语言也太难了，函数参数都看得不是太懂了，不过这个算法不会太难想，大致思路如下：
1、先按照左端点排序(用oop语言的sort）
这点太妙了！原先自己受制于c语言代码实现的原因所以没有往这方面想。
2、分配新的数组（没办法，只能使用额外的空间），然后将首元素插入
3、每次都和最末尾的区间进行比较，先比较有没有交集，
有交集：再判断区间右端点该取谁；
无交集：那就直接加进新的数组；
class Solution {
public:
vector<vector<int>> merge(vector<vector<int>>& intervals) {
vector<vector<int>> result;
if (intervals.size() == 0) return result;
// 排序的参数使用了lamda表达式
sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b){return a[0] < b[0];});
result.push_back(intervals[0]);
for (int i = 1; i < intervals.size(); i++) {
if (result.back()[1] >= intervals[i][0]) { // 合并区间
result.back()[1] = max(result.back()[1], intervals[i][1]);
} else {
result.push_back(intervals[i]);
}
}
return result;
}
};
旋转矩阵
哎呀，其实不难 ，自己在坑里了，中间想到了转置矩阵的办法，就是先转置然后再倒序就好了。
void rotate(int** matrix, int matrixSize, int* matrixColSize){
int i,j,k;
"转置，按对角线转置"
for(i=0;i<matrixSize;i++){
for(j=i;j<matrixSize;j++){
k=matrix[i][j];
matrix[i][j]=matrix[j][i];
matrix[j][i]=k;
}
}
"每行颠倒"
for(i=0;i<matrixSize;i++){
for(j=0;j<matrixSize/2;j++){
k=matrix[i][j];
matrix[i][j]=matrix[i][matrixSize-1-j];
matrix[i][matrixSize-1-j]=k;
}
}
}零矩阵
每次找到等于零的那一个把对应的行和列都置零即可，但是会出现一个问题就是到最后所有的元素都变成零了； （相当于误杀！！！）
那就只能新开数组来 “记录” 每一行每一列是否有0；
void setZeroes(int** matrix, int matrixSize, int* matrixColSize) {
int m = matrixSize;
int n = matrixColSize[0];
int row[m], col[n];
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (!matrix[i][j]) {
row[i] = col[j] = true;
}
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (row[i] || col[j]) {
matrix[i][j] = 0;
}
}
}
}其实还可以优化一下，不过整体思路上也是大同小异，都是找到0的位置然后记录。
https://leetcode-cn.com/problems/zero-matrix-lcci/solution/ling-ju-zhen-by-leetcode-solution-7ogg/