两数之和

两数之和-力扣

思路：

1. 动态开辟一个数组，用来存放下标；
2. 两个for循环嵌套来判断，数组中的两个数相加是否与target相等
3. 若相等，则将 * returnSize赋值为2，表示数组中两个数，并将arr数组进行赋值
4. 若不存在两数相加为target的数，则将*returnSize赋值为0

int* twoSum(int* nums, int numsSize, int target, int* returnSize) 
{
    int* arr=(int*)malloc(sizeof(int)*2);
    for(int i=0;i<numsSize;i++)
    {
        for(int j=i+1;j<numsSize;j++)
        {
            if(nums[i]+nums[j] == target)
            {
                arr[0]=i;
                arr[1]=j;
                *returnSize=2;
                return arr;
            }
        }
    }
    *returnSize=0;
    return arr;
}

两数相加

两数相加-力扣-链表

思路：

1. 创建头结点l3，创建pcur代替l3向后遍历，创建more表示进位数
2. 当l1、l2、more不为空时，进入循环
3. 当l1、l2不为空时，将他们的val值加入more中
4. 开辟新结点，将新结点的val值赋值为more%10，next赋值为NULL，并将新结点插入pcur的next中，并将more/10，这样才能算入进位
5. 最后返回l3的next（因为l3为头结点，l3的next才是链表真正的开始）

typedef struct ListNode ListNode;
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) 
{
    ListNode* l3 =(ListNode*)malloc(sizeof(struct ListNode));
    ListNode* pcur=l3;
    int more= 0;
    while(l1 || l2 || more)
    {
        if(l1)
        {
            more+=l1->val;
            l1=l1->next;
        }
        if(l2)
        {
            more+=l2->val;
            l2=l2->next;
        }
        ListNode* tmp=(ListNode*)malloc(sizeof(ListNode));
        tmp->val = more%10;
        tmp->next = NULL;
        pcur->next=tmp;
        pcur = pcur->next;
        more /= 10;
    }
    return l3->next;
}

无重复字符的最长字串

无重复字符的最长字串-力扣

解题思路来自于：滑动窗口-灵茶山艾府
创建一个bool类型的数组，当数组不重复时，数组向右扩展，增大窗口；当出现相同时，数组的左边向右移动，减小窗口

int lengthOfLongestSubstring(char* s) {
    int ans = 0;
    int left = 0;
    bool has[128] = {}; 
    for (int right = 0; s[right]; right++) 
    {
        char c = s[right];
        while (has[c]) 
        {
            has[s[left++]] = false;
        }
        has[c] = true;
        int len = right - left + 1;
        if(ans < len)
        {
            ans=len;
        }
    }
    return ans;
}