怒刷leetcode题目（2）235，191，141，217，

最新推荐文章于 2025-12-28 17:52:30 发布

原创最新推荐文章于 2025-12-28 17:52:30 发布 · 792 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #c语言 #算法

c 专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍了在数据结构中处理二叉搜索树、位运算解决计数1比特问题以及链表循环检测的算法。通过实例分析，解释了如何在不同的场景下应用这些经典算法，包括寻找最低公共祖先、计算二进制位数以及判断链表是否有环。文章旨在为程序员提供实用的解决方案和深入的理解。

235	Lowest Common Ancestor of a Binary Search Tree	38.6%	Easy

Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”

        _______6______
       /              \
    ___2__          ___8__
   /      \        /      \
   0      _4       7       9
         /  \
         3   5

For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    if(root==NULL || p==NULL || q==NULL){
        return false;
    }
    if(p->val<root->val &&q->val<root->val ){
        return lowestCommonAncestor(root->left, p,q);
    }else if(p->val>root->val &&q->val>root->val){
        return lowestCommonAncestor(root->right, p,q);
    }else if(p->val == root->val ||q->val == root->val){
        return root;
    }else{
        return root;
    }
}

首先大家必须了解BST的特点，若两个节点都在根节点的同一侧，就可以将那一侧的子树拿出来做递归，直到遇到根节点是其中一个节点，返回该节点。或者两点分别在节点的两侧，返回该节点。

191	Number of 1 Bits	37.6%	Easy

Write a function that takes an unsigned integer and returns the number of ’1' bits it has (also known as the Hamming weight).

For example, the 32-bit integer ’11' has binary representation 00000000000000000000000000001011, so the function should return 3.

Credits:
Special thanks to @ts for adding this problem and creating all test cases.

int hammingWeight(uint32_t n) {
    int count= 0;
    while(n!=0){
        n = n & (n-1);
        count++;
    }
    return count;
}

n-1可以将最右的1变成0，右方的0全部变成1。

例如：1011011000会变成1011010111

将n&(n-1)可以将最右边的0去掉，重复就可以将n变成0，记录次数，返回次数即可

141	Linked List Cycle	36.3%	Medium

Given a linked list, determine if it has a cycle in it.

Follow up:
Can you solve it without using extra space?

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool hasCycle(struct ListNode *head) {
    if(head==NULL){
        return false;
    }
    struct ListNode *pointer1 = head;
    struct ListNode *pointer2 = head;
    while(pointer2!=NULL && pointer2->next!=NULL){
        pointer1 = pointer1->next;
        pointer2 = pointer2->next->next;
        if(pointer1 == pointer2){
            return true;
        }
    }
    return false;
}

使用快慢指针，快指针一次走两步，慢指针一次走一步，如果运行之后相遇，则是有循环

217	Contains Duplicate	36.0%	Easy

Given an array of integers, find if the array contains any duplicates. Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.

bool containsDuplicate(int* nums, int numsSize) {
    if(nums==NULL||numsSize<2){
        return false;
    }
    for(int i = 0; i<numsSize;i++){
        for(int j=i+1;j<numsSize;j++){
            if(nums[i]==nums[j]){
                return true;
            }
        }
    }
    return false;
}

这个方法不是最好的，看tags提醒这道题应该用hashtable做，不过c没有现成的hashtable，不知道该怎么实现，请大神们指教。