c語言前序

Ⅰ 用c語言程實現樹的遍歷。分出先序,中序,後序

#include <stdio.h>
#include <stdlib.h>
#define STACK_MAX_SIZE 30
#define QUEUE_MAX_SIZE 30
#ifndef elemType
typedef char elemType;
#endif
/************************************************************************/
/* 以下是關於二叉樹操作的11個簡單演算法 */
/************************************************************************/
struct BTreeNode{
elemType data;
struct BTreeNode *left;
struct BTreeNode *right;
};

/* 1.初始化二叉樹 */
void initBTree(struct BTreeNode* *bt)
{
*bt = NULL;
return;
}

/* 2.建立二叉樹(根據a所指向的二叉樹廣義表字元串建立) */
void createBTree(struct BTreeNode* *bt, char *a)
{
struct BTreeNode *p;
struct BTreeNode *s[STACK_MAX_SIZE];/* 定義s數組為存儲根結點指針的棧使用 */
int top = -1; /* 定義top作為s棧的棧頂指針，初值為-1,表示空棧 */
int k; /* 用k作為處理結點的左子樹和右子樹，k = 1處理左子樹，k = 2處理右子樹 */
int i = 0; /* 用i掃描數組a中存儲的二叉樹廣義表字元串，初值為0 */
*bt = NULL; /* 把樹根指針置為空，即從空樹開始建立二叉樹 */
/* 每循環一次處理一個字元，直到掃描到字元串結束符為止 */
while(a[i] != ''){
switch(a[i]){
case ' ':
break; /* 對空格不作任何處理 */
case '(':
if(top == STACK_MAX_SIZE - 1){
printf("棧空間太小！n");
exit(1);
}
top++;
s[top] = p;
k = 1;
break;
case ')':
if(top == -1){
printf("二叉樹廣義表字元串錯誤!n");
exit(1);
}
top--;
break;
case ',':
k = 2;
break;
default:
p = malloc(sizeof(struct BTreeNode));
p->data = a[i];
p->left = p->right = NULL;
if(*bt == NULL){
*bt = p;
}else{
if( k == 1){
s[top]->left = p;
}else{
s[top]->right = p;
}
}
}
i++; /* 為掃描下一個字元修改i值 */
}
return;
}

/* 3.檢查二叉樹是否為空，為空則返回1,否則返回0 */
int emptyBTree(struct BTreeNode *bt)
{
if(bt == NULL){
return 1;
}else{
return 0;
}
}

/* 4.求二叉樹深度 */
int BTreeDepth(struct BTreeNode *bt)
{
if(bt == NULL){
return 0; /* 對於空樹，返回0結束遞歸 */
}else{
int dep1 = BTreeDepth(bt->left); /* 計算左子樹的深度 */
int dep2 = BTreeDepth(bt->right); /* 計算右子樹的深度 */
if(dep1 > dep2){
return dep1 + 1;
}else{
return dep2 + 1;
}
}
}

/* 5.從二叉樹中查找值為x的結點，若存在則返回元素存儲位置，否則返回空值 */
elemType *findBTree(struct BTreeNode *bt, elemType x)
{
if(bt == NULL){
return NULL;
}else{
if(bt->data == x){
return &(bt->data);
}else{ /* 分別向左右子樹遞歸查找 */
elemType *p;
if(p = findBTree(bt->left, x)){
return p;
}
if(p = findBTree(bt->right, x)){
return p;
}
return NULL;
}
}
}

/* 6.輸出二叉樹(前序遍歷) */
void printBTree(struct BTreeNode *bt)
{
/* 樹為空時結束遞歸，否則執行如下操作 */
if(bt != NULL){
printf("%c", bt->data); /* 輸出根結點的值 */
if(bt->left != NULL || bt->right != NULL){
printf("(");
printBTree(bt->left);
if(bt->right != NULL){
printf(",");
}
printBTree(bt->right);
printf(")");
}
}
return;
}

/* 7.清除二叉樹，使之變為一棵空樹 */
void clearBTree(struct BTreeNode* *bt)
{
if(*bt != NULL){
clearBTree(&((*bt)->left));
clearBTree(&((*bt)->right));
free(*bt);
*bt = NULL;
}
return;
}

/* 8.前序遍歷 */
void preOrder(struct BTreeNode *bt)
{
if(bt != NULL){
printf("%c ", bt->data); /* 訪問根結點 */
preOrder(bt->left); /* 前序遍歷左子樹 */
preOrder(bt->right); /* 前序遍歷右子樹 */
}
return;
}

/* 9.前序遍歷 */
void inOrder(struct BTreeNode *bt)
{
if(bt != NULL){
inOrder(bt->left); /* 中序遍歷左子樹 */
printf("%c ", bt->data); /* 訪問根結點 */
inOrder(bt->right); /* 中序遍歷右子樹 */
}
return;
}

/* 10.後序遍歷 */
void postOrder(struct BTreeNode *bt)
{
if(bt != NULL){
postOrder(bt->left); /* 後序遍歷左子樹 */
postOrder(bt->right); /* 後序遍歷右子樹 */
printf("%c ", bt->data); /* 訪問根結點 */
}
return;
}

/* 11.按層遍歷 */
void levelOrder(struct BTreeNode *bt)
{
struct BTreeNode *p;
struct BTreeNode *q[QUEUE_MAX_SIZE];
int front = 0, rear = 0;
/* 將樹根指針進隊 */
if(bt != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = bt;
}
while(front != rear){ /* 隊列非空 */
front = (front + 1) % QUEUE_MAX_SIZE; /* 使隊首指針指向隊首元素 */
p = q[front];
printf("%c ", p->data);
/* 若結點存在左孩子，則左孩子結點指針進隊 */
if(p->left != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = p->left;
}
/* 若結點存在右孩子，則右孩子結點指針進隊 */
if(p->right != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = p->right;
}
}
return;
}

/************************************************************************/

/*
int main(int argc, char *argv[])
{
struct BTreeNode *bt; /* 指向二叉樹根結點的指針 */
char *b; /* 用於存入二叉樹廣義表的字元串 */
elemType x, *px;
initBTree(&bt);
printf("輸入二叉樹廣義表的字元串：n");
/* scanf("%s", b); */
b = "a(b(c), d(e(f, g), h(, i)))";
createBTree(&bt, b);
if(bt != NULL)
printf(" %c ", bt->data);
printf("以廣義表的形式輸出：n");
printBTree(bt); /* 以廣義表的形式輸出二叉樹 */
printf("n");
printf("前序："); /* 前序遍歷 */
preOrder(bt);
printf("n");
printf("中序："); /* 中序遍歷 */
inOrder(bt);
printf("n");
printf("後序："); /* 後序遍歷 */
postOrder(bt);
printf("n");
printf("按層："); /* 按層遍歷 */
levelOrder(bt);
printf("n");
/* 從二叉樹中查找一個元素結點 */
printf("輸入一個待查找的字元：n");
scanf(" %c", &x); /* 格式串中的空格跳過空白字元 */
px = findBTree(bt, x);
if(px){
printf("查找成功：%cn", *px);
}else{
printf("查找失敗！n");
}
printf("二叉樹的深度為：");
printf("%dn", BTreeDepth(bt));
clearBTree(&bt);
return 0;
}
*/

Ⅱ C語言中，到底先序遍歷、中序遍歷、後續遍歷怎麼看的...真的快瘋掉了！求高人指點指點...淚目

先序遍歷就是「根左右」，不管你現在在哪個節點，都是按這種規則。上面的題目：根是A，左是B，右是C，所以是A-》B，在當前根節點B，還是按上述規則，那麼接下來到D，D之後沒有子節點，返回B，遍歷E-》X，X之後沒有子節點，返回E，E的子節點都遍歷完了，返回B，B的子節點都遍歷完了，返回A，接下來遍歷右子樹，規則同上。
中序遍歷就是「左根右」，對於A來說，先遍歷B，對於B來說，先遍歷D，對於D來說，已經沒有左子樹，所以遍歷D，D沒有右子樹,返回B，遍歷B，B有右子樹E，對於E來說，先遍歷X，完了返回E，E完了返回B，B完了返回A，遍歷A，遍歷右子樹，規則同上。
後序遍歷就是跟先序遍歷相反的，先遍歷右子樹，再左子樹，最後才是根。
好好思考一下。

Ⅲ c語言中排序方法

1、冒泡排序（最常用）
冒泡排序是最簡單的排序方法：原理是：從左到右，相鄰元素進行比較。每次比較一輪，就會找到序列中最大的一個或最小的一個。這個數就會從序列的最右邊冒出來。（注意每一輪都是從a[0]開始比較的）

以從小到大排序為例，第一輪比較後，所有數中最大的那個數就會浮到最右邊；第二輪比較後，所有數中第二大的那個數就會浮到倒數第二個位置……就這樣一輪一輪地比較，最後實現從小到大排序。

2、雞尾酒排序
雞尾酒排序又稱雙向冒泡排序、雞尾酒攪拌排序、攪拌排序、漣漪排序、來回排序或快樂小時排序, 是冒泡排序的一種變形。該演算法與冒泡排序的不同處在於排序時是以雙向在序列中進行排序。
原理：數組中的數字本是無規律的排放，先找到最小的數字，把他放到第一位，然後找到最大的數字放到最後一位。然後再找到第二小的數字放到第二位，再找到第二大的數字放到倒數第二位。以此類推，直到完成排序。

3、選擇排序
思路是設有10個元素a[1]-a[10]，將a[1]與a[2]-a[10]比較，若a[1]比a[2]-a[10]都小，則不進行交換。若a[2]-a[10]中有一個以上比a[1]小，則將其中最大的一個與a[1]交換，此時a[1]就存放了10個數中最小的一個。同理，第二輪拿a[2]與a[3]-a[10]比較，a[2]存放a[2]-a[10]中最小的數，以此類推。

4、插入排序
插入排序是在一個已經有序的小序列的基礎上，一次插入一個元素*
一般來說，插入排序都採用in-place在數組上實現。
具體演算法描述如下：
⒈ 從第一個元素開始，該元素可以認為已經被排序
⒉ 取出下一個元素，在已經排序的元素序列中從後向前掃描
⒊ 如果該元素（已排序）大於新元素，將該元素移到下一位置
⒋ 重復步驟3，直到找到已排序的元素小於或者等於新元素的位置
⒌ 將新元素插入到下一位置中
⒍ 重復步驟2~5

Ⅳ C語言前序遍歷輸入後序非遞歸遍歷輸出演算法

//輸入先序擴展序列:6500700
//後序遍歷序列:576
//6
///
//57
////
//0000

//輸入先序擴展序列:4210030050600
//後序遍歷序列:132654
//
//4
///
//25
////
//1306
/////
//000000

#include<stdio.h>
#include<stdlib.h>
#definemax100//20//棧的大小
structbitree//二叉樹的結構體
{
intdata;
structbitree*llink;//左分支
structbitree*rlink;//右分支
};

structstack_post//棧的結構體[用於後序遍歷]
{
structbitree*bt;//指向二叉樹
intleftOrRight;//當前節點是哪個分支,1=左分支0=右分支
};

structstack_postsk[max];//全局變數:棧(用於後序遍歷)

//voidbuild(structbitree*n)
//創建二叉樹:先序擴展序列+遞歸法
voidbuild(structbitree**n)
{
//注:structbitree**n是指針的指針
intch;
scanf("%d",&ch);
if(ch==0)
{
*n=NULL;
}
else
{
*n=(structbitree*)malloc(sizeof(structbitree));
if(*n==NULL)
{
printf("
Memoryoverflow!
");
exit(1);
}
(*n)->data=ch;
build(&((*n)->llink));
build(&((*n)->rlink));
}
//原代碼
/*
n=(structbitree*)malloc(sizeof(structbitree));
scanf("%d",&ch);
if(ch==0)
n=NULL;
else
{
if(!(n=(structbitree*)malloc(sizeof(structbitree))))
{
return;
}
n->data=ch;
build(n->llink);
build(n->rlink);
}
*/
}

//後序遍歷序列(非遞歸)
voidPost_Order(structbitree*n)
{
structbitree*p=NULL;
////structstack_postsk[max];//全局變數:棧(用於後序遍歷)
inttop=0;//棧頂為0,top=1用於存放第1個數據
intleftOrRight;//當前節點是哪個分支,1=左分支0=右分支
structbitree*tmpTree;

if(n==NULL)return;
p=n;//當前二叉樹的節點
leftOrRight=1;//1=左分支(默認從左分支開始遍歷)
while(p!=NULL)
{
if(p->llink!=NULL)//有左分支,當前節點入棧
{
top++;
sk[top].bt=p;
sk[top].leftOrRight=leftOrRight;
p=p->llink;
leftOrRight=1;
}
elseif(p->rlink!=NULL)//有右分支,當前節點入棧
{
top++;
sk[top].bt=p;
sk[top].leftOrRight=leftOrRight;
p=p->rlink;
leftOrRight=0;
}
else//該節點是"葉子"
{
printf("%d",p->data);
while(1)//處於"回溯"狀態
{
tmpTree=sk[top].bt;//看[棧頂]
if(tmpTree==NULL)//[棧]已經沒有數據
{
p=NULL;//整個遍歷過程結束,退出循環
break;
}
if(leftOrRight==1)//處於"左分支"回溯
{
if(tmpTree->rlink==NULL)//[棧頂]的節點沒有右分支,出棧,列印
{
p=sk[top].bt;
leftOrRight=sk[top].leftOrRight;
top--;
printf("%d",p->data);
//仍然處於"回溯"狀態
}
else//[棧頂]的節點有右分支,不出棧,右分支成為當前節點
{
p=tmpTree->rlink;
leftOrRight=0;//設置當前處於右分支
break;//退出"回溯"狀態
}
}
else//處於"右分支"回溯
{
//[棧]有節點,出棧,列印
p=sk[top].bt;
leftOrRight=sk[top].leftOrRight;
top--;
printf("%d",p->data);
//仍然處於"回溯"狀態
}
}//while(1)結束
}//if(p->llink!=NULL)else結束
}//while(p!=NULL)結束

//棧頂top=0,說明[棧]已經沒有數據
printf("
核對,棧頂top=%d
",top);
}

//有錯誤
//原代碼,後序遍歷序列(非遞歸)
/*
voidpostorder(structbitree*n)
{
structbitree*p,*q;
inti;
p=(structbitree*)malloc(sizeof(structbitree));
p=n;
q=(structbitree*)malloc(sizeof(structbitree));
structbitree*s[max];
for(i=0;i<max;i++)
{
s[i]=(structbitree*)malloc(sizeof(structbitree));
}
inttop=-1;
do
{
while(p!=NULL)
{
if(p->rlink!=NULL)
{
top++;
s[top]=p->rlink;
}
p=p->llink;;
}
p=s[top];
top--;
if(p->rlink==NULL||p->rlink==q)
{
printf("%d",p->data);
q=p;
p=NULL;
}
else
p=p->rlink;
}while(p!=NULL||top!=-1);
}
*/

//後序遍歷序列(遞歸)[用於對比測試]
voidpostTest(structbitree*n)
{
if(n!=NULL)
{
postTest(n->llink);
postTest(n->rlink);
printf("%d",n->data);
}
}

intmain()
{
structbitree*n;
//原代碼n=(structbitree*)malloc(sizeof(structbitree));
printf("Inputthepreorder-numbersofthetree('0'forNULL):
");
//原代碼build(n);
build(&n);

printf("
Postorderisbelow:");
//原代碼postorder(n);//後序遍歷序列(非遞歸)
Post_Order(n);//後序遍歷序列(非遞歸)

printf("
後序遍歷序列(遞歸):");
postTest(n);//用於對比測試

printf("
");
return0;
}

Ⅳ 設計一個c語言程序，實現二叉樹的前序、中序、後序的遞歸、非遞歸遍歷運算

#include<malloc.h> // malloc()等
#include<stdio.h> // 標准輸入輸出頭文件，包括EOF(=^Z或F6)，NULL等
#include<stdlib.h> // atoi()，exit()
#include<math.h> // 數學函數頭文件，包括floor()，ceil()，abs()等

#define ClearBiTree DestroyBiTree // 清空二叉樹和銷毀二叉樹的操作一樣

typedef struct BiTNode
{
int data; // 結點的值
BiTNode *lchild,*rchild; // 左右孩子指針
}BiTNode,*BiTree;

int Nil=0; // 設整型以0為空
void visit(int e)
{ printf("%d ",e); // 以整型格式輸出
}
void InitBiTree(BiTree &T)
{ // 操作結果：構造空二叉樹T
T=NULL;
}

void CreateBiTree(BiTree &T)
{ // 演算法6.4：按先序次序輸入二叉樹中結點的值(可為字元型或整型，在主程中定義)，
// 構造二叉鏈表表示的二叉樹T。變數Nil表示空(子)樹。修改
int number;
scanf("%d",&number); // 輸入結點的值
if(number==Nil) // 結點的值為空
T=NULL;
else // 結點的值不為空
{ T=(BiTree)malloc(sizeof(BiTNode)); // 生成根結點
if(!T)
exit(OVERFLOW);
T->data=number; // 將值賦給T所指結點
CreateBiTree(T->lchild); // 遞歸構造左子樹
CreateBiTree(T->rchild); // 遞歸構造右子樹
}
}

void DestroyBiTree(BiTree &T)
{ // 初始條件：二叉樹T存在。操作結果：銷毀二叉樹T
if(T) // 非空樹
{ DestroyBiTree(T->lchild); // 遞歸銷毀左子樹，如無左子樹，則不執行任何操作
DestroyBiTree(T->rchild); // 遞歸銷毀右子樹，如無右子樹，則不執行任何操作
free(T); // 釋放根結點
T=NULL; // 空指針賦0
}
}

void PreOrderTraverse(BiTree T,void(*Visit)(int))
{ // 初始條件：二叉樹T存在，Visit是對結點操作的應用函數。修改演算法6.1
// 操作結果：先序遞歸遍歷T，對每個結點調用函數Visit一次且僅一次
if(T) // T不空
{ Visit(T->data); // 先訪問根結點
PreOrderTraverse(T->lchild,Visit); // 再先序遍歷左子樹
PreOrderTraverse(T->rchild,Visit); // 最後先序遍歷右子樹
}
}

void InOrderTraverse(BiTree T,void(*Visit)(int))
{ // 初始條件：二叉樹T存在，Visit是對結點操作的應用函數
// 操作結果：中序遞歸遍歷T，對每個結點調用函數Visit一次且僅一次
if(T)
{ InOrderTraverse(T->lchild,Visit); // 先中序遍歷左子樹
Visit(T->data); // 再訪問根結點
InOrderTraverse(T->rchild,Visit); // 最後中序遍歷右子樹
}
}

void PostOrderTraverse(BiTree T,void(*Visit)(int))
{ // 初始條件：二叉樹T存在，Visit是對結點操作的應用函數
// 操作結果：後序遞歸遍歷T，對每個結點調用函數Visit一次且僅一次
if(T) // T不空
{ PostOrderTraverse(T->lchild,Visit); // 先後序遍歷左子樹
PostOrderTraverse(T->rchild,Visit); // 再後序遍歷右子樹
Visit(T->data); // 最後訪問根結點

}
}

void main()
{
BiTree T;
InitBiTree(T); // 初始化二叉樹T
printf("按先序次序輸入二叉樹中結點的值,輸入0表示節點為空，輸入範例：1 2 0 0 3 0 0\n");
CreateBiTree(T); // 建立二叉樹T
printf("先序遞歸遍歷二叉樹： ");
PreOrderTraverse(T,visit); // 先序遞歸遍歷二叉樹T
printf("\n中序遞歸遍歷二叉樹： ");
InOrderTraverse(T,visit); // 中序遞歸遍歷二叉樹T
printf(" \n後序遞歸遍歷二叉樹：");
PostOrderTraverse(T,visit); // 後序遞歸遍歷二叉樹T
printf("\n");
}

Ⅵ c語言三種排序

常用的c語言排序演算法主要有三種即冒泡法排序、選擇法排序、插入法排序。

一、冒泡排序冒泡排序：

是從第一個數開始，依次往後比較，在滿足判斷條件下進行交換。代碼實現（以降序排序為例）

#include<stdio.h>

int main()

{

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

int temp;

for (int i = 0; i < 10; i++)

{//循環次數

for (int j = 0; j <10 - i-1; j++)

{

if (array[j] < array[j+1])

{//前面一個數比後面的數大時發生交換 temp = array[j];

array[j] = array[j+1];

array[j + 1] = temp;

}

}

} //列印數組 for (int i = 0; i < 10; i++) printf("%2d", array[i]); return 0;}}

二、選擇排序以升序排序為例：

就是在指定下標的數組元素往後（指定下標的元素往往是從第一個元素開始，然後依次往後），找出除指定下標元素外的值與指定元素進行對比，滿足條件就進行交換。與冒泡排序的區別可以理解為冒泡排序是相鄰的兩個值對比，而選擇排序是遍歷數組，找出數組元素與指定的數組元素進行對比。（以升序為例）

#include<stdio.h>

int main()

{

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

int temp, index;

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

index = i;

for (int j = i; j < 10; j++)

{

if (array[j] < array[index])

index = j;

}

if(i != index)

{

temp = array[i];

array[i] = array[index];

array[index] = temp;

}

for(int i=0;i<10:i++)

printf("%2d"array[i]）

return 0；

}

三、快速排序

是通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

void QuickSort(int* arr, int size)

{

int temp, i, j;

for(i = 1; i <size; i++)

for(j=i; j>0; j--)

{

if(arr[j] <arr[j-1])

{

temp = arr[j];

arr[j]=arr[j-1];

arr[j-1]=temp;

}

}

}

Ⅶ 用C語言實現前序和中序恢復二叉樹

按照你題目要求做的。。。

由於我不知道你的TNode類是怎麼定義的，所以我就直接輸出結果了

voidInPreToTree(charpreord[],charinord[],intpreleft,intpreright,intinleft,intinright)
{
/*請在BEGIN和END之間實現你的代碼*/
/*****BEGIN*****/
introot2n,leftsize,rightsize;
if(preleft<=preright&&inleft<=inright)
{
for(root2n=inleft;root2n<=inright;root2n++)
if(preord[preleft]==inord[root2n])break;
leftsize=root2n-inleft;
rightsize=inright-root2n;
if(leftsize>0)
InPreToTree(preord,inord,preleft+1,preleft+leftsize,inleft,root2n-1);
if(rightsize>0)
InPreToTree(preord,inord,preleft+leftsize+1,preright,root2n+1,inright);
printf("%c",inord[root2n]);
}
/******END******/
/*請不要修改[BEGIN,END]區域外的代碼*/
}

望採納，謝謝

Ⅷ C語言數據結構樹的前序遍歷演算法求指教

首先創建二叉樹，個人喜歡用先序次序創建，如
int CreateBiTree(Tree *T)// 按先序次序輸入二叉樹中結點的值，'#'字元表示空樹，構造二叉鏈表表示的二叉樹T
{
char ch;
scanf("%c",&ch);
if (ch=='#') T = NULL;
else {
if (!(T = (Tree *)malloc(sizeof(Tree)))) return ERROR;
T->data=ch; // 生成根結點
CreateBiTree(T->lchild); // 構造左子樹
CreateBiTree(T->rchild); // 構造右子樹
}
return OK;
}
再者，調用前序遍歷函數，再運用輸出函數輸出前序遍歷的二叉樹，如：
int Visit(int e ) // 輸出元素e的值
{
printf("%c", e );
return OK;
}
int main()
{
Tree *T;
CreateBiTree(T); //調用按先序次序輸入二叉樹中結點的值（一個字元），構造二叉鏈
pre_order(T,Visit);//調用前序遍歷二叉樹演算法
}

Ⅸ 輸入二叉樹中序和後序，求它的前序（c語言）

//有一個小問題，加一句話就行了

#include <stdio.h>
#include <string.h>
char a[10],b[10];

int work(int zi,int zj,int hi,int hj)
{

int i,j,k,fz,fh=hi;
//這句話要加，如果調試的話會發現，有些時候zi是會大於zj的，這個時候要立即返回
if(zi>zj) return 0;
printf("%c",b[hj]);//getchar();
if (zi==zj) return 0;

for (fz=zi;fz<=zj;fz++) if (a[fz]==b[hj])break;
fh=hi+(fz-zi)-1;
//導致zi>zj的原因就是如果 fz=zi的話，那麼fz-1就比zi小了
work(zi,fz-1,hi,fh);
work(fz+1,zj,fh+1,hj-1);
}

//這樣就OK了

//測試數據
//Sample Input

// ABCDEFG ACBFGED

//Sample Output

// DBACEGF

int main()
{
scanf("%s%s",a,b);
work(0,strlen(a)-1,0,strlen(b)-1);
while (1);
return 0;
}

Ⅹ C語言中，前序遍歷，中序遍歷各什麼意思

前序遍歷：先訪問根節點，然後訪問左子樹，再訪問右子樹。
中序遍歷：先訪問左子樹，然後訪問根節點，再訪問右子樹。