編寫演算法實現單鏈表的逆置運算

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; /*將新插入結點作為新的頭*/}
}