Java如何把一个单链表进行反转

本篇内容介绍了"Java如何把一个单链表进行反转"的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

如何把一个单链表进行反转？

方法1：将单链表储存为数组，然后按照数组的索引逆序进行反转。

方法2：使用3个指针遍历单链表，逐个链接点进行反转。

方法3：从第2个节点到第N个节点，依次逐节点插入到第1个节点(head节点)之后，最后将第一个节点挪到新表的表尾。

方法4: 递归(相信我们都熟悉的一点是，对于树的大部分问题，基本可以考虑用递归来解决。但是我们不太熟悉的一点是，对于单链表的一些问题，也可以使用递归。可以认为单链表是一颗永远只有左(右)子树的树，因此可以考虑用递归来解决。或者说，因为单链表本身的结构也有自相似的特点，所以可以考虑用递归来解决)

方法1：

浪费空间。

方法2:

使用p和q两个指针配合工作，使得两个节点间的指向反向，同时用r记录剩下的链表。

p = head;

q = head->next;

head->next = NULL;

p = q;

q =r;

q->next = p;

q = r

第三次循环。。。。。

具体代码如下

ActList* ReverseList2(ActList* head){    //ActList* temp=new ActList; if(NULL==head|| NULL==head->next) return head;    //少于两个节点没有反转的必要。    ActList* p;    ActList* q;    ActList* r;    p = head;      q = head->next;    head->next = NULL; //旧的头指针是新的尾指针，next需要指向NULL    while(q){        r = q->next; //先保留下一个step要处理的指针        q->next = p; //然后p q交替工作进行反向        p = q;         q = r;     }    head=p; // 最后q必然指向NULL，所以返回了p作为新的头指针    return head;    }

如果觉得上面的先成环再断环的过程不太好理解，那么可以考虑下面这个办法，增加一个中间变量，使用三个变量来实现。

struct ListNode{    int val;    ListNode* next;    ListNode(int a):val(a),next(NULL){}};

ListNode* reverseLinkedList3(ListNode* head){        if(head==NULL||head->next==NULL)            return  head;        ListNode* p=head; //指向head        ListNode* r=head->next; //指向待搬运的节点，即依次指向从第2个节点到最后一个节点的所有节点        ListNode* m=NULL; //充当搬运工作用的节点        ListNode* tail=head->next;        while(r!=NULL){  //bug2 循环语句写错了, while写成了if            m=r;            r=r->next;            m->next=p->next;            p->next=m;            //if(r!=NULL)                //std::cout<<"m="<val<<" ,p="<val<<" ,r="<val<next;        tail->next=p;        p->next=NULL;        tail=p;        return head; // bug1 忘记了return    }

方法3

还是先看图，

从图上观察，方法是：对于一条链表，从第2个节点到第N个节点，依次逐节点插入到第1个节点(head节点)之后，(N-1)次这样的操作结束之后将第1个节点挪到新表的表尾即可。

代码如下:

ActList* ReverseList3(ActList* head){    ActList* p;    ActList* q;    p=head->next;    while(p->next!=NULL){        q=p->next;        p->next=q->next;        q->next=head->next;        head->next=q;    }     p->next=head;//相当于成环    head=p->next->next;//新head变为原head的next    p->next->next=NULL;//断掉环    return head;  }

附:

完整的链表创建，显示，反转代码:

//创建:用q指向当前链表的最后一个节点；用p指向即将插入的新节点。
//反向:用p和q反转工作，r记录链表中剩下的还未反转的部分。

#include "stdafx.h"#include using namespace std; struct ActList{    char ActName[20];    char Director[20];    int Mtime;    ActList *next;}; ActList* head; ActList*  Create(){//start of CREATE()    ActList* p=NULL;    ActList* q=NULL;    head=NULL;    int Time;    cout<<"Please input the length of the movie."<>Time;    while(Time!=0){    p=new ActList;    //类似表达:  TreeNode* node = new TreeNode;//Noice that [new] should be written out.    p->Mtime=Time;    cout<<"Please input the name of the movie."<>p->ActName;    cout<<"Please input the Director of the movie."<>p->Director;     if(head==NULL)    {    head=p;    }    else    {    q->next=p;    }    q=p;    cout<<"Please input the length of the movie."<>Time;    }    if(head!=NULL)    q->next=NULL;    return head; }//end of CREATE()  void DisplayList(ActList* head){//start of display    cout<<"show the list of programs."<Mtime<<"\t"<ActName<<"\t"<Director<<"\t"<next;    }}//end of display  ActList* ReverseList2(ActList* head){    //ActList* temp=new ActList; if(NULL==head|| NULL==head->next) return head;        ActList* p;    ActList* q;    ActList* r;    p = head;      q = head->next;    head->next = NULL;    while(q){        r = q->next; //        q->next = p;            p = q; //        q = r; //    }    head=p;    return head;    } ActList* ReverseList3(ActList* head){    ActList* p;    ActList* q;    p=head->next;    while(p->next!=NULL){        q=p->next;        p->next=q->next;        q->next=head->next;        head->next=q;    }     p->next=head;//相当于成环    head=p->next->next;//新head变为原head的next    p->next->next=NULL;//断掉环    return head;  }int main(int argc, char* argv[]){//    DisplayList(Create());//  DisplayList(ReverseList2(Create()));    DisplayList(ReverseList3(Create()));    return 0;}

方法4: 递归

updated: 2014-01-24

因为发现大部分问题都可以从递归角度想想，所以这道题目也从递归角度想了想。

现在需要把A->B->C->D进行反转，
可以先假设B->C->D已经反转好，已经成为了D->C->B,那么接下来要做的事情就是将D->C->B看成一个整体，让这个整体的next指向A，所以问题转化了反转B->C->D。那么，
可以先假设C->D已经反转好，已经成为了D->C,那么接下来要做的事情就是将D->C看成一个整体，让这个整体的next指向B，所以问题转化了反转C->D。那么，
可以先假设D(其实是D->NULL)已经反转好，已经成为了D(其实是head->D),那么接下来要做的事情就是将D(其实是head->D)看成一个整体，让这个整体的next指向C，所以问题转化了反转D。
上面这个过程就是递归的过程，这其中最麻烦的问题是，如果保留新链表的head指针呢？想到了两个办法。

// 递归版的第一种实现，借助类的成员变量m_phead来表示新链表的头指针。

struct ListNode{    int val;    ListNode* next;    ListNode(int a):val(a),next(NULL){}}; class Solution{     ListNode* reverseLinkedList4(ListNode* head){ //输入: 旧链表的头指针        if(head==NULL)            return NULL;        if(head->next==NULL){            m_phead=head;            return head;        }        ListNode* new_tail=reverseLinkedList4(head->next);        new_tail->next=head;        head->next=NULL;        return head; //输出: 新链表的尾指针     }    ListNode* m_phead=NULL;//member variable defined for reverseLinkedList4(ListNode* head)};

第二个办法是，增加一个引用型参数 new_head，它用来保存新链表的头指针。

struct ListNode{    int val;    ListNode* next;    ListNode(int a):val(a),next(NULL){}}; class Solution{    ListNode* reverseLinkedList5(ListNode* head, ListNode* & new_head){ //输入参数head为旧链表的头指针。new_head为新链表的头指针。        if(head==NULL)            return NULL;        if(head->next==NULL){            new_head=head; //当处理到了旧链表的尾指针，也就是新链表的头指针时，对new_head进行赋值。因为是引用型参数，所以在接下来调用中new_head的值逐层传递下去。            return head;        }        ListNode* new_tail=reverseLinkedList5(head->next,new_head);        new_tail->next=head;        head->next=NULL;        return head; //输出参数head为新链表的尾指针。    }};

"Java如何把一个单链表进行反转"的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注网站，小编将为大家输出更多高质量的实用文章！