数据结构单链表的逆序

单链表的逆序

这是一次我们上机实验课的内容：实现单链表的逆序
单链表的逆序当然不是把一个单链表用头插法用一次，尾插法弄一次，而是在唯一的单链表的基础上进行操作next指针使他们原本指向后继的元素指向他们的前驱元素

思想

借助辅助指针来进行操作

我的代码

我是用三个辅助指针进行操作 pre，q，NEXT，这可能不是最简单的思想（没看书自己按照自己理解敲的），但是可以基本实现

#include <iostream>
#include <malloc.h>
using namespace std;
typedef int ElemType;
typedef struct LNode//单链表结构体
{
    ElemType data;
    struct LNode *next;
}LinkNode;
void InitList(LinkNode *&L)//初始化链表
{
    L=(LinkNode*)malloc(sizeof(LinkNode));
    L->next=NULL;
}
void CerateList(LinkNode*&L,ElemType a[],int n)//创建链表尾插法
{
    LinkNode *s,*r;
    r=L;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
        s=(LinkNode*)malloc(sizeof(LinkNode));
        s->data=a[i];
        s->next=r->next;
        r->next=s;
        r=s;
    }
    r->next=NULL;
}
void DispList(LinkNode *L)//输出链表
{
    LinkNode *p=L->next;
    while(p!=NULL)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
int backward(LinkNode *&L)//链表逆序
{
    LinkNode *pre,*q=L->next,*NEXT=q->next;//创建三个辅助指针
    if(NEXT->next==NULL)//单链表长度为2时
    {
        L->next=NEXT;
        NEXT->next=q;
        q->next=NULL;
        return 0;
    }
    while(true)//单链表长度大于等于3时
    {
        pre=NEXT->next;
        NEXT->next=q;
        if(pre->next==NULL)
        {
            pre->next=NEXT;
            L->next->next=NULL;
            L->next=pre;
            break;
        }
        q=pre->next;
        pre->next=NEXT;
        if(q->next==NULL)
        {
            q->next=pre;
            L->next->next=NULL;
            L->next=q;
            break;
        }
        NEXT=q->next;
        q->next=pre;
        if(NEXT->next==NULL)
        {
            NEXT->next=q;
            L->next->next=NULL;
            L->next=NEXT;
            break;
        }
    }
    return 0;
}
int main()
{
    LinkNode *L;
    int n;
    cout<<"请输入单链表的长度：";
    cin>>n;
    int a[n];
    InitList(L);
    CerateList(L,a,n);
    cout<<endl<<"创建单链表：";
    DispList(L);
    cout<<endl<<"调用逆序"<<endl;
    if(L->next->next!=NULL)//单链表长度为1时
        backward(L);
    cout<<endl<<"逆序单链表：";
    DispList(L);
    return 0;
}

if你是想应付作业这个代码应该做够了

else请 多采纳 多思考

改进之后的代码

#include <iostream>
#include <malloc.h>
using namespace std;
typedef int ElemType;
typedef struct LNode//单链表结构体
{
    ElemType data;
    struct LNode *next;
}LinkNode;
void InitList(LinkNode *&L)//初始化链表
{
    L=(LinkNode*)malloc(sizeof(LinkNode));
    L->next=NULL;
}
void CerateList(LinkNode*&L,ElemType a[],int n)//创建链表尾插法
{
    LinkNode *s,*r;
    r=L;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
        s=(LinkNode*)malloc(sizeof(LinkNode));
        s->data=a[i];
        s->next=r->next;
        r->next=s;
        r=s;
    }
    r->next=NULL;
}
void DispList(LinkNode *L)//输出链表
{
    LinkNode *p=L->next;
    while(p!=NULL)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
void Converse(LinkNode *&L)//逆置
{
   LinkNode *p,*q;
    p=L->next;
    L->next=NULL;
    while(p)
    {
        /*向后挪动一个位置*/
        q=p;
        p=p->next;

        /*头插*/
        q->next=L->next;
        L->next=q;
     }
}
int main()
{
    LinkNode *L;
    int n;
    cout<<"请输入单链表的长度：";
    cin>>n;
    int a[n];
    InitList(L);
    CerateList(L,a,n);
    cout<<endl<<"创建单链表：";
    DispList(L);
    cout<<endl<<"调用逆序"<<endl;
    Converse(L)；
    cout<<endl<<"逆序单链表：";
    DispList(L);
    return 0;
}

改进核心

void Converse(LinkNode *&L)//逆置
{
    LinkNode *p,*q;
    p=L->next;
    L->next=NULL;
    while(p)
    {
        /*向后挪动一个位置*/
        q=p;
        p=p->next;

        /*头插*/
        q->next=L->next;
        L->next=q;
    }
}