考核题解读

考核题解读

最大嵌套深度

由括号先进的后对应的特性可知该题表面上是栈的应用，实际上是用数组模拟栈，且只需记录栈顶移动的最大值；
源代码如下：

int maxDepth(char * s){
    int len = strlen (s);
    int i;
    int top = 0;
    int max = top;
    for (i = 0;i < len ; i++) {
        if (s[i] == '(') {
            top++;
        }
        if (s[i] == ')') {
            top--;
        }
        if (top > max) {
            max = top;
        }
    }
    return max;
}

删除链表的中间节点

这题可以分为两部，寻找中间节点，删除操作中间节点；
由于没有时间限制，最简单的方法是直接遍历技术，再除以二
，如果追求时间可以使用快慢指针，这里我用的是第一种方法；

struct ListNode* deleteMiddle(struct ListNode* head){
    int cnt = 0;
    struct ListNode* p;
    for(p = head; p ;p = p->next) {
        cnt++;
    }
    if (head == NULL || head->next == NULL) {
        return NULL;
    }
    struct ListNode* dummyhead = (struct ListNode*) malloc (sizeof (struct ListNode));
    dummyhead->next = head;
    p = dummyhead;
    struct ListNode* q = NULL;
    int i;
    for(i = 0;i < cnt / 2 + 1;i++) {
        q = p;
        p = p->next;
    }
    q->next = p->next;
    free (p);
    return head;
}

有序数组的平方

如题，先非递减排序，然后平方，这里我选择冒泡排序后，再遍历平方；

int* sortedSquares(int* nums, int numsSize, int* returnSize){
    *returnSize = numsSize;
    int i;
    for (i = 0; i < numsSize; i++) {
        nums[i] = nums[i] * nums[i];
    }
    int j;
    for (i = numsSize - 2; i >= 0; i--) {
        for (j = 0; j <= i; j++) {
            if (nums[j] > nums[j + 1]) {
                int t = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = t;
            }
        }
    }
    return nums;
}

压缩字符串

先统计字符的个数，找到连续相同的字符，把后面相同的转化为新字符，直到遍历结束；

int compress(char* chars, int charsSize){
    int j = 0;
    int k = 0;
    int i = 0;
    while (i < charsSize) {
        while (i < charsSize && chars[j] == chars[i]) {
            i++;
        }
        chars[k++] = chars[j];  
        int len = i - j;        
        if (len > 1) {
            char str[10];
            sprintf(str, "%d", len);  
            for (int m = 0; m < strlen(str); m++) {
                chars[k++] = str[m];
            }
        }
        j = i;
    }
    return k;
}

盛最多水的容器

首尾指针向中缩进，求面积大小，再把最短的一段移动，循环，直到遍历结束

int maxArea(int* height, int heightSize){
    int left=0;
    int right=heightSize-1;
    int tall=0;
    int area=0;
    int max=0;

    while(left < right)
    {
        tall=height[left]<height[right] ? height[left] : height[right];
        area=tall*(right-left);
        max=max>area ? max : area;
        
        if(height[left] < height[right])left++;
        else right--;
    }

    return max;
}