目录
1.力扣第217题：存在重复元素
2.力扣第53题：最大子数组和
3.力扣第1题：两数之和
4.力扣第88题：合并两个有序数组
5.牛客BM1题：反转链表
6.牛客BM2题：链表内指定区间反转
1.力扣第217题：存在重复元素
题目：给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。
示例 1：
输入：nums = [1,2,3,1]
输出：true
示例 2：
输入：nums = [1,2,3,4]
输出：false
解：这道题用排序做十分简单，将数组从小到大排列，相邻两个元素若相等则返回true，不相等返回false。
int cmp(const void *a_h,const void*b_h)
{
int a=*(int*)a_h,b=*(int*)b_h;//强制类型转换
return a-b;
}
bool containsDuplicate(int* nums, int numsSize){
qsort(nums,numsSize,sizeof(int),cmp);//对数组进行由小到大排序
for(int i=0;i<numsSize-1;++i)
{
if(nums[i]==nums[i+1])
{
return true;
}
}
return false;
}代码中出现的关键字：const限制了a_h,b_h变量的值不可修改，具有静态的作用，保证数组排序的安全性。
2.力扣第53题：最大子数组和
题目：给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。
示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：
输入：nums = [1]
输出：1
解：
int maxSubArray(int* nums, int numsSize){
int a,b=nums[0];
for(int i=0;i<numsSize;++i)
{
a=fmax(a+nums[i],nums[i]);
b=fmax(a,b);
}
return b;
}3.力扣第1题：两数之和
有人相爱，有人夜里开车看海，有人leetcode第一题都做不出来，哈哈哈哈哈(～￣▽￣)～
题目：给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和 为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
解：这题第一想法是用两个变量，进行循环判断，找出数组下标，操作比较简单，但是时间长。
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
for(int i=0;i<numsSize;i++)
{
for(int j=i+1;j<numsSize;j++)
{
if(nums[i]+nums[j]==target)
{
int *count=malloc(sizeof(int)*2);//创建一个新的动态内存结点；
*returnSize=2;
count[0]=i,count[1]=j;
return count;
}
}
}
*returnSize=0;
return NULL;
}4.力扣第88题：合并两个有序数组
题目：给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
示例 1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
示例 2：
输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。
解：这道题的第一个想法是把数组nums2直接移动到数组nums1的后面，然后进行排序；
第二个想法则是创建双指针，对数组进行判断，然后送入新栈；
int cmp(const void*a_h,const void*b_h)
{
int a=*(int*)a_h,b=*(int*)b_h;
return a-b;
}
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
for(int i=0;i!=n;i++)
{
nums1[m+i]=nums2[i];
}
qsort(nums1,nums1Size,sizeof(int),cmp);
} 
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
int j=0,k=0;
int bitter[m+n];
int tea;
while(j<m||k<n)
{
if(j==m)tea=nums2[k++];
else if(k==n)tea=nums1[j++];
else if(nums1[j]>nums2[k])tea=nums2[k++];
else tea=nums1[j++];
bitter[j+k-1]=tea;
}
for(int i=0;i!=m+n;i++)
{
nums1[i]=bitter[i];
}
}5.牛客BM1题：反转链表
题目：给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。
数据范围： 0\leq n\leq10000≤n≤1000
要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。
如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。
解：
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
/**
*
* @param pHead ListNode类
* @return ListNode类
*/
struct ListNode* ReverseList(struct ListNode* pHead ) {
// write code here
if(pHead==NULL)return NULL;
struct ListNode* nxt=malloc(sizeof(struct ListNode));
nxt->next=NULL;
while(pHead!=NULL)
{
struct ListNode* pre=malloc(sizeof(struct ListNode));
pre->val=pHead->val;
pre->next=nxt->next;
nxt->next=pre;
pHead=pHead->next;
}
return nxt->next;
}6.牛客BM2题：链表内指定区间反转
题目：将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。
例如：
给出的链表为 1\to 2 \to 3 \to 4 \to 5 \to NULL1→2→3→4→5→NULL, m=2,n=4m=2,n=4,
返回 1\to 4\to 3\to 2\to 5\to NULL1→4→3→2→5→NULL.
数据范围： 链表长度 0 < size \le 10000<size≤1000，0 < m \le n \le size0<m≤n≤size，链表中每个节点的值满足 |val| \le 1000∣val∣≤1000
要求：时间复杂度 O(n)O(n) ，空间复杂度 O(n)O(n)
进阶：时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param head ListNode类
* @param m int整型
* @param n int整型
* @return ListNode类
*/
struct ListNode* reverseBetween(struct ListNode* head, int m, int n ) {
// write code here
if(head->next==NULL||m==n)return head;
struct ListNode*phead=malloc(sizeof(struct ListNode));//创建一个新结点做表头
phead->next=head;
struct ListNode*cur=phead;
for(int i=0;i<m-1;i++)//区间前一个结点
{
cur=cur->next;//指向头结点
}
struct ListNode*pre,*temp,*res;
pre=cur;
cur=cur->next;
temp=cur;//保存区间的第一个结点
for(int i=0;i<n-m+1;i++)
{
res=cur;
cur=cur->next;
res->next=pre->next;
pre->next=res;
}
temp->next=cur;//头尾结点相连
return phead->next;
}
