leedcode数组第五、六、七题（C语言）

五：只出现一次的数字
代码：
int singleNumber(int* nums, int numsSize)
{
int i = 0,res = 0;

if (numsSize == 1)
{
    return nums[0];
}

for(i = 0;i< numsSize; i++)
{
    res ^= nums[i];
}
return res;

}
解题思路：
1.首先考虑当数组中只有一个数的时候，无需比较，直接输出
2.数组循环，进行按位异或运算（a ^= b --> a = a ^ b）
补充：两边同时转为二进制数，进行比较，相同为0，不同变为1
[4,1,2,1,2]
res = 0000 0000
num[0] = 4 = 0000 0100, 运算得 res = 0000 0100 = 4
num[1] = 1 = 0000 0001, 运算得 res = 0000 0101 = 5
num[2] = 2 = 0000 0010, 运算得 res = 0000 0111 = 7
num[3] = 1 = 0000 0001, 运算得 res = 0000 0110 = 6
num[4] = 2 = 0000 0010, 运算得 res = 0000 0100 = 4

六：两个数组的交集
大佬的代码：
void Swap(int A[], int i, int j)
{
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}

int Partition(int A[], int left, int right) // 划分函数
{
int pivot = A[right]; // 这里每次都选择最后一个元素作为基准
int tail = left - 1; // tail为小于基准的子数组最后一个元素的索引
for (int i = left; i < right; i++) // 遍历基准以外的其他元素
{
if (A[i] <= pivot) // 把小于等于基准的元素放到前一个子数组末尾
{
Swap(A, ++tail, i);
}
}
Swap(A, tail + 1, right); // 最后把基准放到前一个子数组的后边，剩下的子数组既是大于基准的子数组
// 该操作很有可能把后面元素的稳定性打乱，所以快速排序是不稳定的排序算法
return tail + 1; // 返回基准的索引
}

void QuickSort(int A[], int left, int right)
{
if (left >= right)
return;
int pivot_index = Partition(A, left, right); // 基准的索引
QuickSort(A, left, pivot_index - 1);
QuickSort(A, pivot_index + 1, right);
}

int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {

int len = nums2Size;
int i, j, k = 0;
int flag = 0;
int *array_bak;

/* 快速排序 */
QuickSort(nums1, 0, nums1Size - 1);
QuickSort(nums2, 0, nums2Size - 1);

/* 处理特殊情况并获取数组长度 */
if(nums1Size == 0)
    return;
else if(nums2Size == 0)
    return;
else if(nums1Size < nums2Size)
    len = nums1Size;

int array[len];

/* 判断数组中是否有交集 */
for(i = 0; i < nums1Size; i++)
{
    for(j = flag; j < nums2Size; j++)
    {
        if(nums1[i] == nums2[j])
        {
            array[k] = nums2[j];
            k++;
            flag = j + 1;
            break;
        }
    }
}
/* 返回数组大小 */
*returnSize = k;
/* 为返回数组分配空间 */
array_bak = (int *)malloc(sizeof(int) * k);
/* 为返回数组赋值 */
memcpy(array_bak, array, sizeof(int) * k);
return array_bak;

}

我的代码：
void px(int *nums,int numsSize){
int min,tt;
for(int i=0;i<numsSize-1;i++){
min=i;
for(int j=i+1;j<numsSize;j++){
if(nums[min]>nums[j]){
min=j;
}
}
if(min!=i){
tt=nums[min];
nums[min]=nums[i];
nums[i]=tt;
}
}
}

int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
int i,j;
int result=(int )malloc(nums2Sizesizeof(int)); //指针名=（数据类型）malloc（长度）,（数据类型*）表示指针.

px(nums1,nums1Size);

px(nums2,nums2Size);

*returnSize=0;
for(i=0,j=0;i<nums1Size&&j<nums2Size;)
{
    if(nums1[i]>nums2[j])
    {
        j++;
    }
    else if(nums1[i]<nums2[j])
    {
        i++;
    }
    else
    {
        result[(*returnSize)++]=nums1[i];
        i++;
        j++;

    }
}
return result;

}

解题思路：
1.先让两个数组各按从小到大的顺序分别排序
2.两数组进入循环，比较每个元素，小了的往后进1，相等则录入申请分配的内存块

七：加一
代码：
int* plusOne(int* digits, int digitsSize, int* returnSize)
{

int i;
int* res = (int*)malloc((digitsSize + 1)*sizeof(int));

for (i = digitsSize - 1; i >= 0; i--)
{
	if (digits[i] < 9)       
	{
		digits[i] = digits[i] + 1;
		break;
	}
	else                     
	{
		digits[i] = 0;
	}
}
if (digits[0] == 0)    
{
	for (int j = 0; j < digitsSize + 1; j++)
	{
		res[j] = 0;
	}
	res[0] = 1;
	*returnSize = digitsSize + 1;
	
	return res;
}
else                  
{
	for (i = 0; i < digitsSize; i++)  
	{
		res[i] = digits[i];
	}
	*returnSize = digitsSize;
	
	return res;
}

}

解题思路：
1 . 分析可能情况：
(1) 输入：[1,2,3] 输出：[1,2,4]
(2) 输入：[1,2,9] 输出：[1,3,0]
(3) 输入：[9,9,9] 输出：[1,0,0,0](你可以假设除了整数 0 之外，这个整数不会以零开头)
2. （采用循环）从末位先加1的思路出发：
（1）判断末位不为9时，直接加1，跳出循环
（2）末位为9时，数组中的数通过循环向前推，依次加1
（3）循环结束后，考虑数组第 0 个数是否变为0，若变为0，则数组长度要扩大1位，并将第 0 位赋值为1，其余元素还是0；若没有变为0，则循环赋值输出即可。