leetcode【数据结构简介】《数组和字符串》卡片——数组简介

数组简介 主要内容

• 数组
• 动态数组

数组简介

1. 数组是一种基本的数据结构，用于按顺序存储元素的集合。但是元素可以随机存取，因为数组中的每个元素都可以通过数组索引来识别。
2. 数组可以有一个或多个维度。
3. 一维数组也被称为线性数组。
4. 数组 A 中有 6 个元素，则 A 的长度是 6 。

相关操作	语句
Initialize	int a0[5]; int a1[5] = {1, 2, 3} ;
Get length	int size = sizeof(a1) / sizeof(*a1);
Access Element	a1[0]
Iterate all Elements*	for(int i=0; i<size; i++){...};
Modify Element**	a1[0] = 4;
Sort	C++中有sort(a1, a1 + size); C中只有qsort();

*：遍历所有元素
** ：修改元素

关于qsort函数，见小白笔记本【函数篇】

动态数组简介

正如我们在上一篇文章中提到的，数组具有固定的容量，我们需要在初始化时指定数组的大小。有时它会非常不方便并可能造成浪费。

因此，大多数编程语言都提供内置的动态数组，它仍然是一个随机存取的列表数据结构，但大小是可变的。例如，在 C++ 中的 vector，以及在 Java 中的 ArrayList. 而在C语言中，则使用malloc。小白笔记本【函数篇】

程序练习

1. 寻找数组的中心索引

题目

• 给定一个整数类型的数组 nums，请编写一个能够返回数组“中心索引”的方法。
• 我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。
• 如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。

测试用例

输入:
nums = [1, 7, 3, 6, 5, 6]
输出: 3
解释:
索引3 (nums[3] = 6) 的左侧数之和(1 + 7 + 3 = 11)，与右侧数之和(5 + 6 = 11)相等。
同时, 3 也是第一个符合要求的中心索引。

代码实现

函数judge判断当前位置position是否满足

int judge(int* nums, int numsSize, int position){
    int sum1=0, sum2=0;
    for(int i=0; i<position; i++) sum1 += nums[i];
    for(int j=position+1; j<numsSize; j++) sum2 += nums[j];
    return sum1==sum2 ? 1:0; 
}

int pivotIndex(int* nums, int numsSize){
    for(int i=0; i<numsSize; i++)
        if(judge(nums, numsSize, i)) return i; 
    return -1;
}

2. 至少是其他数字两倍的最大数

题目

• 在一个给定的数组nums中，总是存在一个最大元素 。
• 查找数组中的最大元素是否至少是数组中每个其他数字的两倍。
• 如果是，则返回最大元素的索引，否则返回-1。

测试用例

输入: nums = [3, 6, 1, 0]
输出: 1
解释: 6是最大的整数, 对于数组中的其他整数,6大于数组中其他元素的两倍。6的索引是1, 所以我们返回1.

代码实现

int judge(int* nums, int numsSize){
int position, max=0, i;    
for(i=0; i<numsSize; i++){        
	if(max < nums[i]){            
	max = nums[i];            
	position = i;        
	}    
} 
for(int j=0; j<numsSize; j++){        
	if(j == position) continue;        
	if(max < 2*nums[j]) return 0;    
}    
return position+1;
}

int dominantIndex(int* nums, int numsSize){   
	return judge(nums, numsSize) ? (judge(nums, numsSize)-1):-1;
}

【注】judge函数中return position+1;的原因：排除索引为0时产生的错误。

其他思路

按数值大小进行排序，排序之后比较最大的是否是第二大的两倍

3. 加一

题目

• 给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
• 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
• 你可以假设除了整数 0 之外，这个整数不会以零开头。

测试用例

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

代码

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 int* plusOne(int* digits, int digitsSize, int* returnSize){
    int* p;
    *returnSize = digitsSize;
    for(int i=digitsSize-1; i>-1; i--){
        digits[i]++;
        if(digits[i] > 9 && i) digits[i] = (digits[i])%10;
        else if(digits[i]<10) return digits;
        else;
    }
    if(*digits > 9){
        (*returnSize) ++;
        p =(int *)malloc(sizeof(int) *(*returnSize));
        for(int i=digitsSize-1; i>=0; i--){
            p[i+1] = digits[i]%10;
        }
        p[0] = 1;  
    }
    return p;
}

优化

上面给出的代码属于中规中矩的解决方法。下面给出一种略微巧妙的方法：

因为出现进位仅仅出现在初始数组为9，99，999之类，通过观察可以发现，他们加一之后仅仅只有第一位为1，其余全为0，故可如下改变程序。

if(*digits > 9){
    (*returnSize) ++;
    p =(int *)malloc(sizeof(int) *(*returnSize));
    for(int i=digitsSize-1; i>=0; i--){
        p[i+1] = 0;
    }
    p[0] = 1;  
}

比较前后两种方法，后面取巧的方法减少了一些内存消耗，但是在执行时间上并无差异。
更重要的是发现了一个规律，我们在写代码的时候注意到规律的存在还是很重要的。

说出来也不怕人笑话，我开始的时候的思路是直接在digits一维数组上操作，用malloc函数给(digits+digitsSize)这个位置分配一个int大小的空间。然后，频繁报错，说并没有给(digits+digitsSize)复制，尽管我也用了等号，尽管形式并与p =(int *)malloc(sizeof(int) *(*returnSize));无不同。
百般尝试无果之后，决定直接另开一个数组p，然后在函数的末尾直接返回p。这就是上图贴的代码的样子。