大一考核题解

在本篇中，将尽力使用多种解法，来达到一题多练的效果。

1：

1.原题链接：

238. 除自身以外数组的乘积 - 力扣（LeetCode）

这道题首先一眼肯定想到拿整体的积除以当前元素，将结果作为ans，但是一来题目说了不要用除法，二来除法要注意零元素。（虽然实际上是可以用除法来写的）

前缀：

所以我们就要换思路来写，要除了当前元素外的所有元素的积，也就是前面元素的积乘后面元素的积，这里就能想到前缀和后缀两点，所以首先可以先找出来每个元素之前的元素的积，存入一个数组，之后再找出该元素后面的元素的乘积，与前缀相乘即可。

所以这里我们就先动态分配一个数组

/*** Note: The returned array must be malloced, assume caller calls free().*/
int* productExceptSelf(int* nums, int numsSize, int* returnSize){int i=0, pro = 1;int *ans = malloc(numsSize * sizeof(int));for (i = 0; i < numsSize; i++) {ans[i] = pro;pro = pro * nums[i];}pro = 1;for (i = numsSize - 1; i >=0 ; i--) {ans[i] = ans[i] * pro;pro = nums[i]*pro;}*returnSize = numsSize;return res;
}

这里的pro是中间变量，我们将这个中间变量不断与当前元素相乘，就得到了前缀。

注意：

这里先将pro赋值给ans是因为要求的是：要除去当前元素的前缀和。所以先赋值之后再进行操作。

接下来，pro置为1，倒着遍历数组求出后缀并于ans相乘就可以得到答案。

下面是取巧的做法，

使用除法，先遍历一遍找出所有0，将非0项求积。

再遍历分四种情况：

1.0的个数大于1，那么剩下肯定是0

2.0个数为1，判断当前元素是否为0，是0，则就是上面所求的积，反之则是0

3.没有0，那么直接就是计算出的积除以当前元素。

/*** Note: The returned array must be malloced, assume caller calls free().*/
int* productExceptSelf(int* nums, int numsSize, int* returnSize) {int* ans = (int*)malloc(sizeof(int) * numsSize);memset(ans,1,sizeof(int)*numsSize);long long sum = 1;long long zero = 0;for (int i = 0; i < numsSize; i++) {if (nums[i] != 0)sum *= nums[i];elsezero++;}for (int i = 0; i < numsSize; i++) {if (zero > 1) {ans[i] = 0;} else if (zero == 1 && nums[i] == 0) {ans[i] = sum;} else if (zero == 1 && nums[i] != 0) {ans[i] = 0;} else if (zero == 0) {ans[i] = sum / nums[i];}}*returnSize = numsSize;return ans;
}

2：

2.原题链接：

394. 字符串解码 - 力扣（LeetCode）

本题难点在于括号内嵌套括号，需要从内向外生成与拼接字符串，这与栈的先入后出特性对应。

我的思路是，创建一个栈保存字符，创建一个数组保存数字。

遇到左括号，则索引位置入栈（输出串的尾指针）；

遇到“ ] ”时，从索引栈里弹出栈顶元素——就是最近的与之闭合的左括号，这部分内容是要被复制的，再找到数字数组最新元素元素，是几就把这部分内容复制几遍。

然后塞回栈中，等待之后使用。

这里的难点在于：要处理的太多了，很容易脑子就乱了，稍微简化一点的话，可以将数字数组删除，直接数字入栈，找到‘[’，他前面就是数字，这个时候，直接取出这个数字就可以了

char* decodeString(char* s) {int len = (int)strlen(s);int stackSize = 50;char* stack = (char*)malloc(stackSize * sizeof(char));int top = -1;for (int i = 0; i < len; i++) {char c = s[i];if (c != ']') {if (top == stackSize - 1) {stack = realloc(stack, (stackSize += 50) * sizeof(char));}stack[++top] = c;} else {int tempSize = 10;char* tempStack = (char*)malloc(tempSize * sizeof(char));int tempTop = -1;while (stack[top] != '[') {if (tempTop == tempSize - 1) {tempStack =realloc(tempStack, (tempSize += 10) * sizeof(char));}tempStack[++tempTop] = stack[top];top--;}char* cpyStr = (char*)malloc((tempTop + 2) * sizeof(char));for (int i = tempTop; i >= 0; i--) {cpyStr[tempTop - i] = tempStack[i];}cpyStr[++tempTop] = '\0';top--;int cpyNum = 0;int j = 0;while (top >= 0 && stack[top] >= '0' && stack[top] <= '9') {cpyNum += (stack[top] - '0') * pow(10, j);top--;j++;}for (int i = 0; i < cpyNum; i++) {for (int j = 0; j < strlen(cpyStr); j++) {if (top == stackSize - 1) {stack =realloc(stack, (stackSize += 50) * sizeof(char));}stack[++top] = cpyStr[j];}}free(tempStack);}}char* result = realloc(stack, (top + 2) * sizeof(char));result[++top] = '\0';return result;
}

3：

3.原题链接：

73. 矩阵置零 - 力扣（LeetCode）

如果遍历一遍该数组边遍历边置零的话，就会导致之前置零的影响之后的。

所以我们先遍历一遍，将每一个地方是0的元素都标记为1，之后再遍历hash数组，将原来为1的地方进行操作变成0就行了。

这里的

O（mn）的额外空间就是二维hash数组

O（m+n）就是用两个数组

一旦元素为0，就将该位置的下标地方的a，b数组都置为1，

这样遍历的时候只要两个同时为1就可以保证这个元素要改。

void setZeroes(int** matrix, int matrixSize, int* matrixColSize) {int h = matrixColSize[0];int l = matrixSize;int a[l][h];for (int i = 0; i < l; i++) {for (int j = 0; j < h; j++) {if (matrix[i][j] == 0) {a[i][j] = 1;} else {a[i][j] = 0;}}}for (int i = 0; i < l; i++) {for (int j = 0; j < h; j++) {if (a[i][j] == 1) {for (int k = 0; k < l; k++) {matrix[k][j] = 0;}for (int k = 0; k < h; k++) {matrix[i][k] = 0;}}}}
}

4：

4.原题链接：

23. 合并 K 个升序链表 - 力扣（LeetCode）

这是合并两个升序链表这道题的plus版，合并两个的时候，我们怎么处理呢？

用归并排序的思路来：

递归：

如果 l1 或者 l2 一开始就是空链表，那么没有任何操作需要合并，所以我们只需要返回非空链表。>否则，我们要判断 l1 和 l2 哪一个链表的头节点的值更小，然后递归地决定下一个添加到结果里的>节点。如果两个链表有一个为空，递归结束。

迭代：

1.初始化: 伪头节点 dum ，节点 cur 指向 dum 。
2.循环合并:当或2为空时跳出。
a.当 l.val < lz.val 时: cur 的后继节点指定为，并向前走一步
b.当 l.val > z.val 时:
cur 的后继节点指定为 2，并2 向前走步
c.节点 cur 向前走一步，即 cur = cur.next 。
3.合并剩余尾部: 跳出时有两种情况，即，为空或2为空
a.若 l 头null : 将添加至节点 cur 之后
b.否则: 将1。添加至节点 cur 之后
4.返回值:合并链表在伪头节点 dum 之后，因此返回 dum.neat 即可。

那么放大到n个的时候我们完全可以一个一个来，每一次都将list[i]与list[0]链接，那么之后呢链接的新链表又是list[0]，再与之后的链接，我们就可以用同样的思路完成该题。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {if(list1 == NULL){return list2;}if(list2 == NULL){return list1;}struct ListNode* ans;if(list1->val <= list2->val){ans = list1;ans->next = mergeTwoLists(list1->next,list2);}else{ans = list2;ans->next = mergeTwoLists(list1,list2->next);}return ans;}struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) {if(!listsSize) return NULL;struct ListNode* head = NULL;for(int i = 0; i < listsSize; i++){head = mergeTwoLists(head,lists[i]);}return head;
}

取巧法：

接下来，是另一个思路，说是升序链表，又没说必须操作链表，那我们就将所有元素取出存入数组，排序之后，再存入一个新链表不就可以了吗。逃课代码：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
int cmp(const void* a, const void* b) { return *(int*)a - *(int*)b; }
struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) {int a[10000];int j = 0;for (int i = 0; i < listsSize; i++) {struct ListNode* move = lists[i];while (move) {a[j++] = move->val;move = move->next;}}qsort(a, j, sizeof(int), cmp);struct ListNode* q = (struct ListNode*)malloc(sizeof(struct ListNode));q->next = NULL;struct ListNode* dong = q;for (int i = 0; i < j ; i++) {struct ListNode* new =(struct ListNode*)malloc(sizeof(struct ListNode));new->val = a[i];new->next = NULL;dong->next = new;dong = dong->next;}return q->next;
}

5：

5.原题链接：

232. 用栈实现队列 - 力扣（LeetCode）

学队列的时候必练的题目：

我们用两个栈模拟一个队列，入队操作的时候进入in，出队时，先将in的出栈到out中，再从out出栈就可以完成出队操作。


typedef struct a {int stcin[10], stcout[10];int stcintop, stcouttop;
} MyQueue;MyQueue* myQueueCreate() {MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));q->stcintop = 0;q->stcouttop = 0;return q;
}void myQueuePush(MyQueue* obj, int x) { obj->stcin[obj->stcintop++] = x; }int myQueuePop(MyQueue* obj) {if (obj->stcouttop == 0) {while (obj->stcintop > 0) {obj->stcout[obj->stcouttop++] = obj->stcin[--obj->stcintop];}}int ans = obj->stcout[--obj->stcouttop];while (obj->stcouttop > 0) {obj->stcin[obj->stcintop++] = obj->stcout[--obj->stcouttop];}return ans;
}int myQueuePeek(MyQueue* obj) { return obj->stcin[0]; }bool myQueueEmpty(MyQueue* obj) {return obj->stcintop == 0 && obj->stcouttop == 0;
}void myQueueFree(MyQueue* obj) {obj->stcintop = 0;obj->stcouttop = 0;
}/*** Your MyQueue struct will be instantiated and called as such:* MyQueue* obj = myQueueCreate();* myQueuePush(obj, x);* int param_2 = myQueuePop(obj);* int param_3 = myQueuePeek(obj);* bool param_4 = myQueueEmpty(obj);* myQueueFree(obj);
*/

6：

6.原题链接：

61. 旋转链表 - 力扣（LeetCode）

首先是常规的模拟法

假设链表的长度为n，为了将链表每个节点向右移动 k 个位置，我们只需要将链表的后 k % n个节点移动到链表的最前面，然后将链表的后k % n个节点和前 n - k个节点连接到一块即可。

具体过程如下：

1、首先遍历整个链表，求出链表的长度n，并找出链表的尾节点tail。

2、由于k可能很大，所以我们令 k = k % n，然后再次从头节点head开始遍历，找到第n - k个节点p，那么1 ~ p是链表的前 n - k个节点，p+1 ~ n是链表的后k个节点。

3、接下来就是依次执行 tail->next = head，head = p->next，p->next = nullptr，将链表的后k个节点和前 n - k个节点拼接到一块，并让head指向新的头节点(p->next)，新的尾节点即p节点的next指针指向null。

4、最后返回链表的新的头节点head。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/struct ListNode* rotateRight(struct ListNode* head, int k) {if (!head || !k) return head;int n = 0; // 链表的长度struct ListNode* tail; // 尾节点struct ListNode* p = head;while (p) {tail = p;p = p->next;n++;}k %= n;p = head;for (int i = 0; i < n - k - 1; i++) p = p->next; // 找到链表的第n-k个节点tail->next = head;head = p->next;p->next = NULL;return head; // 返回新的头节点
}

接下来是取巧法：

我们看到这种，那继续之前合并k个链表的思路，只管开头和结尾，将元素取出组成数组，然后将整个数组复制一份接到另一个数组之后，接下来，只需要将第一个元素更新为k%n个，那就是将链表移动k个之后的链表的样子啦，我们再将数值赋值进新链表就可以完美解决。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* rotateRight(struct ListNode* head, int k) {if (head == NULL || head->next == NULL)return head;if (k == 0)return head;int a[501];int j = 0;struct ListNode* move = head;while (move) {a[j++] = move->val;move = move->next;}int b[j * 2];for (int i = 0; i < j; i++) {b[i + j] = a[i];b[i] = a[i];}for (int i = 0; i < j; i++) {printf("%d", a[i]);}struct ListNode* q = (struct ListNode*)malloc(sizeof(struct ListNode));q->next = NULL;struct ListNode* dong = q;for (int i = (j - k % j); i < j+(j - k % j) ; i++) {struct ListNode* new =(struct ListNode*)malloc(sizeof(struct ListNode));new->val = b[i];new->next = NULL;dong->next = new;dong = dong->next;}return q->next;
}