编写算法，实现带头结点单链表的逆置算法。_

misonomika

2025年7月10日 20:31

void invent(Lnode *head)

{Lnode *p,*q;

if(!head->next) return ERROR;

p=head->next; q=p->next; p->next =NULL;

while(q)

{p=q; q=q->next; p->next=head->next; head->next=p;}

}

202233113

2025年6月29日 12:22

????

ljc414

2025年6月12日 11:52

bool nizhi(linklist &L){

Lnode *b,*a

a=L->next；

b=a->next;

L-next=null;

if(a=null) return flase;

while(a){//利用前插法实现倒置、

a-next=L-next;//插入

L->next=a;

a=b;

b=b-next;}

}

sprite127

2025年4月3日 11:45

void reverse() {
ListNode* prev = nullptr;
ListNode* current = head->next;
ListNode* nextNode = nullptr;
while (current) {
nextNode = current->next;
current->next = prev;
prev = current;
current = nextNode;
}
head->next = prev;
}

浅水

2025年3月26日 14:46

int reverse_n(Lnode *n){

Lnode* s;

Lnode *s1;

s1=n;

int i=0;

while(s1->next!=null) { s1=s1->next; i++; }

for(int i;i>=1;i--){

Lnode* s2=n;

for(int j=0;j<i;j++){

s2=s2->next;

}

s->data=s2->data;

}

n=s;

return 0;

}

LeeChungHo

2025年3月17日 21:40

仅展示逆置代码和main函数与输出结果
bool ReserveList(LinkList *L){
   LinkList new;
   InitList(&new);
   LNode *p = (*L)->next;
   while(p!=NULL){
       LNode *node = (LNode*)malloc(sizeof(LNode));
       node->next = NULL;
       node->val = p->val;
       node->next = new->next;
       new->next = node;
       p=p->next;
   }
   *L = new;
   printf("置换完成\n");
   return true;
}
int main()
{
   LinkList L;
   InitList(&L);//链表初始化函数
   ListAdd(1,L);//链表新增函数
   ListAdd(2,L);
   ListAdd(3,L);
   ListAdd(5,L);
   LNode *new = (LNode*)malloc(sizeof(LNode));
   new->val = 4;
   new->next = NULL;
   ListInsert(4,L,new);//链表插入节点函数
   ListInsert_Num(6,L,6);//链表插入值函数
   toString(L);//打印链表函数
   ListDelete(4,L);//链表删除元素函数
   toString(L);
   ListDelete(6,L);
   ReserveList(&L);
   toString(L);

return 0;
}

输出结果：
链表初始化完成
插入成功，插入值为1
插入成功，插入值为2
插入成功，插入值为3
插入成功，插入值为5
插入成功，插入值为4，插入次序为4
插入成功，插入值为6，插入次序为6
1,2,3,4,5,6,
删除成功，删除元素为4
1,2,3,5,6,
删除位序超过链表长度
链表初始化完成
置换完成
6,5,3,2,1,

single

2025年3月13日 16:34

1

jaygee_

2025年3月13日 11:43

LinkList Reverse(LinkList L) {

Lnode *p, *r;

p = L -> next;

L -> next = NULL;

while(p) {

r = p -> next;

p -> next = L -> next;

L -> next = p;

p = r;

}

return L;

}

夏恋星澄

2025年3月10日 14:57

Void Reverse（Sqlist &L）{

Node* P=L→next；

Node* q=P→next；

Node* pre；

P→next=NULL；

while（q！=NULL）{

pre=q；q=q→next；pre→next=P；P=pre；

}

L→next=P；

}

plutoczm

2025年3月3日 18:29

// 逆置链表 void reverseList(Node* head) { Node* prev = NULL; Node* current = head->next; Node* next = NULL; while (current != NULL) { next = current->next; current->next = prev; prev = current; current = next; } head->next = prev; }

CaoRui

2025年3月1日 20:01

void nizhi(lnode *head) {
   lnode* p, *q;
   p = head->next;
   if (p == null) return 0;
   q = p->next;
   p->next = NULL;
   while (q) {
       p = q;
       q = q->next;
       p->next = head->next;
       head->next = p;

}

shangan680

2024年12月22日 21:53

void ReverseList(LinkList L) {
LinkList p = L->next; // p指向第一个结点
LinkList r = L; // r始终指向逆置后的最后一个结点，初始时指向头结点
LinkList s; // s用于临时保存结点
while (p != NULL) {
s = p->next; // 保存p的下一个结点
p->next = r; // 将p的next指向逆置后的链表的最后一个结点
r = p; // 移动r到p
p = s; // 移动p到下一个结点
}
L->next = r; // 将头结点的next指向新的逆置后的第一个结点
}

LoneRanger

2024年12月14日 09:38

void ReverseList(LinkList &L){

LNode *cur=L->next;

LNode *next=NULL;

L->next=NULL;

while(cur){

next=cur->next;

cur->next=L->next;

L->next=cur;

cur=next;

}

lxy2001

2024年12月10日 21:25

void ReverseList(LinkList L) {
    LinkList p = L->next; // p指向第一个结点
    LinkList r = L; // r始终指向逆置后的最后一个结点，初始时指向头结点
    LinkList s; // s用于临时保存结点

    while (p != NULL) {
        s = p->next; // 保存p的下一个结点
        p->next = r; // 将p的next指向逆置后的链表的最后一个结点
        r = p; // 移动r到p
        p = s; // 移动p到下一个结点
    }

    L->next = r; // 将头结点的next指向新的逆置后的第一个结点
}

⁠⁤⁤⁬⁠

2024年12月7日 15:27

void NZ(Linklist &L){

Lnode *p=L->next;

Lnode *pre=NULL;

Lnode *next=NULL;

while(p){

next=p->next;

p->next=pre;

pre=p;

p=next;

}

L->next=pre;

}

wwj0102

2024年11月10日 16:13

void reverseLink(LinklList head){

LNode *p = head->next;

LNode *head2 = p->head;

p-next = NULL;

while(head2 != NULL){

LNode *q = head2;

head2 = head2->next;

q->next = p;

head->next = q;

}

JJlin

2024年11月7日 22:07

将单链表就地逆置可以考虑使用头插法。

LinkList Reverse(LinkList L){
   LNode *p = L->next;
   LNode *r;
   L->next = NULL;
   while(p){
       r = p->next;
       p->next = L->next;
       L->next = p;
       p = r;
   }
   return L;
}

muquew

2024年11月5日 22:23

LinkList* reverse(LinkList& L) {
    if(L->next == NULL) return L;
    LinkNode *p = L->next, *q;
    p = p->next;
    while(p != NULL) {
        q = p->next;
        p->next = L->next;
        L->next = p;
        p = q;
    }
    return L;
}

南部第一瞬狙

2024年10月31日 00:30

public class headinsert{

Node newnode=new node（o）

}

韩鹏

2024年10月18日 21:25

btnode *revers(btnode *h){

btnode *rear=(btnode*)malloc(sizeof(btnode));

btnode p;

rear->next=NULL;

rear->next=h->next;

h->next=h->next->next;

rear->next->nexet=NULL

p=h->next;

while(h->next){

h->next=p->next;

p->next=rear->next;

rear->next=p;

p=h->next;

}

free(h);

return rear;

}

siyxo

2024年10月17日 09:09

void reverse(LinkList &L){

LNode *p = L->head, *head = L->head, *q = p->next;

while(!p){

p = q;

q = q->next;

p->next = head->next;

head->next = p;

}

wangcai

2024年10月16日 20:57

void Reverse(LinkList *L){

if(!L -> next) return ERROR;

LinkList *p = L -> next;

LinkList *q = p -> next;

L -> next == NULL;

while(p){

p -> next = L-> next;

L -> next = p;

p = q;

q = q -> next;

}

return L;

}

mhhhx

2024年10月11日 14:58

ListNode* reverseList(ListNode* head){

if(!head || !head->next) returnhead;

auto new_head = reverseList(head->next);

head->next->next = head;

head->next = nullptr;

return new_head;

Candour

2024年9月29日 15:36

void invert(Lnode *head)
{
   Lnode *p, *q;

   p -> next = head -> next, q -> next = p -> next;

   while(q)
   {
       p = q, q = q -> next;
       p -> next = head -> next;
       head -> next = p;
   }
}

kbkj

2024年9月27日 20:09

Inverse(Linklist L){
   Linklist q; //头插法建立的新链表
   LNode* p = L->next; //在旧链表上摘结点
   q->next = NULL;
   while(p!=NULL){
       L->next = p->next;
       p->next = q->next;
       q->next = p;
       p = L->next;
   }
}

15730896717

2024年9月24日 15:07

Typedef struct LNode{
  ElemType data;
  struct LNode *next ; 
} LNode,*LinkList;

void invert (LinkList& L){
  #头指针法
  LNode *p,*r;
  P=L → next;
  l=next=null;
  While ( p ! =null) ｛
   r =p → next;
   P - next= i c → next;


 }

heshuqi

2024年9月22日 10:39

void reverseList(LNode *L){

LNode *pL->next,*q;

L->next=NULL;

while(p){

q=p->next

p->next=L->next;

L->next=p;

p=q;

}

lsssssj

2024年9月19日 20:08

头插发建立单链表

世界和平

2024年9月18日 10:44

void invent(Lnode *head)

{Lnode *p,*q;

if(!head->next) return ERROR;

p=head->next; q=p->next; p->next =NULL;

while(q)

{p=q; q=q->next; p->next=head->next; head->next=p;}

}

Conan_G

2024年9月12日 14:45

访问->头插法

void invent(Lnode *head)

{Lnode *p,*q;

if(!head->next) return ERROR;

p=head->next; q=p->next; p->next =NULL;

while(q)

{p=q; q=q->next; p->next=head->next; head->next=p;}

}

kenshin_ying

2024年9月1日 11:14

头插法

嘤狐

2024年8月29日 13:07

if(head->next==NULL||head->next->next==NULL) return;

node *p=head->next;

node *q=head->next->next;

while(p!=NULL)

{

if(head->next==p)p->next=NULL;

else p->next=head->next;

head->next=p;

p=q;

if(q!=NULL)q=q->next;

}

现在只想上岸

2024年8月27日 11:26

vg

2893385654

2024年8月23日 17:00

#include<stdio.h>

typedef struct link {

int data;

struct link *next;

} link;

//带头结点

link *initlinklist(int a[],int size) {

link *head=(link*)malloc(sizeof(link));

head->next=NULL;

link *p=head;

for(int i=0; i<size; i++) {

link *temp=(link*)malloc(sizeof(link));

temp->data=a[i];

temp->next=NULL;

p->next=temp;

p=p->next;

}

return head;

}

void display(link *head) {

link *temp=head->next;

while(temp!=NULL) {

printf("%d",temp->data);

if(temp->next)

printf("->");

temp=temp->next;

}

printf("\n");

}

//逆置算法--就地逆置法

link *reverselinklist(link *head) {

link *beg,*end,*p=head->next;

while(head==NULL||head->next==NULL) {

printf("空表\n");

return head;

}

beg=p;

end=p->next;

while(end!=NULL) {

beg->next=end->next;

end->next=p;

p=end;

end=beg->next;

}

head->next=p;

return head;

}

int main()

{

int a[]= {1,2,3,4,5,6,7,8,9};

int size=sizeof(a)/sizeof(a[0]);

link *head=initlinklist(a,size);

display(head);

link *p=reverselinklist(head);

display(p);

return 0;

}

缘小遇

2024年8月14日 14:29

typedef struct LNode{

int data;

struct LNode *next;

}LNode,*LinkList;

void Reverse(LinkList &L){

LNode *p=L->next,*r;

L->next=NULL;

while(p!=NULL){

r=p->next;

p->next=L->next;

L->next=p;

p=r;

}

Mapleman

2024年8月14日 09:12

void invent(Lnode *head){

Lnode *p,*q;

if(!head->next)

return ERROR;

p=head->next;

q=p->next;

head->next=NULL;

while(q){

p->next=head->next;

head->next=p;

p=q;

q=q->next;

}

Austin00

2024年7月25日 12:43

#include<iostream>
using namespace std;
struct  Lnode{
    int data;
    Lnode *next;
};

void reverse(Lnode * l){
    Lnode * p,*q;

   p=l->next->next;
   while(!p){
      q = p;
      p=p->next;
      q->next = l->next;
      l->next  =  q;

   }
}

Fenda

2024年7月24日 12:08

void invent(Lnode *head)

{Lnode *p,*q;

if(!head->next) return ERROR;

p=head->next; q=p->next; p->next =NULL;

while(q)

{p=q; q=q->next; p->next=head->next; head->next=p;}

}

q992646222_

2024年7月23日 16:22

//单链表逆置
void ReverseLNode(LNode *head){
printf("单链表逆置后--\n");
LNode *p=head->next; //此时p为结点1
LNode *q=p->next; //此时q为结点2
p->next=NULL; //结点1变为尾结点，指向赋空
while (q){ //如果后续结点不为空
p=q;//p变为结点2
q=q->next; //q变为结点3
p->next=head->next; //结点2指向结点1
head->next=p; //头结点指向结点2（因为此时的结点1变为了尾结点，而原先的结点2变为了首结点。
}
}

你这

2024年7月23日 12:10

void revert(LinkList *L){

LinkList *begin,*end;

begin = L->next;

end = L ->next->next;

while(end !=null){

begin->next = end->next;

end->next = L ->next;

L->next = end;

end = begin->next;

}

17843740381

2024年7月8日 14:37

Linklist reverse(LinkList L){

LNode *p,*r;

p=L->next;

L->next=NULL;

while(p!=NULL){

r=p->next;

p->next=L->next;

L->next=p;

p=r;

}

liuxinyi

2024年6月26日 17:49

void invent(Lnode *head)

{Lnode *p,*q;

if(!head->next) return ERROR;

p=head->next; q=p->next; p->next =NULL;

while(q)

{p=q; q=q->next; p->next=head->next; head->next=p;}

}

zynannan

2024年6月25日 18:41

：

17679377259

2024年6月15日 21:51

// 带头结点单链表的逆置算法

void ReverseList(LinkList L) {

if (L == NULL || L->next == NULL)

return;

LNode *prev = NULL;

LNode *current = L->next;

LNode *next = NULL;

while (current != NULL) {

next = current->next;

current->next = prev;

prev = current;

current = next; }

L->next = prev;

}

takanasi

2024年5月29日 17:54

void reverse(LinkList L){

Node *head = L->next;

Node *old = NULL, *tmp;

while(head != NULL){

tmp = head->next;

head->next = old;

old = head;

head = tmp;

}

y741934193

2024年4月18日 00:01

void invent(Lnode *L){

Lnode *p,*q;

if (!L->next) return ERROR;

p=L->next;q=p->next;p->next=NULL;

while (q)

{p=q;q=q->next;p->next=L->next;L->next=p;}

}

公交车呢

2024年3月12日 20:48

void invent(Lnode *head)

{Lnode *p,*q;

if(!head->next) return ERROR;//头结点为空跳出

p=head->next; q=p->next; p->next =NULL;//头结点分开

while(q)

{

p=q; q=q->next; p->next=head->next; head->next=p;//尾插法插入

}

zzw1803472614

2024年3月2日 23:37

//单链表逆置
void ReverseLNode(LNode *head){
    printf("单链表逆置后--\n");
    LNode *p=head->next; //此时p为结点1
    LNode *q=p->next;   //此时q为结点2
    p->next=NULL;   //结点1变为尾结点，指向赋空
    while (q){ //如果后续结点不为空
        p=q;//p变为结点2
        q=q->next; //q变为结点3
        p->next=head->next; //结点2指向结点1
        head->next=p; //头结点指向结点2（因为此时的结点1变为了尾结点，而原先的结点2变为了首结点。
    }
}

lkjgggggoing

2024年3月1日 17:31

bool re_linklist(LinkList &L){

LNode *p,*q;

if(L->next==NULL) return false;//单链表为空

p=L->next;

if(p->next==NULL) reurn true;//单链表只有一个节点，逆置等于它本身

q=p->next;

while(p!=NULL){

p->next=L->next;

L->next=p;

p=q;

if(q!=NULL) q=q->next;

}

return true;

}

小爪狸

2023年12月8日 20:02

void reverse (Linklist &L)

{

Lnode *p=l->next,*r;

l-next=null;

while(p!=null)

{

r=l->next;

p->next=L->next;

l-next=p;

p=r;

}

1762434726

2023年12月2日 20:50

头插法

carrot_huan

2023年11月30日 20:11

//不知道用递归对不对

LinkNode* Reverse(LinkNode* head)

{

if(head->next==NULL) return NULL;

LinkNode* temp=head->next;

head->next=Reverse(LinkNode* head->next->next);

Reverse(LinkNode* head->next->next) = temp;

return NULL;

}

carrot_huan 回复 carrot_huan： LinkNode* Reverse(LinkNode* head) { if(head->next==NULL) return NULL; LinkNode* temp=head->next; head->next=Reverse(head->next->next); Reverse( head->next->next) = temp; return NULL; }

2023年11月30日 20:13

执笔

2023年11月27日 20:42

ListNode* reverseList(struct ListNode* head){

ListNode *prev=NULL;

ListNode *curr=head;

while(curr){

//由于倒转指针指向后会断开连接，所以用临时结点temp保存curr指向的下一结点

ListNode *temp = curr->next;

//链表指针方向倒转

curr->next=prev;

//两指针依次向后移动

prev=curr;

curr=temp;

}

return prev;

}

椰噜

2023年11月24日 09:46

代码怎么学一窍不通有没有大佬给点建议

月溅星河回复椰噜：新手建议看C语言快速入门：https://noobdream.com/Major/majorinfo/1/

2023年11月24日 09:50

gaoshipeng

2023年11月23日 16:20

头插法实现单链表逆置

关键点：

1构建带头结点的空链表 R

2 遍历原链表，将每个结点以头插法插入到R中。

3 返回R

dasuanmao_11

2023年11月11日 15:20

void Reverse_List(LinkList L)
{
   LNode* r=L;
   LNode* p=L->next;
   L->next=NULL;//记得把头指针next域置空，否则会循环指首结点
   while(p)
   {
       r=p->next;
       p->next=L->next;
       L->next=p;
       p=r;
   }
}

兜兜里没有糖

2023年11月9日 12:09

//头插法逆置
LinkList Rverse_1(LinkList L){
    LNode *p,*r;//p为工作指针，r为p的后继，防止断链
    p = L->next;//从第一个结点开始
    L->next = NULL;//先将头结点L的next置为NULL
    while(p!= NULL){//依次拿下结点
        r = p->next;//暂存p的后继
        p->next = L->next;//将p插入在头结点之后
        L->next = p;
        p = r;
    }
}
//改变指针指向
LinkList Rverse_1(LinkList L){
    LNode *pre,*p = L->next,*r = p->next;
    p->next = NULL;
    while(r!= NULL){
        pre = p;
        p = r;
        r = r->next;
        p->next = pre;
    }
    L->next = p;
    return L;
}

mk921 回复兜兜里没有糖：三指针

2023年11月17日 18:04

山药男孩

2023年10月27日 22:05

LinkList reverse(LinkList L){
    LinkList P=L->next,r;
    L->next=null;
    while(p){
        r=p->next;
        p->next=L->next;
        L->next=p;
        p=r;
    }
    return L;
}

Graven

2023年10月23日 19:24

void Revert(Sqlist &L)

{

Sqlist *p,*q;

if(L->next == NULL) return;

p = L->next;

q = p ->next;

p -> next = NULL;

while(q){

p = q;

q = q->next;

p ->next = L->next;

L->next = p;

}

一叶

2023年10月20日 20:53

void invent(Lnode *L){

Lnode *p,*q;

if(L-next==NULL)//判断传入链表是否为空

{ return flase;}

p=L->next;//将待处链表传递给p

q=p->next;//第二结点开始遍历

p->next=NULL;//设置一个新链表

while（q）{

p=q；//结点传递

q=q->next;//进行L链表的位置移动

p->next=L->next;//头插法

L->next=p;

}

南秋

2023年10月1日 12:19

void invent(Lnode *L){

Lnode *p,*q;

if(L-next==NULL)//判断传入链表是否为空

{ return flase;}

p=L->next;//将待处链表传递给p

q=p->next;//第二结点开始遍历

p->next=NULL;//设置一个新链表

while（q）{

p=q；//结点传递

q=q->next;//进行L链表的位置移动

p->next=L->next;//头插法

L->next=p;

}

adidam9633

2023年9月23日 19:53

void invent(Lnode *head) {Lnode *p,*q; if(!head->next) return ERROR; p=head->next; q=p->next; p->next =NULL; while(q) {p=q; q=q->next; p->next=head->next; head->next=p;} }

yunke

2023年9月11日 20:16

思路

1.初始化2个指针，previous（前一个结点），current（当前结点）。previous指向NULL，current指向头结点L。

2.判断条件当L->next = NULL时返回，不需逆置。

3.保存current->next结点nextNode，使current指向previous，将previous移到current位置，current指向nextNode位置。重复23步骤。

void reverse(struct LNode* L) {
    if(L->next = NULL); {
        return FALSE;
    }
    struct LNode* current = L;
    struct LNode* previous = NULL;
    while (L->next != NULL) {
        nextNode = current->next;
        current->next = previous;
        previous = current;
        current = nextNode;
    }//最后previous指向反转后的头结点。
    return L;
}

lightstar

2023年9月6日 21:40

不知

Syou

2023年7月21日 21:32

void invert(Lnode *head){

Lnode *p, *q;

if(!head->next){

return ERROR;

}

p = head->next;

q = p->next;

p->next = NULL；

while(q){

p = q;

q = q->next;

p->next = head->next;

head->next = p;

}

WhiteWing

2023年7月7日 22:04

void reverse(LinkList *L)

{

LinkNode * p = L ->next;

LinkNode * q = p;

L->next = NULL;

while(p)

{

q = p ->next;

p->next = L->next;

L->next = p;

p = q;

}

hunhun

2023年6月28日 16:27

void reverse(NodeList L) {
   LNode* p = new LNode;
   LNode* q = new LNode;
   p = L->next;
   L->next = NULL;
   while (p!=NULL)
   {
       q = p->next;
       p->next = L->next;
       L->next = p;
       p = q;
   }
}

Nirvana-T

2023年5月20日 18:28

void reverseLinkedList(struct ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return;
    }

    struct ListNode* prev = NULL;
    struct ListNode* curr = head->next;
    while (curr != NULL) {
        struct ListNode* nextNode = curr->next;
        curr->next = prev;
        prev = curr;
        curr = nextNode;
    }
    head->next = prev;
}

desonglll

2023年5月3日 13:01

Node *head_reverse(Node *head) { // 头插法实现元素逆置
  Node *p, *q;
  p = head->next;    // p指向第一个有元素的节点
  head->next = NULL; // 将head分离出来
  while (p != NULL) {
    q = p->next;          // q指向p的下一个节点
    p->next = head->next; // 头插法把q插入head中
    head->next = p;
    p = q;
  }
  return head;
}

Pstary

2023年4月27日 20:35

LinkList reverse(LinkList L){

ListNode *pre,*p=L->next,*r=p->next;

p->next=NULL;

while(r!=NULL){

pre=p;

p=r;

r=r->next;

p->next=pre;

}

L=p->next;

return L;

}

13245372484

2023年4月1日 18:20

LinkList  Reverse_2(LinkList L){
//依次遍历线性表，并将结点指针反转
  LNode *pre, *p=L->next, *r=p->next;
  p->next = NULL;  //处理第一个结点  链表反转后，第一个结点变为最后一个结点，其next域为NULL
  while(r!= NULL){
   /* 后三句依次更新指针，遍历单链表*/
    pre = p;
    p = r;
    r = r->next;
    p->next = pre;       //反转指针
  }
  L->next = p;      //处理最后一个结点，链表反转后，最后一个结点变为第一个结点，L->next要指向其
  return L;
}

MSjJustin

2022年9月28日 11:54

1. p=L-›next； L-›next=NULL； while (p){ r=p-›next； p-›next=L-›next；//断p-r p=r;｝ 2. p=L-›next; r=p-›next; p-›next=NULL;//断p-r while(r)｛ pre=p; p=r； r=r-›next；//依次后移 p-›next=pre;//断p-r L-›next=p;｝

我行其野

2022年9月12日 14:38

void reverse(TreeNode * head)

{

TreeNode *p = head->next, *last = NULL;

while (p)

{

TreeNode *s = p->next;

p->next = last;

last = p, p = s;

}

head->next = last;

}

一只发财鸭

2022年3月10日 16:01

void reverse(List *head)

{

List *p,*q;

p=head->next;

q=p->next;

p->next=NULL;

while(q)

{

p=q;

q=q->next;

p->next=head->next;

head->next=p;

}

print(head);

}

冲冲冲123···

2022年2月13日 12:51

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
int data;
node *next;
}List;

List* create(){           //创建单链表
   List *head = (List*)malloc(sizeof(List));
   head->next=NULL;
   List *tail=head;
   int i;
   for(i=0;i<10;i++){
       List *p = (List*)malloc(sizeof(List));
       p->data=i;
       p->next=tail->next;
       tail->next=p;
       tail=p;
   }
   return head;
}
void reverse(List *head){       //逆置单链表
   List *p,*q;
   p=head->next;
   q = p->next;
   head->next=NULL;
   while(p!=NULL){
       p->next=head->next;
       head->next=p;
       p=q;
       if(p==NULL) continue;
       q=p->next;
   }
}
void print(List* head){           //打印单链表
   head=head->next;
   while(head!=NULL){
       printf("%d ",head->data);
       head=head->next;
   }
   printf("\n");
}

int main(){
   List* head = create();
   print(head);
   reverse(head);
   print(head);
   return 0;
}

H WH

2021年11月25日 21:45

//链表逆置
void Inverse(LinkList L) {
   LNode* p;
   LNode* q;
   p = L->next;
   L->next = NULL;
   while (p) {
       q = p->next;
       p->next = L->next;
       L->next = p;
       p = q;
   }
}

butler

2021年11月16日 15:00

`aa`

butler

2021年11月16日 15:00

void reversed_hh(LinkList L1){
    LNode *p = L1->next;
    LNode *q = p->next;
    p->next = NULL;
    while (q ->next != NULL){
        LNode *t = q->next;
        q->next = p;
        p = q;
        q = t;
    }
    q->next = p;
    L1->next = q;
}

Limny

2021年10月30日 16:59

LinkList  Reverse_2(LinkList L){
//依次遍历线性表，并将结点指针反转
  LNode *pre, *p=L->next, *r=p->next;
  p->next = NULL;  //处理第一个结点  链表反转后，第一个结点变为最后一个结点，其next域为NULL
  while(r!= NULL){
   /* 后三句依次更新指针，遍历单链表*/
    pre = p;
    p = r;
    r = r->next;
    p->next = pre;       //反转指针
  }
  L->next = p;      //处理最后一个结点，链表反转后，最后一个结点变为第一个结点，L->next要指向其
  return L;
}

zyjf

2021年10月21日 23:39

//带头结点单链表逆置算法（逆置：可以从后往前遍历，也可以直接接原有后面）

void reverse_head(Lnode &L)

{ Lnode *p,*q;

while(p!=null)

{ p=L->next;

q=p->next;

p->next=null;

}

while(q)

{ for(i=0;i<n;i++)

{ p=q;

q=q->next;

p=L->next;

p->next=null;

}

15843552692

2021年10月9日 17:26

void invent(Lnode *head)

{Lnode *p,*q;

if(!head->next) return ERROR;

p=head->next; q=p->next; p->next =NULL;

while(q)

{p=q; q=q->next; p->next=head->next; head->next=p;}

}

hulin

2021年9月6日 10:45

LinkList ListReverse( LinkList L){

LNode p,s;

Lr = (LinkList) malloc(sizeof(LNode));

Lr-next = NULL;

p = L;

while(p){

p = p->next;

s = (LNode *) malloc(sizeof(LNode));

s->data = p->data;

s->next = Lr->next;

Lr->next = s;

}

return Lr;

}

王文静

2021年7月22日 10:38

void Reverse(LinkList &L){
   LNode *p=L->next,*r;
   L->next=NULL;
   while(p!=NULL){
       r=p->next;
       p->next=L->next;
       L->next=p;
       p=r;
   }
}

hello

2021年7月7日 16:48

int fun(List &L)
{
Node *p = L;
int n = 0;
while (p != NULL)
{
p = p->next;
n++;
}
for (int i = 0; i < n; i++)
{
p->next = head->next;
head->next = head->next->next;
p->next->next = NULL;
p = p->next;
}
return true;
}

Zakin

2021年3月22日 15:06

LNode reverse(LNode *head){

LNode *p,*q;

p=head->next;

head->next=null;

while(p!=null){

q=p;

p=p->next;

//头插法

q->next = head->next;

head->next = q;

}

return head;

}

realtian

2021年3月9日 16:21

LinkList reverse(LinkList L){
Lnode *p, *q;
p = L->next;
L->next = NULL;
while(p!NULL){
q = p->next;
p->next = L->next;
L-next = p;
p = q;
}
return L;
}

1cecream

2020年12月19日 15:26

void invent(Lnode *head)

{Lnode *p,*q;

if(!head->next) return ERROR;

p=head->next; q=p->next; p->next =NULL;

while(q)

{p=q; q=q->next; p->next=head->next; head->next=p;}

}

none

2020年8月31日 16:07

LinkList Reverse_1(LinkList L){

LNode *p,*r;

p=L->next;

L->next=NULL；

while(p!=NULL){

r=p->next;

p->next=L->next;

L->next=p;

p=r;

}

return L;

}

wyh917917

2020年7月27日 10:51

void reverse(LNode head){

LNode p*,q*;

p = head->next; q = p -> next; p -> next = null;

while(!q){

p = q; p->next = head->next;head->next = q;
}
}

wyh917917 回复 wyh917917： while(q)

2020年7月27日 10:52

我超白好嘛

2020年6月15日 21:36

void reserve(Linklist L){

if(NULL==L->next){ return EOF;}

if(L->next!=NULL){

reserve(L->next);

}

if(L!=NULL) {

printf(L->data);

}

a575301453

2020年6月7日 16:47

void invent(Lnode *head)

{

Lnode *p,*q;

if(!head->next) return ERROR;

p=head->next; q=p->next; p->next =NULL;

while(q)

{p=q; q=q->next; p->next=head->next; head->next=p;}

}

[数据结构 P1073] 编写算法，实现带头结点单链表的逆置算法。

登录后提交答案

LinkList ListReverse( LinkList L){

LNode p,s;

Lr = (LinkList) malloc(sizeof(LNode));

p = L;

while(p){

p = p->next;

s = (LNode *) malloc(sizeof(LNode));

s->data = p->data;

s->next = Lr->next;

Lr->next = s;

}

return Lr;

}

[数据结构 P1073] 编写算法，实现带头结点单链表的逆置算法。

登录后提交答案

LinkList ListReverse( LinkList L){

LNode *p,*s;

Lr = (LinkList) malloc(sizeof(LNode));

p = L;

while(p){

p = p->next;

s = (LNode *) malloc(sizeof(LNode));

s->data = p->data;

s->next = Lr->next;

Lr->next = s;

}

return Lr;

}

LNode p,s;