牛客网刷机考题

题目：输入一个链表，反转链表后，输出新链表的表头。

反思总结：注意，如果pHead是一个空表，那么就不存在Phead->next，千万注意！！！

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
    
    
public:
    ListNode* ReverseList(ListNode* pHead) {
    
    
        ListNode* L=nullptr;   //运用前插法
        //在这里玩意PHead是空的情况下，那么就没有pHead->next存在！！！注意！！！
        ListNode* p=pHead;
        ListNode* q;
        while(p!=nullptr)
        {
    
    
            q=p->next;
            p->next=L;
            L=p;
            p=q;
        }
        return L;
    }
};

第二题 k个一组反转链表，剩余不足k个保持原样。

（1）用前插法

将给出的链表中的节点每\ k k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是\ k k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。
要求空间复杂度 \ O(1) O(1)
例如：
给定的链表是1→2→3→4→5
对于k=2, 你应该返回 2→1→4→3→5
对于k=3, 你应该返回3→2→1→4→5

1.本题思路 :先看从当前p开始，是否至少存在k个结点，切记在循环之前先保存原指针的位置以方便届时可以还原。
2.然后切记保存每k个翻转之后的最后一个结点（也就是原本这k个里的第一个结点，下次可以与下一个k链表或者剩余的链接）。
3.整体不难，但是切记，当p已经为nullptr之后就不能再p->next了，这真的很容易出错。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */
class Solution {
    
    
public:
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* reverseKGroup(ListNode* head, int k) {
    
    
        int num=0;
        ListNode* L=nullptr;
        ListNode* p=head;
        ListNode* q;
        ListNode* tail=nullptr;
        ListNode* tailpre=nullptr;
        while(p!=nullptr)
        {
    
    
            q=p;     //记录初始结点
            ListNode * start=p;
            num=0;
            while(num<k&&p!=nullptr)
            {
    
    
                num++;
                p=p->next;
            }
            if(num==k)    //这部分构成一个反置链表
            {
    
    
                p=q;
                ListNode *L1=nullptr;
                while(num>0&&p!=nullptr)
                {
    
    
                    if(num==k)
                    {
    
    
                        tail=p;   //保留当前子链表排好序后最后一个元素。
                    }
                    q=p->next;
                    p->next=L1;
                    L1=p;
                    p=q;
                    num--;
                }
                if(L==nullptr)
                {
    
    
                    L=L1;
                }
                else
                {
    
    
                    tailpre->next=L1;
                }
                tailpre=tail;
            }
            else if(num<k)
            {
    
    
                if(tail==nullptr)  //整体长度小于k。
                {
    
    
                    L=start;
                }
                else
                {
    
    
                    tailpre->next=start;  //最后剩余少于k的那部分。
                }
            }
        }
        return L;
        // write code here
    }
};

（2）用栈

import java.util.*;
import java.math.*;
/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    
    
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    public ListNode reverseKGroup (ListNode head, int k) {
    
    
        // write code here
        Stack<ListNode> stack=new Stack<ListNode>();
        ListNode ret=new ListNode(0);
        ListNode p=ret;
        ListNode temp;
        while(true)
        {
    
    
            int num=0;
            temp=head;
            while(num<k&&temp!=null)
            {
    
    
                stack.push(temp);
                num++;
                temp=temp.next;
            }
            if(num<k)
            {
    
    
                p.next=head;
                break;
            }
            else if(num==k)
            {
    
    
                while(!stack.isEmpty())
                {
    
    
                    p.next=stack.pop();
                    p=p.next;
                }
            }
            p.next=temp;
            head=temp;
        }
        return ret.next;
    }
}