鏈表倒序演算法
1. 鏈表倒序排列
例：ABC DEF
結果1：FED CBA
結果2：DEF ABC
以下給出的兩個程序都是用堆棧的方法接收，從而倒序！
/*結果1*/
#include "stdio.h"
#include <stdlib.h>
#define N 5
struct str
{
char a;
struct str *next;
};
struct str *creat(struct str *head)
{
int i;
struct str *p1;
printf("請輸入5個字元:");
for(i=0;i<N;i++)
{
p1=malloc(sizeof(struct str));
p1->a=getche();
p1->next=head;
head=p1;
}
return(head);
}
void main()
{
struct str *head;
head=NULL;
head=creat(head);
printf("\n");
do{
printf("%c",head->a);
head=head->next;
}while(head!=NULL);
}
/*結果2*/
#include "stdio.h"
#include <stdlib.h>
#define N 3
struct str
{
char a[30];
struct str *next;
};
struct str *creat(struct str *head)
{
int i;
struct str *p1;
for(i=0;i<N;i++)
{
printf("輸輸入3個字元串:\n");
p1=malloc(sizeof(struct str));
gets(p1->a);
p1->next=head;
head=p1;
}
return(head);
}
void main()
{
struct str *head;
head=NULL;
head=creat(head);
do{
printf("%s ",head->a);
head=head->next;
}while(head!=NULL);
}
2. 鏈表的倒序
//基本思路：頭指針逐漸一到鏈表尾，同時將各個節點連接反向
//h是指向表頭結點的指針
p = h->next;
while(p)
{
q=p;
p=p->next;
q->next=h->next;
h->next=q;
}
3. 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：香頭跟著鐵頭
}
自己用道具操作幾遍，然後把流程背會，以後自己根據流程寫代碼即可。
4. 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：香頭跟著鐵頭
}
自己用道具操作幾遍，然後把流程背會，以後自己根據流程寫代碼即可。
5. 三個關於鏈表的演算法問題，分別是排序，插入和倒序
#include<stdlib.h>
#include<stdio.h>
#defineCOUNT5//初始5個結點的鏈表
structnode{
intnum;
node*next;
};
node*creat();//創建新鏈表（5個結點）
voidprint(node*);//遍歷鏈表
node*add(node*);//添加插入一個結點
intisSort(node*);//判斷其數據項是否按從小到大排列
node*reverse(node*);//反轉鏈表
voidmain()
{
node*head;
head=creat();
print(head);
head=add(head);
print(head);
head=reverse(head);
print(head);
if(0==isSort(head))printf("不是按從小到大排序 ");
elseprintf("是按從小到大排序 ");
}
node*creat()
{
node*p1,*p2,*head;
head=NULL;
p1=p2=(node*)malloc(sizeof(node));
p1->num=1;//頭結點
head=p1;
for(inti=1;i<=COUNT;i++)
{
p1=(node*)malloc(sizeof(node));
p1->num=(100*rand())/(RAND_MAX*1.0);//0~100間的隨機數
p2->next=p1;
p2=p1;
}
p2->next=NULL;
returnhead;
}
voidprint(node*head)
{
if(head==NULL){printf("It'saemptylist ");return;}
node*first=head;
while(first!=NULL)
{
printf("%d",first->num);
first=first->next;
}
printf(" ");
}
intisSort(node*head)
{
if(head==NULL){printf("It'saemptylist ");return0;}
node*p=head;
while(p->next!=NULL)
{
if(p->num>p->next->num)return0;//發現有後一個比前一個值小則結束查找
p=p->next;
}
return1;
}
node*reverse(node*head)
{
node*pre,*cur,*nex;
if(head==NULL){printf("It'saemptylist ");returnhead;}
pre=head;
cur=head->next;
while(cur)
{
nex=cur->next;//保存下一個結點
cur->next=pre;//當前結點的下一個結點指向前一個結點，實現反轉
pre=cur;//pre和cur都依次後移一個結點
cur=nex;
}
head->next=NULL;//處理舊鏈表的頭結點（即新鏈表的尾結點）
head=pre;
returnhead;
}
哦，忘了頭結點指針是first，你把所有head替換成first就OK了。
6. 如何實現鏈表的倒序輸出
如下：
#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
int data;
node* pNext;
}Node;
//鏈表的操作，以有頭節點為例，無頭節點類似
Node* head = NULL;
//創建鏈表，頭結點data=0，pNext=NULL;
bool createNodeList()
{
head = (Node*) malloc(sizeof(Node));
if(NULL == head)
{
return false;
}
else
{
head->data = 0;
head->pNext = NULL;
return true;
}
}
//增加節點
bool addNode(Node* node)
{
if(NULL == head)
{
return false;
}
Node* p = head->pNext;
Node* q = head;
while(NULL != p)
{
q = p;
p = p->pNext;
}
q->pNext = node;
node->pNext = NULL;
return true;
}
//刪除節點
bool deleteNode(int index)
{
if(NULL == head)
{
return false;
}
Node* p = head->pNext;
int length = 0;
while(NULL != p)
{
length ++;
p = p->pNext;
}
if(length < index)
{
return false;
}
else
{
Node* q = head;
p = head;
for(int i=0;i<index;i++)
{
q = p;
p = p->pNext;
}
Node* t = p->pNext;
q->pNext = t;
free(p);
return true;
}
}
//逆序
void reverseNodeList()
{
if(NULL == head)
{
return;
}
//如果鏈表長度為1
if(head->pNext == NULL)
{
return;
}
Node* p = head->pNext;
Node* q = p->pNext;
Node* t = NULL;
while(NULL != q)
{
t = q->pNext;
q->pNext = p;
p = q;
q = t;
}
head->pNext->pNext = NULL;
head->pNext = p;
}
//排序(降序)
void sort()
{
//冒泡排序
Node* pHead = head;
if(head == NULL)
{
return;
}
if(pHead->pNext == NULL)
{
return;
}
Node* pi = pHead->pNext;
Node* pj = pi->pNext;
for(;pi != NULL;pi=pi->pNext)
{
for(pj = pi->pNext;pj != NULL;pj=pj->pNext)
{
if(pj->data>pi->data)
{
int tmp = pj->data;
pj->data = pi->data;
pi->data = tmp;
}
}
}
}
//銷毀
void destroyNodeList()
{
if(NULL == head)
{
return;
}
if(NULL == head->pNext)
{
free(head);
head = NULL;
return;
}
Node* p = head->pNext;
while(NULL != p)
{
Node* tmp = p;
p = p->pNext;
free(tmp);
}
free(head);
head = NULL;
}
void main()
{
createNodeList();
Node* node1 = (Node*)malloc(sizeof(Node));
node1->data = 1;
node1->pNext = NULL;
Node* node2 = (Node*)malloc(sizeof(Node));
node2->data = 2;
node2->pNext = NULL;
7. 數據結構（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：香頭跟著鐵頭
}
自己用道具操作幾遍，然後把流程背會，以後自己根據流程寫代碼即可。
8. 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：香頭跟著鐵頭
}
自己用道具操作幾遍，然後把流程背會，以後自己根據流程寫代碼即可。
9. 求解C語言數據結構鏈表倒序思路
循環執行下列操作：
從舊鏈表頭部抽走一個節點
再將這個節點壓入新鏈表頭部
舊鏈表：1--->2--->3--->4--->
新鏈表：
舊鏈表：2--->3--->4--->
新鏈表：1--->
舊鏈表：3--->4--->
新鏈表：2--->1--->
舊鏈表：4--->
新鏈表：3--->2--->1--->
舊鏈表：
新鏈表：4--->3--->2--->1--->