单向链表每k个元素翻转一次

给出一个链表,每 k 个节点一组进行翻转,并返回翻转后的链表。

k 是一个正整数,它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍,那么将最后剩余节点保持原有顺序。

示例 :

给定这个链表:1->2->3->4->5

当 k = 2 时,应当返回: 2->1->4->3->5

当 k = 3 时,应当返回: 3->2->1->4->5

说明 :

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
         //涉及到链表指针的题目大多需要进行链的翻转,如下会用一个常用的
1、
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* pre; 
        ListNode* p = head;  
        ListNode* q = head;  
        
        if(!p || k == 1) return p;  
        for(int i = 1; i < k; i ++){
            if(!q->next)    return head;
            q = q->next;
        }
        pre = p;  
        head = q;
        while(p->next != head){//翻转链表的核心
            q = p->next;      //1. 缓冲p后面的单链表
            p->next = p->next->next;   //2. 反转单链表
            q->next = pre;    //3.让pPre指针后移
            pre = q;       //4. 让pre指针后移
    
 
        }
        p->next =  reverseKGroup(head->next, k);
        head->next = pre;
 
        return head;        
    }
};
2、

public ListNode reverseKGroup(ListNode head, int k) {
    if(head == null)
    {
        return null;
    }
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    int count = 0;
    ListNode pre = dummy;
    ListNode cur = head;
    while(cur != null)
    {
        count ++;
        ListNode next = cur.next;
        if(count == k)
        {
            pre = reverse(pre, next);
            count = 0;   
        }
        cur = next;
    }
    return dummy.next;
}
private ListNode reverse(ListNode pre, ListNode end)
{
    if(pre==null || pre.next==null)
        return pre;
    ListNode head = pre.next;
    ListNode cur = pre.next.next;
    while(cur!=end)
    {
        ListNode next = cur.next;//缓冲cur后面的链表
        cur.next = pre.next;//翻转单链表
        pre.next = cur;//让pre.next的指针后移,类似于后移head
        cur = next;//后移cur的指针
    }
    head.next = end;
    return head;
}
//直接翻转单链表
 
ListNode *listReverse(ListNode *pHead)
{
    if(pHead == NULL)
        return NULL;
    ListNode *pCurrent ,*pPre,*pNext;
                                  //一、指针的初始化阶段
    pPre = pHead;
    pCurrent = pPre->next ;
 
    while(pCurrent)               //二、反转单链表的核心代码
    {
        pNext = pCurrent->next ;   //1. 缓冲pCurrent后面的单链表
        pCurrent->next = pPre ;       //2. 反转单链表
        pPre = pCurrent;           //3.让pPre指针后移
        pCurrent = pNext ;         //4. 让pCurrent指针后移
    }
                       //三、处理并返回头指针
    pHead->next = NULL;                //把原头结点的next域变成空指针
    pHead = pPre ;                   //把头结点指向最后一个结点产生新的头结点,也就是把原单链表的尾结点变成头结点
 
    return pHead;
}
 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值