Reverse Nodes in k-Group --leetcode

#include<iostream>
#include<string>
#include<algorithm>
#include<stack>
using namespace std;
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k)
    {
        ListNode* sentinal_Node=(ListNode*)malloc(sizeof(ListNode));
        sentinal_Node->next=head;
        ListNode* lastNode=sentinal_Node;
        while(lastNode!=NULL&&lastNode->next!=NULL)
        {

            ListNode* fristNode=lastNode->next;
            ListNode* secondNode=lastNode->next;
            cout<<"fristNode="<<fristNode->val<<endl;
            int index;
            stack<int> vals;
            vals.push(fristNode->val);
            for(index=1;index<k;index++)
            {
                if(fristNode->next!=NULL)
                {
                    cout<<"fristNode->val="<<fristNode->val<<endl;
                    fristNode=fristNode->next;
                    vals.push(fristNode->val);
                }
                else
                {
                    break;
                }
            }
            if(index!=k)
            {
                break;
            }
            while(!vals.empty())
            {
                int tmp=vals.top();
                vals.pop();
                cout<<"tmp="<<tmp<<endl;
                secondNode->val=tmp;
                secondNode=secondNode->next;
            }
            lastNode=fristNode;
        }
        return head;
    }
};
void printList(ListNode* head)
{
    while(head!=NULL)
    {
        cout<<head->val<<endl;
        head=head->next;
    }
}
int main()
{
     ListNode* ListNode1=(ListNode*)malloc(sizeof(ListNode));
    ListNode1->val=1;
    ListNode1->next=NULL;

    ListNode* ListNode2=(ListNode*)malloc(sizeof(ListNode));
    ListNode2->val=2;
    ListNode2->next=NULL;
    ListNode1->next=ListNode2;

    ListNode* ListNode3=(ListNode*)malloc(sizeof(ListNode));
    ListNode3->val=3;
    ListNode3->next=NULL;
    ListNode2->next=ListNode3;

    ListNode* ListNode4=(ListNode*)malloc(sizeof(ListNode));
    ListNode4->val=4;
    ListNode4->next=NULL;
    ListNode3->next=ListNode4;

    ListNode* ListNode5=(ListNode*)malloc(sizeof(ListNode));
    ListNode5->val=5;
    ListNode5->next=NULL;
    ListNode4->next=ListNode5;

    Solution solution;
    ListNode* head=solution.reverseKGroup(ListNode1,2);
    printList(head);
}