怒刷leetcode题目（3）226,83,142,86

最新推荐文章于 2026-01-05 22:36:07 发布

原创最新推荐文章于 2026-01-05 22:36:07 发布 · 684 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #c #c语言 #链表 #数据结构

算法专栏收录该内容

2 篇文章

订阅专栏

本文解析了四道LeetCode题目：翻转二叉树、移除排序链表中的重复元素、寻找链表环的入口及链表分区问题。通过深入浅出的方式介绍了各题目的解决思路和代码实现。

226	Invert Binary Tree	36.2%	Easy

Invert a binary tree.

     4
   /   \
  2     7
 / \   / \
1   3 6   9

     4
   /   \
  7     2
 / \   / \
9   6 3   1

对的，这就是前阵子homebrew大神面试没做出来的那道题

其实这道题并不难…也许只是大神不屑于做这样的题目罢了…

照样的，我们发现以下规律

所有的左子树和右子树交换，除非到了结点（树叶）

主需要交换两棵子树然后对子树递归就好了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* invertTree(struct TreeNode* root) {
    if(root == NULL){
        return NULL;
    }
    struct TreeNode* temp = root->left;
    root->left=root->right;
    root->right = temp;
    invertTree(root->left);
    invertTree(root->right);
    return root;
}

83	Remove Duplicates from Sorted List	34.4%	Easy

Given a sorted linked list, delete all duplicates such that each element appear only once.

For example,
Given 1->1->2, return 1->2.
Given 1->1->2->3->3, return 1->2->3.

太简单了…都不知道说什么好了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* deleteDuplicates(struct ListNode* head) {
    if(head == NULL){
        return false;
    }
    struct ListNode* pointer = head;
    while(pointer->next!=NULL){
        if(pointer->val==pointer->next->val){
            pointer->next = pointer->next->next;
        }else{
            pointer= pointer->next;
        }
    }
    return head;
}

142	Linked List Cycle II	31.4%	Medium

Given a linked list, return the node where the cycle begins. If there is no cycle, return null.

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

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    if(head==NULL){
        return false;
    }
    struct ListNode *slow = head;
    struct ListNode *fast = head;
    while(fast!=NULL && fast->next!=NULL){
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast){
            slow = head;
            while(slow!=fast){
                slow = slow->next;
                fast = fast->next;
            }
            return slow;
        }
    }
    return false;
}

这道题目跟141（上一篇博客中提及的）很类似，都是找出环

142实际是升级版，要找出环的入口

同样是使用快慢指针，大家可以在纸上画一下，写一下

如果有环，第一次相遇的时候，慢指针走了L+X的路程（L是起点到环入口的距离，X是入口到相遇时走过的距离，距离有可能比一圈的长度大）

快指针想当然的走了（L+X）*2的路程（其实不一定是2，只不过2比较好计算而已）

而且！！！快指针走过的距离是L+X+m*R（L、X同上，毕竟相遇点相同，m代表的是走过的圈数，R代表圈的长度）

也就是L+X=m*R

所以L=m*R-X

这时候，我们将慢指针回到起点，快指针的每一步的距离变成1

我们可以知道，慢指针和快指针相遇的时候

慢指针走了L，快指针走了m*R+m*R+X-X=2*m*R，也是在环的入口

所以他们再次相遇的节点就是环的入口

86	Partition List	27.4%	Medium

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

For example,
Given 1->4->3->2->5->2 and x = 3,
return 1->2->2->4->3->5.

遍历一次，将节点放进相应的链表，最后相连就好了，注意细节比较重要

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* partition(struct ListNode* head, int x) {
    if(head==NULL){
        return NULL;
    }
    if(head->next==NULL){
        return head;
    }
    struct ListNode* less_list = NULL;
    struct ListNode* less_list_head = NULL;
    struct ListNode* greater_list = NULL;
    struct ListNode* greater_list_head = NULL;
    struct ListNode* pointer = head;
    while(head!=NULL){
        struct ListNode* next = head->next;
        head->next = NULL;
        if(head->val<x){
            if(less_list_head==NULL){
                less_list_head=head;
                less_list=head;
            }else{
                less_list->next = head;
                less_list=less_list->next;
            }
        }else{
            if(greater_list_head==NULL){
                greater_list_head=head;
                greater_list=head;
            }else{
                greater_list->next = head;
                greater_list=greater_list->next;
            }
        }
        head=next;
    }
    if(less_list_head==NULL){
        return greater_list_head;
    }
    
    less_list->next=greater_list_head;
    return less_list_head;
}