编写算法实现单链表的逆置运算

1. 用c语言实现单链表的逆置，能将此程序详细的解释一下吗

算法的核心就是reverse函数，其它的都是辅助建立链表和输出链表的。
从数据结构的定义来看这是一个带头节点的链表。要弄的十分明白你要耐心点画图看看。我简单的说下思路：
【head是指向头结点的】
p=head; //p最开始指向头结点
s=p->next; //s最开始指向第一个节点
while(s->next!=NULL)//只要没有到最后一个元素就继续。最后一个元素的next肯定为NULL
{ //进入核心了楼主
t=s->next; //用t指向s后面的那个元素
s->next=p; //把s指向她前面那个，这个时候就实现了逆向了。而且是就地逆向。元素都没有动的
p=s; //然后p向后移动s
s=t; //s向后移动到p
这样到下一轮的时候又可以讲下下个再指向刚才那个下一个。一次内推
}
s->next=p; //当最后一个的时候，还是要指向她的前一个。
head->next->next=NULL;//头指针的下一个是指向原来的第一个。逆向后肯定是最后的那个了。所以最后的一个的next=NULL就明了了。
head->next=s;//s是逆序前的最后一个，逆序后是第一个，所以用头指向他

画个图好好体会下，楼主！

2. 如何用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：香头跟着铁头

}

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

3. 用c语言实现单链表的逆置，能将此程序详细的解释一下吗

用c语言实现单链表的逆置的方法：

p=head;
s=p->next;
while(s->next!=NULL)
t=s->next;
s->next=p;
s=t;
s->next=p;
head->next->next=NULL;
head->next=s;

4. 单链表的逆置算法

帮你写好了，你看下

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

typedef struct node
{
int data;
struct node *next;
}Node;

//创建链表
Node *CreatList(void)
{
int i;
Node *head, *p, *q;

head = NULL;
printf("请输入您要输入的数据:\n");
scanf("%d", &i);
while(i != 0)
{
p = (Node *)malloc(sizeof(Node));
p->data = i;
if(head == NULL)
q = head = p;
else
q->next = p;
q = p;
scanf("%d", &i);
}
p->next = NULL;
return head;
}

//链表的逆置
Node *ReverseList(Node *head)
{
Node *p, *q, *r;

p = head;
q=r=NULL;

while(p)
{
q = p->next;
p->next = r;
r = p;
p = q;
}
return r;
}

//输出链表
void PrintList(Node *head)
{
Node *p;

p = head;
while(p)
{
printf("%d\n", p->data);
p = p->next;
}
}

int main(void)
{
Node *head;

head = CreatList();
printf("链表逆置前的数据:\n");
PrintList(head);

head = ReverseList(head);
printf("链表逆置后的数据:\n");
PrintList(head);

return 0;
}

请输入您要输入的数据:
1 2 3 4 5 6 0
链表逆置前的数据:
1
2
3
4
5
6
链表逆置后的数据:
6
5
4
3
2
1

5. 试写一算法对单链表实现就地逆置

voidInverse(LinkList&L)
{
LNode*p,*q;
p=L->next;/*记录第一个结点地址*/
L->next=NULL;/*把链表设置成空表*/
while(p!=NULL)/*依次按头插法将各结点插入，就实现了逆置*/
{
q=p;/*用q记录待插入结点地址*/
p=p->next;/*用p记录待插入结点的后继结点地址*/*/
q->next=L->next;/*将q（待插入结点）插入到头结点的前面*/
L->next=q;/*将新插入结点作为新的头*/
}

6. 如何用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：香头跟着铁头

}

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

7. 实现单链表逆置

就是头插法，图片真心懒得画……
每一步实现的是这样的过程：
0（初始化）、q为每一步运算的主要节点位置，初始化为第一个；
1、r=q的后续，把q的后续记录下来；
2、q-》next=p，把q的后续指向p（也就是开始），换句话说，把q放在了最开始；
3、p=q，把新的开始设置为新插入的q（下一次循环时，他就是p了）；
4、q=r，把下一步要进行运算的主要节点设置为r，也就是当前运算节点的下个节点。

相当于，一队小朋友双手搭着前一个人的肩。从第二个开始，把他挪到第一个人前面去，然后对下一个人做同样操作。
自己画画图吧，指针就是这么个东西。

8. 单链表的就地逆置的算法！！

就地逆置即算法的辅助空间为O(1)。

思路为：逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。

实现代码：

voidconverse(LinkList*head)
{
LinkList*p,*q;
p=head->next;
head->next=NULL;
while(p)
{
/*向后挪动一个位置*/
q=p;
p=p->next;

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

9. 试写一算法,对单链表实现就地逆置,即利用原表的存储空间将线性表 （a1,a2,…,an）逆置为（a

#include"stdio.h"
#include"iostream.h"
typedef int elementype;
#define MAXSIZE 100
struct list
{
elementype *elem;
int length;
int listsize;
};
//建立链表
int initlist(list *l)
{
int i=0,x;
l->elem=(elementype *)malloc(sizeof(elementype));
if(!l->elem)
{
cout<<"建立链表失败"<<endl;
return 1;
}
l->length=0;
l->listsize=MAXSIZE;
while(1)
{
cout<<"请输入链表数据:";
cin>>x;
if(x==0) break;
l->elem[i]=x;
l->length++;
i++;
}
return 1;
}
int swaplist(list *l)
{
int i=0,k,t;
k=(int)(l->length/2);
for(i=0;i<k;i++)
{
t=l->elem[i];
l->elem[i]=l->elem[l->length-1-i] ;
l->elem[l->length-1-i]=t;
}
return 1;
}
int displaylist(list *l)
{
int i=0;
cout<<"链表数据为:"<<endl;
for(i=0;i<l->length;i++)
{
cout<<l->elem[i]<<" ";

}
cout<<endl;
}

int main()
{
list *l;
initlist(l);
displaylist(l);
swaplist(l);
displaylist(l);
return 1;
}

10. 试写一算法 对单链表实现就地逆置 在线等！~

void Inverse(LinkList &L)
{
LNode *p, *q;
p = L->next; /*记录第一个结点地址*/
L->next = NULL; /*把链表设置成空表*/
while (p != NULL) /*依次按头插法将各结点插入，就实现了逆置*/
{
q = p; /*用q记录待插入结点地址*/
p = p->next; /*用p记录待插入结点的后继结点地址*/*/
q->next = L->next; /*将q（待插入结点）插入到头结点的前面*/
L->next = q; /*将新插入结点作为新的头*/}
}