目录
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;
-
}
转载：https://blog.csdn.net/weixin_69250798/article/details/128662202