当前位置：首页 » 编程语言 » c语言单链表反转

c语言单链表反转

发布时间: 2021-03-14 12:51:03

① c语言链表逆序怎么理解

扣着的是头节点（头子）

车是首节点（首子）

马是次节点（次子）

牙签细的是指针指向，香头发黑的是指向，铁头细的是指向。

根据步骤写程序的伪算法（3步4循环，7张图片搞定），如下：

第一个循环把马弄到车前面，

第二个循环把相弄到马前面

第三个循环把士弄到相前面

........

直到香指向为空后停止循环。

代码如下：只需要一个首结点pHead,就能把链表找到，并倒置。具体代码如下

p香=pHead->pNext;

p铁=p香->pNext;

p香->pNext=NULL;

P香=p铁

while(p香！=NULL)

{

p铁=p香->pNext;

p香->pNext=pHead->pNext;

pHead->pNext=p香；

p香=p铁；

}

对照伪算法（三步四循环），和上面的代码是一一对应的：

第一步：香头指向首子，铁头指向次子

第二步：删掉首子指向次子（铁头所指向的那个子）的牙签

第三步：香头跟着铁头

以下循环条件：（条件：香头指向不为空）

{

循环1：铁头移动到香头的下一个指向

循环2：香头的下一个指向首子

循环3：头子的下一个跟着香头

循环4：香头跟着铁头

}

自己用道具操作几遍，然后把流程背会，以后自己根据流程写代码即可。

② C语言用链表实现逆序输出

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

//定义链表节点
typedefstructLNode
{intdata;
structLNode*next;
}LNode,*Linklist;

//创建链表
Linklistcreate()
{inti,n;//i用于下面循环,n用来存放有效节点的字数
Linklistp,L;
printf("PleaseinputN=");
scanf("%d",&n);
L=(Linklist)malloc(sizeof(LNode));//分配一个不存放有效数据的头结点
L->next=NULL;
for(i=0;i<n;i++)
{p=(Linklist)malloc(sizeof(LNode));//生成新节点
scanf("%d",&p->data);//输入元素值
p->next=L->next;
L->next=p;
}
returnL;//返回头节点;
}
//链表反转输出
LinklistReverseList(LinklistL,intst)//st为1时输出结点数据
{if(L->next!=NULL)
ReverseList(L->next,1);
if(st)printf("%d",L->data);
returnL;
}

voidput(LinklistL)
{Linklistp;
p=L->next;
while(p!=NULL)
{printf("%d",p->data);
p=p->next;
}
printf(" ");
}

intmain()
{LinklistL;
L=create();
printf("A:");put(L);
printf("B:");
ReverseList(L,0);//附加结点未保存数据，故第二参数为0
return0;
}

③ C语言单链表的倒序

struct student *reverse(struct student *head)
{
struct student *p1,*p2,*p3;
p2=head;p3=head->next;
do
{ p1=p2;p2=p3;p3=p2->next;p2->next=p1;
}
while(p3!=NULL);
//这个循环就是使得p2取到头指针head所指向的链表的尾部
//同时，在这个过程中，始终保持p2->p3->p1这样的顺序
//因此，循环结束后，必然得到原来链表的逆序链表
//（好吧，描述起来有些别扭，但是情况就是这样的）
head->next=NULL;
return(p2);
}

struct student *p0,*p1,*p2;
p0=head;
p1=p0->next;
p2=p0;
if(p0->next!=NULL)
{
while(p1->next!=NULL)
p1=p1->next;
p1->next=p0;//这句，明显错啦！你让所有的head所指向的链表的节点都变成p0啦！
head=p1;//这个语句执行的最终结果就是：head=last
}
while(p0->next!=NULL)//好好理解下人间正确的代码吧，要么这个代码是多此一举，
//要么就是还在犯迷糊，参看你上面的代码，我很难知道你这段是用来干嘛的？
{
while(p2->next!=NULL)
p2=p2->next;
p2->next=p0;
}
p0->next=NULL;
return(head);

④ c语言，链表的反转怎么写代码

单链表反转很简单，只说下思路：
1，从头到尾循环遍历链表
2，取下头结点，作为版尾结点，尾结点此时也为权头结点
3，采用前插法，将步骤二中取下的结点一个一个连接到头结点前面，成为新的头结点。
4，链表全部遍历完后，新的链表产生了，是原来链表的反转。

⑤ C语言原地逆转单链表

List_ptrInvertList(List_ptrhead)//原地逆转单链表head
{
List_ptrp=head,q=NULL,listend=head;
while(listend->next!=NULL)listend=listend->next;

while(p!=listend)
{
head=p->next;
listend->next=p;
if(q==NULL)p->next=NULL;
elsep->next=q;
q=p;
p=head;
}

returnhead;
}

⑥ C语言将一个单链表倒置

扣着的是头节点（头子）

车是首节点（首子）

马是次节点（次子）

牙签细的是指针指向，香头发黑的是指向，铁头细的是指向。

根据步骤写程序的伪算法（3步4循环，7张图片搞定），如下：

第一个循环把马弄到车前面，

第二个循环把相弄到马前面

第三个循环把士弄到相前面

........

直到香指向为空后停止循环。

代码如下：只需要一个首结点pHead,就能把链表找到，并倒置。具体代码如下

p香=pHead->pNext;

p铁=p香->pNext;

p香->pNext=NULL;

P香=p铁

while(p香！=NULL)

{

p铁=p香->pNext;

p香->pNext=pHead->pNext;

pHead->pNext=p香；

p香=p铁；

}

对照伪算法（三步四循环），和上面的代码是一一对应的：

第一步：香头指向首子，铁头指向次子

第二步：删掉首子指向次子（铁头所指向的那个子）的牙签

第三步：香头跟着铁头

以下循环条件：（条件：香头指向不为空）

{

循环1：铁头移动到香头的下一个指向

循环2：香头的下一个指向首子

循环3：头子的下一个跟着香头

循环4：香头跟着铁头

}

自己用道具操作几遍，然后把流程背会，以后自己根据流程写代码即可。

⑦ c语言，链表的反转，请写出代码，并讲解下，谢了！！！！！

/*
0 2 4 6 8
8 6 4 2 0
Press any key to continue
*/
#include <stdio.h>
#include <stdlib.h>

#define ELTYPE int

typedef struct node {
ELTYPE m;
struct node *next;
} *NODE;

void InversionNode(NODE head) {
NODE p,t,q;
p = NULL;
t = head->next;
q = t->next;
if(t == NULL || q == NULL) return; // 空表和仅有一个结点的链表不用倒置
while(q) {
t->next = p; // 倒置结点
p = t; // p指向新倒置的结点
t = q; // 前进一个结点
q = q->next;
}
t->next = p; // 处理最后一个结点
head->next = t; // head指向倒置后的链表
}

void ShowNode(NODE head) {
NODE p = head->next;
for(;p;p = p->next) printf("%d ",p->m);
printf("\n");
}

NODE CreatNode(int n) { // 创建有头结点的单向链表
int i;
NODE head,p,q;
head = p = (NODE)malloc(sizeof(node));
for(i = 0; i < n; ++i) {
q = (NODE)malloc(sizeof(node));
q->m = 2 * i;
p->next = q;
p = q;
}
p->next = NULL;
return head;
}

int main() {
NODE head = CreatNode(5);
ShowNode(head);
InversionNode(head);
ShowNode(head);
return 0;
}

⑧ 翻转单向链表 c语言

#include <stdio.h>
#include <stdlib.h>

/*定义链表结构体*/
typedef struct _list {
int v;
struct _list* t;
}list;

/*输出单链表*/
void show(list* h)
{
while(h) {
printf("%d ", h->v);
h = h->t;
}
putchar('\n');
}

/*逆序*/
void reverse(list** h)
{
list* t, *p;
p = *h; /*p保存上一个节点*/
t = p->t; /*t保存下一个节点*/
p->t = NULL; /*置尾节点为空*/
while(t) {
*h = t; /**h暂存当前节点*/
t = t->t; /*t遍历指向下一个节点*/
(*h)->t = p; /*逆序，改变指向*/
p = (*h); /*更新p值为下个节点*/
}
}

int main()
{
int i;
list* h = NULL, *t;
for(i = 0; i < 10; ++i) {
t = (list*)malloc(sizeof(list));
t->v = i;
t->t = h;
h = t;
}
show(h);
reverse(&h);
show(h);
}

⑨ c语言数据结构链表反转

两处scanf("%c",&data);后面都要加一行getchar();
另外代码中的%s要改成%c

⑩ 单链表反转的问题怎么解决（C语言）

单链表反转：
比如原链表为 head->1->2->3->NULL;
反转后：head->3->2->1->NULL;

实现代码：

#include<stdio.h>
#include<stdlib.h>
typedefstructNode
{
intdata;
structNode*next;
}*List;

#definenodestructNode

Listcreat(void);
Listre(Listhead,Listp,Listq);
voidOutlist(Listq);

intmain(intargv,char*argc[])
{
Listhead;
Listp;
Listq;
head=NULL;
head=creat();
p=head->next;
q=head;
re(head,p,q);
q=head->next;
Outlist(q);
system("pause");

return0;
}

Listcreat(void)
{
intdata;
Listhead;
Listp;
Listq;
intflag=1;
head=(List)malloc(sizeof(node));
q=head;
do
{
printf("请输入正数(<MAX_INT输入0表示输入结束)：");
scanf("%d",&data);
fflush(stdin);
if(0==data)
{
q->next=NULL;
flag=0;
}
else
{
p=(List)malloc(sizeof(node));
p->data=data;
q->next=p;
q=p;
}
}while(flag);
q=head->next;
Outlist(q);
returnhead;
}

voidOutlist(Listq)
{
while(NULL!=q)
{
printf("%d",q->data);
q=q->next;
}
printf("
");
return;
}

Listre(Listhead,Listp,Listq)
{
if(NULL==p)
{
head->next=q;
}
else
{
p=re(head,p->next,q->next);
p->next=q;
if(head==q)
{
p->next=NULL;
}
}
returnq;
}

阅读全文

c语言单链表反转

与c语言单链表反转相关的阅读推荐