力扣(LeetCode)刷题，简单题(第5期)

目录

第1题：二进制中1的个数

第2题：打印从 1 到最大的 n 位十进制数

第3题：删除链表的节点

第4题：调整数组顺序使奇数位于偶数前面

第5题：链表中倒数第K个节点

第6题：反转链表

第7题：二叉树的镜像

第8题：顺时针打印矩阵

第9题：数组中出现次数超过一半的数

第10题：最小的K个数

力扣(LeetCode)定期刷题，每期10道题，业务繁重的同志可以看看我分享的思路，不是最高效解决方案，只求互相提升。

第1题：二进制中1的个数

试题要求如下：

回答（C语言）：

int hammingWeight(uint32_t n) {
    int cou=0;

    while(n>0){

        if(n%2==1){ //注意是二进制
            cou++;
        }

        n/=2;
    }

    return cou;
}

运行效率如下所示：

第2题：打印从 1 到最大的 n 位十进制数

试题要求如下：

回答（C语言）：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* printNumbers(int n, int* returnSize){
    int cou=(int)pow(10,n)-1;

    int* data_buf=(int*)malloc(sizeof(int)*(cou));

    for(int i=0;inext;

    if(head->val==val) 
        return head->next;

    while(q){
        if(q->val==val){
            p->next=q->next;
            free(q);
            return head;
        }else{
            p=q;
            q=q->next;
        }
    }

    return head;
}

运行效率如下所示：

第4题：调整数组顺序使奇数位于偶数前面

试题要求如下：

回答（C语言）：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* exchange(int* nums, int numsSize, int* returnSize){
    int i=0,j=numsSize-1;
    int num=0;

    while(inext;
        i++;
    }

    i=i-k;

    while(i--){
       p=p->next; 
    }

    return p;
}

运行效率如下所示：

第6题：反转链表

试题要求如下：

回答（C语言）：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode *cur = NULL,*pre = head,*t;

    while (pre != NULL) {
        t = pre->next;
        pre->next = cur;
        cur = pre;
        pre = t;
    }
    
    return cur;
}

运行效率如下所示：

第7题：二叉树的镜像

试题要求如下：

回答（C语言）：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

struct TreeNode* mirrorTree(struct TreeNode* root){
    if (root==NULL) {
        return NULL;
    }

    struct TreeNode* right = mirrorTree(root->right);
    struct TreeNode* left = mirrorTree(root->left);

    root->left = right;
    root->right = left;
    
    return root;
}

运行效率如下所示：

第8题：顺时针打印矩阵

试题要求如下：

回答（C语言）：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
    if(matrixSize==0){
        *returnSize=0;
        return 0;
    }
    int cycle=0,row=0,column=0,k=0;
    *returnSize=matrixSize*(*matrixColSize);
    int *res=malloc(*returnSize * sizeof(int));
    while(k