翻转链表，合并两个有序链表，补充一个翻转链表很清晰的实现

翻转链表、合并两个有序链表

#include<iostream>
struct Node{
    int val;
    Node *pnext;
    Node(int arg,Node *pNext=nullptr):val(arg),pnext(pNext){};
};
Node* TurnList(Node *p){    //翻转链表
    if(!p)return nullptr;
    Node *ppre(p),*pcur(p->pnext),*pnext(nullptr);
    while(pcur){
        pnext=pcur->pnext;  //先保存下一节点
        pcur->pnext=ppre;   //翻转指向

        ppre=pcur;  //更新前一节点
        pcur=pnext; //更新当前节点为下一节点
    }
    p->pnext=nullptr;   //传入节点已经变为翻转链表的尾节点，置零
    return ppre;
};
Node *CombineTwoOrderedList(Node *p1,Node *p2){
    if(!p1 && !p2)return nullptr;
    //合并两个有序链表
    Node *pnew(nullptr),*ppre(nullptr); //ppre指向合并后的链表的前一个元素，对前一个元素的pnext改指向
    //传入的两个链表的元素不变，只是要从头部开始修改元素的pnext指向
    while(p1 && p2){
        if(p1->val<=p2->val){
            if(!pnew) pnew=p1;   //合并后链表的首元素
            else ppre->pnext=p1; //在找到下一个元素后才对前一个元素的pnext改指向
            ppre=p1;    //为下一个元素更新其前一个元素

            p1=p1->pnext;
        }else{
            if(!pnew) pnew=p2;
            else ppre->pnext=p2;
            ppre=p2;

            p2=p2->pnext;
        }
    }
    //肯定有一个链表还没结束
    if(p1) ppre->pnext=p1;
    else ppre->pnext=p2;
    return pnew;
}

测试：

int main(int argc,char* argv[]){
    Node *p1=new Node(3);
    Node *p2=new Node(1);
    p1->pnext=p2;
    Node *p3=new Node(4);
    p2->pnext=p3;
    Node *p4=new Node(1);
    p3->pnext=p4;
    Node *p5=new Node(5);
    p4->pnext=p5;

    Node *p(p1);
    while(p){
        std::cout<<p->val<<"\t";
        p=p->pnext;
    }
    std::cout<<"\n";

    Node *pReverse=TurnList(p1);
    p=pReverse;
    while(p){
        std::cout<<p->val<<"\t";
        p=p->pnext;
    }
    std::cout<<"\n";

    Node *p01=new Node(1);
    Node *p02=new Node(2);
    Node *p03=new Node(3);
    p01->pnext=p03;
    Node *p04=new Node(4);
    p02->pnext=p04;
    Node *p05=new Node(5);
    p03->pnext=p05;
    Node *p06=new Node(6);
    p04->pnext=p06;

    Node *pnew=CombineTwoOrderedList(p01,p02);
    p=pnew;
    while(p){
        std::cout<<p->val<<"\t";
        p=p->pnext;
    }
    std::cout<<"_\n";
}

输出：

HaypinsMBP:MultiThread haypin$ ./TurnList
3       1       4       1       5
5       1       4       1       3
1       2       3       4       5       6       _
HaypinsMBP:MultiThread haypin$

210728补充一个翻转链表很清晰的实现：

#include<iostream>
#include<string>
using namespace std;
class Data{
    public:
        string field;
        Data* pnext;
        Data(string var,Data* pnext=nullptr){
            this->field = var;
            this->pnext = pnext;
        }
        void print(){
            Data* pcur=this;
            while(pcur){
                std::cout<<pcur->field<<"——>";
                pcur = pcur->pnext;
            }
            std::cout<<std::endl;
        }
};
Data* reverse_chain(Data* proot){
    // ppre——>pcur——>pfu分别表示相邻三个元素的第一、第二、第三个
    Data* ppre = proot;
    if(ppre->pnext == nullptr){
         return ppre;
    }
    Data* pcur = ppre->pnext;
    ppre->pnext = nullptr;
    if(pcur->pnext == nullptr){
        pcur->pnext = ppre;
        return pcur;
    }
    Data* pfu = pcur->pnext;
    pcur->pnext = ppre;

    while(pfu->pnext){
        ppre = pcur;
        pcur = pfu;
        pfu = pcur->pnext;
        pcur->pnext = ppre;
    }

    pfu->pnext = pcur;
    return pfu;
}
int main(int argc,char* argv[]){
    Data* p4 = new Data(string("4"));
    Data* p3 = new Data(string("3"),p4);
    Data* p2 = new Data(string("2"),p3);
    Data* p1 = new Data(string("1"),p2);
    Data* preverse = reverse_chain(p1);
    preverse->print();
}

编译执行：

 haypin@MBP  ~/catkin_ws/src/creeper   main  clang++ -g reverse-list.cpp -o main
 haypin@MBP  ~/catkin_ws/src/creeper   main  ./main      
4——>3——>2——>1——>