Task02-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40621619/article/details/122971086

博客探讨了链表旋转问题，对比了两种不同的实现方式，指出第一种方法导致超时，而第二种和第三种方法通过优化实现了高效旋转。作者通过分析他人程序，意识到自己在流程设计和代码健壮性上的提升空间。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 * 
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
       
        while(k>0){
             ListNode* p=head;
            while(p->next!=nullptr)
             p=p->next;
             p->next=head->next->next;
            head->next=p; 
            
        
        k--;    
        }
return head;
    }
};

此种方式超时。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 * 
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
      ListNode* p1=head;
      ListNode* p2=head;
 while(k>0&&p1->next!=nullptr){
          p1=p1->next;
          k--;
      }
      while(p1->next!=nullptr){
          p1=p1->next;
          p2=p2->next;
          
      }
      p1->next=head->next;
      head->next=p2->next;
      p2->next=nullptr;
   
      
      
            
        
       
        
return head;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 * 
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
      ListNode* p1=head;
      ListNode* p2=head;
 while(k>0&&p1->next!=nullptr){
          p1=p1->next;
          k--;
      }
      while(p1->next!=nullptr){
          p1=p1->next;
          p2=p2->next;
          
      }
     p1->next=head;;
     head=p2->next;
     p2->next=nullptr;
      
      
            
        
       
        
return head;
    }
};

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head == nullptr){
            return nullptr;
        }
        int cnt = 0;  // 计算结点个数
        ListNode *p = head;
        while(p != nullptr){
            p = p->next;
            cnt++;
        }
        // 循环次数取余，避免重复循环
        k = k % cnt;
        // 同样使用头结点避免讨论第一个结点的问题
        ListNode *dummy = new ListNode(-1);
        dummy->next = head;
        ListNode *first = dummy, *second = dummy;
        // 第一个结点先出发走k步
        while(k--){
            first = first->next;
        }
        // 再同时前进，直到first指向最后一个结点
        // 此时second将指向新的链尾
        while(first->next != nullptr){
            first = first->next;
            second = second->next;
        }
        first->next = head;  // 链尾指向链头
        head = second->next;  // 慢指针的后一个是新的链头
        second->next = nullptr;  // 慢指针是新的链尾指向空
        return head;
    }
};

最后一段为他人写的程序，而他的可以通过，

从他的程序的设计流程看，

我的程序的健壮性，也就是我对整个过程条理清晰把握的能力是需要锻炼的