力扣-题解

概要

力扣题解

##题目及对应代码

话不多说，直接上代码（一些重要的注释直接写在了代码里）

206翻转链表

struct ListNode* reverseList(struct ListNode* head)
 {
    struct ListNode* prev = NULL;
    struct ListNode* curr = head;
    while (curr) 
    {
        struct ListNode* next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
 }

05最长回文子串

char* answer(char* s)
{
	int len = strlen(s);
	int left, right, med;
	
	int anslen = 0, sta = 0; //anslen为回文长度 sra为回文的起始下标 
	
	for (med = 0; med < len; med++)//这样采用循环的方式是因为要找出最长的回文数组，所以短的回文直接覆盖掉 
	{
		left = med - 1;
		right = med + 1;
		while (left >= 0 && right < len && s[left] == s[right])
		{
			left--;
			right++;
		}
		if ((right - left - 1) > anslen)//用新子串两头下标的差和上一个回文子串的长度作比较 
		{
			sta = left + 1;
			anslen = right - left - 1;
		}
	}

	for (med = 0; med < len; med++)
	{
		left = med;
		right = med + 1;
		while (left >= 0 && right < len && s[left] == s[right])
		{
			left--;
			right++;
		}
		if ((right - left - 1) > anslen)//与之前找到的字符串比长度 
		{
			sta = left + 1;
			anslen = right - left - 1;
		}

	}
	s[sta + anslen] = '\0';//注意在原数组中插入\0，返回后输出指定回文子串 
	return s + sta;
}

102 二叉树的层次遍历

int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    int** arr = (int**)malloc(sizeof(int*) * 2001);//存储结果
    *returnColumnSizes =malloc(sizeof(int)* 2001) ; //存储二维数组每行多少元素

    *returnSize = 0; //初始化行数
    if (root == NULL)
        return NULL;

    struct TreeNode* queue[2001];// 模拟队列
    //初始化队列参数
    struct TreeNode* node; 
    int front, rear;
    front = 0;
    rear = 0;
    queue[rear++] = root;// 根节点入队
    while (front < rear) { //队列不为空
        int len = rear- front;//每层长度
        int* level = malloc(sizeof(int)*len);//定义一个数组，用于存储一层的元素
        (*returnColumnSizes) [(*returnSize)] = len;//记录每层长度
        for (int i = 0; i < len; i++) { //将这层的所有元素出队，并将这层元素的左右节点依次入队
            node = queue[front++];
            level[i] = node->val;
            if (node->left != NULL)
                queue[rear++] = node->left;
            if (node->right != NULL)
                queue[rear++] = node->right;
        }
        arr[(*returnSize)++] = level;//将这层元素的值直接赋值给结果数组
    }
    return arr;
}

23 合并k个升序链表

struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) {
    struct ListNode *new_node = NULL;
    int min_index = -1;
    int min_val = INT_MAX;

    for(int i = 0; i < listsSize; i++) // 寻找当前最小节点
    {
        if(lists[i])
        {
            if(lists[i]->val < min_val)
            {
                min_val = lists[i]->val;
                min_index = i;
            }
        }
    }

    if(min_index != -1) // 若存在当前最小节点
    {
        new_node = (struct ListNode *)malloc(1 * sizeof(struct ListNode));
        new_node->val = min_val;
        lists[min_index] = lists[min_index]->next; // 用完移动链表至下一个节点
        new_node->next = mergeKLists(lists, listsSize);
    }

    return new_node;
}