數據結構樹演算法
⑴ 數據結構關於二叉樹的演算法問題
bt的結點個數、二叉樹bt的深度、求二叉樹bt的葉子結點個數都是作為函數的返回值返回給調用者，在函數中沒有輸出，但是就沒有輸出了。改很簡單：
cout<<"(6)二叉樹bt的結點個數是："<<Count_BT(bt);
cout<<endl;
cout<<"(2)二叉樹bt的深度是："<<Depth_BT(bt);
cout<<endl;
cout<<"(2)二叉樹bt的葉子結點個數是："<<Leafs_BT(bt);
就ok了。
⑵ 數據結構課程設計（C版語言）二叉排序樹演算法
下面的程序包含了樹二叉樹的所有操作
在二叉樹的應用中有二叉排序樹。
都是C語言，只不過用了C++的cin(輸入)和cout（輸出）,因為這兩個不需要格式控制符。
//建一個工程：包含頭文件：bittree.h Cpp文件：bittree.cpp main函數:main.cpp
編譯運行就可以了。
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//頭文件 bittree.h
#ifndef _DEF
#define _DEF
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#define TURE 1
#define OK 1
#define FALSE 0
#define ERROR 0
#define INFEASIBLE -1//不可實行的
#define OVERFLOW -2
typedef int stas;
typedef char Telemtype;
//typedef int Telemtype2;//為了二叉排序樹的創建
typedef char ElemType;
#define STACK_SIZE 100;
#define STACKINCREMENT 10;
//二叉樹
typedef struct bitnode{
Telemtype data;
struct bitnode *lchild,*rchild;
}BitNode,*BitTree;
extern stas CreateBitTree(BitTree &T);
extern stas PreOrderTraverse(BitTree T);
extern stas InOrderTraverse(BitTree T);
extern stas PostOrderTraverse(BitTree T);
typedef BitNode selemtypechar;
typedef BitTree selemtypechar2;
// 棧
typedef struct SqStack{
selemtypechar2 *base;
selemtypechar2 *top;
int stacksize;
}sqstack;
extern stas initstackC(sqstack &S);
extern stas gettopC(sqstack S,selemtypechar2 &e);
extern stas pushC(sqstack &S,selemtypechar2 e);
extern stas popC(sqstack &S,selemtypechar2 &e);
extern stas destroyC(sqstack &S);//銷毀
extern stas clearC(sqstack &S);//置空
extern stas stackempty(sqstack S);
//棧實現二叉樹的輸出
extern stas PreOrderTraverse2(BitTree T);
extern stas InOrderTraverse2(BitTree T);
extern stas PostOrderTraverse2(BitTree T);
//二叉樹的應用
extern stas Depth(BitTree T);
extern stas Single(BitTree T);
extern stas Double(BitTree T);
extern stas CountLeaf(BitTree T);
extern void Change_Left_Right(BitTree T);
//二叉層次遍歷用到隊列
typedef BitTree Qelemtype;
typedef struct QNode{
Qelemtype data;
struct QNode *next;
}qnode,*QueuePtr;
typedef struct {
QueuePtr front;
QueuePtr rear;
}LinkQueue;
extern stas InitQueue(LinkQueue &Q);
extern stas DestroyQueue(LinkQueue &Q);
extern stas EnterQueue(LinkQueue &Q,Qelemtype e);
extern stas DeQueue(LinkQueue &Q,Qelemtype &e);
//二叉層次遍歷
extern stas LevelOrder(BitTree T);
//二叉排序樹
extern void insert(BitTree &T,ElemType x);
extern void CreateBiTree2(BitTree &root);
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//cpp文件 bittree.cpp
#include "bittree.h"
#include <stdlib.h>
stas initstackC (sqstack &s)
{
s.base=(selemtypechar2 *)malloc(100*sizeof(selemtypechar));//用STACKINCREMENT會報錯？？？
if (!s.base) exit(OVERFLOW);
s.top=s.base;
s.stacksize=100;
return OK;
}
stas gettopC(sqstack s,selemtypechar2 &e)
{
if(s.base==s.top) return ERROR;
e=*(s.top-1);
return OK;
}
stas pushC(sqstack &s,selemtypechar2 e)
{
if ((s.top-s.base)>=s.stacksize)
{
s.base=(selemtypechar2 *)realloc(s.base,((s.stacksize+10)*(sizeof(selemtypechar))));
if(!s.base) exit(OVERFLOW);
s.top=s.base+s.stacksize;
s.stacksize+=10;
}
*(s.top++)=e;
//s.top++;
return OK;
}
stas popC(sqstack &s,selemtypechar2 &e)
{
if(s.top==s.base) return ERROR;
--s.top;
e=*(s.top);
return OK;
}
stas destroyC(sqstack &s)
{
free(s.base); s.base=NULL;s.top=NULL;
return OK;
}
stas clearC(sqstack &s)
{
s.top=s.base;
return OK;
}
stas stackempty(sqstack s)
{
if(s.top!=s.base) return ERROR;
else
return OK;
}
//二叉樹
stas CreateBitTree(BitTree &T)//創建
{
Telemtype ch;
cin>>ch;
if(ch=='#') T=NULL;
else{
T=(BitTree)malloc(sizeof(BitNode));
if (!T) exit (OVERFLOW);
T->data=ch;
CreateBitTree(T->lchild);
CreateBitTree(T->rchild);
}
return OK;
}
stas PreOrderTraverse(BitTree T)//先序訪問
{
if(!T) return ERROR;
else if (T)
{
cout<<T->data<<" ";
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
return OK;
}
stas InOrderTraverse(BitTree T)//中序
{
if(!T) return ERROR;
else if (T)
{
InOrderTraverse(T->lchild);
cout<<T->data<<" ";
InOrderTraverse(T->rchild);
}
return OK;
}
stas PostOrderTraverse(BitTree T)//後序
{
if(!T) return ERROR;
else if (T)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout<<T->data<<" ";
}
return OK;
}
//棧實現二叉樹的訪問
stas PreOrderTraverse2(BitTree T)//先序
{
sqstack s;
BitTree p;
initstackC(s);
p=T;
//pushC(s,p);
while (p||!stackempty(s))
{
//popC(s,p);
if (p)
{
pushC(s,p);
if(!p->data)return ERROR;
cout<<p->data<<" ";
//p1=p;
p=p->lchild;
if (p==NULL)
{
popC(s,p);
p=p->rchild;
}
else
pushC(s,p);
}
else {
popC(s,p);
popC(s,p);
p=p->rchild;
if (p==NULL)
{
popC(s,p);
if (p==NULL)
{
return OK;
}
else
{
p=p->rchild;
}
}
else{
pushC(s,p);
if(!p->data)return ERROR;
cout<<p->data<<" ";
p=p->lchild;//左空不壓棧
if (p==NULL)
{
popC(s,p);
p=p->rchild;
}
else
pushC(s,p);
}
}
}
destroyC(s);
return OK;
}
stas InOrderTraverse2(BitTree T)//中序
{
sqstack s;
BitTree p;
initstackC(s);
p=T;
while (p||!stackempty(s))
{
if (p)
{
pushC(s,p);
p=p->lchild;
}
else {
popC(s,p);
if(!p->data)return ERROR;
cout<<p->data<<" ";
p=p->rchild;
}
}
destroyC(s);
return OK;
}
stas PostOrderTraverse2(BitTree T)//後序
{
sqstack s;
BitTree p;
initstackC(s);
p=T;
while (p||!stackempty(s))
{
if (p)
{
pushC(s,p);
p=p->lchild;
if (p==NULL)
{
popC(s,p);
//p=p->rchild;
if (p->rchild==NULL)
{
if(!p->data)return ERROR;
cout<<p->data<<" ";
//p=p->rchild;
popC(s,p);
if (p==NULL)
{
return OK;
}
else
{
//pushC(s,p);//???右結點重復壓棧？？？
//p1=p;
p=p->rchild;
//p->rchild=NULL;
}
}
else
{
p=p->rchild;
}
}
else
continue ;
}
else
{
//popC(s,p);
if(!p->data)return ERROR;
cout<<p->data<<" ";
popC(s,p);
if (p==NULL)
{
return OK;
}
else
{
//pushC(s,p);
//p1=p;
p=p->rchild;
//p->rchild=NULL;
}
}
}
destroyC(s);
return OK;
}
//二叉樹的應用
//二叉樹的深度
stas Depth(BitTree T)
{
int depthval,depthLeft,depthRight;
if (!T) depthval=0;
else{
depthLeft=Depth(T->lchild);
depthRight=Depth(T->rchild);
depthval=1+(depthLeft>depthRight?depthLeft:depthRight);
}
return depthval;
}
//二叉樹的單分支結點數
stas Single(BitTree T)
{
if (T==NULL) return 0; //空樹
else if (T->lchild==NULL && T->rchild==NULL) return 0; //葉子結點
else{
if (!T->lchild && T->rchild) return Single(T->rchild)+1;//只有左單分支
if (T->lchild && !T->rchild) return Single(T->lchild)+1;//只有右單分支
if(T->lchild && T->rchild) return Single(T->lchild)+Single(T->rchild);//雙分支結點
}
}
//二叉樹的多分支結點數
stas Double(BitTree T)
{
if (T==NULL) return 0; //空樹
else if (T->lchild==NULL && T->rchild==NULL) return 0; //葉子結點
else{
if (!T->lchild && T->rchild) return Double(T->rchild);//只有左單分支
if (T->lchild && !T->rchild) return Double(T->lchild);//只有右單分支
if(T->lchild && T->rchild) return Double(T->lchild)+Double(T->rchild)+1;//雙分支結點
}
}
//葉子結點
stas CountLeaf(BitTree T)
{
int num,num1,num2;
if(T==NULL) num=0;
else if(T->lchild==NULL&&T->rchild==NULL)
num=1;
else
{
num1=CountLeaf(T->lchild);
num2=CountLeaf(T->rchild);
num=num1+num2;
}
return num;
}
//交換左右子樹
void Change_Left_Right(BitTree T)
{
BitTree Temp;
if (T)
{
Change_Left_Right(T->lchild);
Change_Left_Right(T->rchild);
Temp=T->lchild;
T->lchild=T->rchild;
T->rchild=Temp;
}
}
//二叉層次遍歷用到隊列
stas InitQueue(LinkQueue &Q)
{
Q.front=Q.rear=(QueuePtr)malloc(100*sizeof(qnode));
if(!Q.front) exit(OVERFLOW);
Q.front->next=NULL;
return OK;
}
stas DestroyQueue(LinkQueue &Q)
{
while (Q.front)
{
Q.rear=Q.front->next;
free(Q.front);
Q.front=Q.rear;
}
return OK;
}
stas EnterQueue(LinkQueue &Q,Qelemtype e)
{
QueuePtr p;
p=(QueuePtr)malloc(sizeof(qnode));
if(!p) return ERROR;
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return OK;
}
stas DeQueue(LinkQueue &Q,Qelemtype &e)
{ QueuePtr p;
if(Q.front==Q.rear) return ERROR;
p=Q.front->next;e=p->data;
Q.front->next=p->next;
if(Q.rear==p)Q.rear=Q.front;
free(p);
return OK;
}
//二叉層次遍歷
stas LevelOrder(BitTree T)
{
LinkQueue Q;
BitTree B;
InitQueue(Q);
if (T!=NULL)
{
EnterQueue(Q,T);
while (!(Q.front==Q.rear))
{
DeQueue(Q,B);
cout<<B->data<<" ";
if(B->lchild!=NULL) EnterQueue(Q,B->lchild);
if(B->rchild!=NULL) EnterQueue(Q,B->rchild);
}
}
return OK;
}
//二叉排序樹
void insert(BitTree &T,ElemType x)
{
if (T==NULL)
{
T=(BitTree)malloc(sizeof(BitNode));
T->data=x;
T->lchild=T->rchild=NULL;
}
else
{
if(x<T->data)insert(T->lchild,x);
if(x>=T->data)insert(T->rchild,x);
}
}
void CreateBiTree2(BitTree &root)
{
ElemType x;
root=NULL;
cout<<"二叉排序樹的創建<以'#'結束!!!>"<<endl;
cout<<"<請輸入字母，沒寫整型!!!>"<<endl;
cin>>x;
while (x!='#')
{
insert(root,x);
cin>>x;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//主函數 main.cpp
#include "bittree.h"
void main()
{
system("cls");
system("color f0");
BitTree T;
Create:
cout<<'\t'<<'\t'<<"先序創建二叉樹<以'#'表示左右孩子為空!!!>："<<endl;
CreateBitTree(T);
BitTree T1(T);
select:
cout<<'\t'<<'\t'<<"----------------MAIN-MENU----------------"<<endl;
cout<<'\t'<<'\t'<<"&1、先序輸出 2、中序輸出 3、後序輸出 &"<<endl;
cout<<'\t'<<'\t'<<"&4、棧實現輸出 5、重新創建二叉樹 0、退出&"<<endl;
cout<<'\t'<<'\t'<<"------------6、二叉樹的應用-------------"<<endl;
char sel;
getchar();
cin>>sel;
switch (sel)//總
{
case '0':
break;
case '1':cout<<endl<<"---------------------------------"<<endl;
PreOrderTraverse(T);
cout<<endl<<"---------------------------------"<<endl;
goto select;
case '2':cout<<endl<<"---------------------------------"<<endl;
InOrderTraverse(T);
cout<<endl<<"---------------------------------"<<endl;
goto select;
case '3':cout<<endl<<"---------------------------------"<<endl;
PostOrderTraverse(T);
cout<<endl<<"---------------------------------"<<endl;
goto select;
case '4':
stackcout:
cout<<endl<<'\t'<<" -------------------SUB-MENU1---------------------"<<endl;
cout<<'\t'<<" &1、先序輸出 2、中序輸出 3、後序輸出 4、返回 &"<<endl;
cout<<'\t'<<" ------------------------------------------------"<<endl;
cin>>sel;
switch (sel)//棧關於樹的輸出
{
case '1':cout<<endl<<"---------------------------------"<<endl;
PreOrderTraverse2(T1);//p->lchild==null,時 T 的值被修改！！！！！！！！
cout<<endl<<"---------------------------------"<<endl;
goto stackcout;
case '2':cout<<endl<<"---------------------------------"<<endl;
InOrderTraverse2(T);
cout<<endl<<"---------------------------------"<<endl;
goto stackcout;
case '3':cout<<endl<<"---------------------------------"<<endl;
PostOrderTraverse(T1);//棧實現未寫完
cout<<endl<<"---------------------------------"<<endl;
goto stackcout;
case '4':goto select;
default:cout<<"選擇錯誤!!!"<<endl;
goto stackcout;
}
case '5':
goto Create;
case '6':
{
SUB_MENU2:
cout<<'\t'<<'\t'<<"-------------------------SUB-MENU2---------------------"<<endl;
cout<<'\t'<<'\t'<<"&1、二叉樹的深度 2、二叉樹的單分支結點數 &"<<endl;
cout<<'\t'<<'\t'<<"&3、二叉樹的多分支結點數 4、二叉樹的葉子結點數 &"<<endl;
cout<<'\t'<<'\t'<<"&5、二叉層次遍歷 6、二叉排序樹 7、交換左右子樹 &"<<endl;
cout<<'\t'<<'\t'<<"&------------------8、輸出 0、返回--------------------&"<<endl;
cin>>sel;
switch (sel)//二叉樹的應用
{
case '0':
goto select;
case '1':
{
int deepth=0;
deepth=Depth(T);
cout<<endl<<"---------------------------------"<<endl;
cout<<"樹的深度為："<<deepth<<endl;
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '2':
{
int cou_sig;
cou_sig=Single(T);
cout<<endl<<"---------------------------------"<<endl;
cout<<"此樹的單分支結點為數："<<cou_sig<<endl;
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '3':
{
int cou_dou;
cou_dou=Double(T);
cout<<endl<<"---------------------------------"<<endl;
cout<<"此樹的雙分支結點數為："<<cou_dou<<endl;
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '4':
{
int cou_leaf;
cou_leaf=CountLeaf(T);
cout<<endl<<"---------------------------------"<<endl;
cout<<"此樹的葉子結點數為："<<cou_leaf<<endl;
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '5':
{
cout<<"二叉層次遍歷的結果為："<<endl;
cout<<endl<<"---------------------------------"<<endl;
LevelOrder(T);
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '6':
{
BitTree T3;
CreateBiTree2(T3);
SUB3:
cout<<'\t'<<"-------------------------SUB-MENU2-------------------"<<endl;
cout<<'\t'<<" &1、先序輸出 2、中序輸出 3、後序輸出 0、返回 &"<<endl;
cout<<'\t'<<"-----------------------------------------------------"<<endl;
cin>>sel;
switch (sel)//二叉樹的層次遍歷
{
case '0':
break;
case '1':cout<<endl<<"---------------------------------"<<endl;
PreOrderTraverse(T3);
cout<<endl<<"---------------------------------"<<endl;
goto SUB3;
case '2':cout<<endl<<"---------------------------------"<<endl;
InOrderTraverse(T3);
cout<<endl<<"---------------------------------"<<endl;
goto SUB3;
case '3':cout<<endl<<"---------------------------------"<<endl;
PostOrderTraverse(T3);
cout<<endl<<"---------------------------------"<<endl;
goto SUB3;
default:
cout<<"選擇錯誤!!!"<<endl;
goto SUB3;
}
}
goto SUB_MENU2;
case '7':
{
Change_Left_Right(T);
cout<<endl<<"---------------------------------"<<endl;
cout<<"交換完成，請選擇8輸出查看!!!"<<endl;
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '8':
goto select;
default:
cout<<"選擇錯誤!!!"<<endl;
goto SUB_MENU2;
}
}
break;
default :
cout<<endl<<"選擇錯誤!!!"<<endl;
goto select;
}
}
⑶ 數據結構演算法設計——統計二叉樹葉子結點的個數，並輸出結果
代碼如下：
#include<stdio.h>
#include<stdlib.h>
typedef struct BiTNode
{
char data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreatTree(BiTree &A)
{
char ch;
scanf("%c",&ch);
if(ch=='#')
{
A=NULL;
}
else
{
A=new BiTNode;
A->data=ch;
CreatTree(A->lchild);
CreatTree(A->rchild);
}
}
int NodeTree(BiTree A)
{
if(A==NULL)
return 0;
else if(A->lchild==NULL&&A->rchild==NULL)
return 1;
else
return NodeTree(A->lchild)+NodeTree(A->rchild);
}
int main()
{
BiTree A;
int b;
printf("先序法賦值（空用#表示）：");
CreatTree(A);
b=NodeTree(A);
printf("共有%d個葉子節點 ",b);
}
(3)數據結構樹演算法擴展閱讀
二叉樹的性質
1、對於任意一棵二叉樹，如果其葉結點數為N0，而度數為2的結點總數為N2，則N0=N2+1；
2、有N個結點的完全二叉樹各結點如果用順序方式存儲，則結點之間有如下關系：
若I為結點編號則 如果I>1，則其父結點的編號為I/2；
如果2*I<=N，則其左孩子（即左子樹的根結點）的編號為2*I；若2*I>N，則無左孩子；
如果2*I+1<=N，則其右孩子的結點編號為2*I+1；若2*I+1>N，則無右孩子。
3、給定N個結點，能構成h(N)種不同的二叉樹。h(N)為卡特蘭數的第N項。h(n)=C(2*n，n)/(n+1)。
4、設有i個枝點，I為所有枝點的道路長度總和，J為葉的道路長度總和J=I+2i[2]
⑷ 數據結構與演算法中，樹一般會應用在哪些方面為什麼
數據結構的演算法，並沒有多少種演算法，關於樹，其實都是對DOM, AST 等應用，對人腦分層分類認知的建模,。樹的一個大類是自平衡二叉搜索樹 (self-balanced BST), 變種特別多:RB 樹是每個節點是紅色或者黑色, 顏色隔代遺傳AVL 樹是每個節點包含平衡因子, 等於左高-右高Splay 樹是每個節點帶個父節點的指針
總的來說，只要有序列的地方就可以應用樹，因為樹結構即是一種序列索引結構。序列的核心介面就是三個cha：插、查、X。
⑸ 數據結構有哪些基本演算法
一、排序演算法 1、有簡單排序（包括冒泡排序、插入排序、選擇排序） 2、快速排序，很常見的 3、堆排序， 4、歸並排序，最穩定的，即沒有太差的情況 二、搜索演算法 最基礎的有二分搜索演算法，最常見的搜索演算法，前提是序列已經有序 還有深度優先和廣度有限搜索；及使用剪枝，A*，hash表等方法對其進行優化。 三、當然，對於基本數據結構，棧，隊列，樹。都有一些基本的操作 例如，棧的pop，push，隊列的取隊頭，如隊；以及這些數據結構的具體實現，使用連續的存儲空間（數組），還是使用鏈表，兩種具體存儲方法下操作方式的具體實現也不一樣。 還有樹的操作，如先序遍歷，中序遍歷，後續遍歷。 當然，這些只是一些基本的針對數據結構的演算法。 而基本演算法的思想應該有：1、回溯2、遞歸3、貪心4、動態規劃5、分治有些數據結構教材沒有涉及基礎演算法，lz可以另外找一些基礎演算法書看一下。有興趣的可以上oj做題，呵呵。演算法真的要學起來那是挺費勁。
⑹ java（樹的內容）演算法與數據結構
其實有兩種方式：
第一種就是遞歸 就像現在比較老的樹形菜單。這種方式應該string類型應該是存不了的。就是自定義一個類型A 裡面有一個成員變數 list<A>。 這種結構就是list裡面嵌套list，你有多少級就有多少層。
第二種其實要做處理，就是把原數據按一定規則排序放到一個list裡面，這裡面不會再嵌套list。list排完序就如你的效果圖一樣。第一個 一級節點 》》其子節點；然後第二個一級節點》》其子節點，etc。 但是這種結構要有存的時候要循環一遍排成上述的順序，取的時候還需要判斷哪個是下一個不同級節點的開始。
js前台展示比較簡單，根據父id直接添加就行了，原數據什麼都不用做。但是java里這種方式不行。
⑺ 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);//調用前序遍歷二叉樹演算法
}
⑻ 數據結構中的是樹形的結構有哪些，演算法叫什麼名字
基礎類：二叉搜索（排序）樹，線索二叉樹，哈夫曼樹（最優二叉樹），二叉堆
平衡樹類：AVL，紅黑樹，2-3樹，2-3-4樹，B樹，B+樹，B-樹，treap，SBT。
優先隊列類：左高樹（左偏樹，可並堆，斜堆），雙端堆，斐波那契堆
集合類：並查集
區間樹類：線段樹，劃分樹，歸並樹，樹狀數組
字母樹類：字典樹，後綴樹。AC自動機演算法
動態樹類：伸展樹
計算幾何類：KD-tree （塊狀樹），4叉樹
RMQ轉LCA：笛卡爾樹
圖論相關：最小生成樹，無根樹
其它：敗者樹，博弈樹
⑼ 數據結構中常用的演算法有哪些啊
基本：
線性表，鏈表，棧，隊列
排序：
快速排序，堆排序，歸並排序，希爾排序，插入排序，選擇排序
二叉樹：
前序，中序，後序遍歷，層次遍歷，包括遞歸演算法和非遞歸演算法兩種
AVL樹，Huffman編碼
二叉樹和樹，森林之間的轉換，穿線樹
圖演算法：
深度優先遍歷演算法，廣度優先遍歷演算法，最小生成樹，最短路徑
字元串：
查找子串，KMP演算法
以上都是比較基本的演算法，一定要弄懂
⑽ 數據結構c二叉樹的演算法
額 我來講講吧：
第一個問題 你問應該用何種方式來存儲，這個問題糾結了，什麼叫應該用什麼方式存儲，當然是都可以啦兩種方式~~不過你的意思可能是哪種方式最好，如果就是進行那兩種操作的話，是順序存儲方式比較好（你應該知道順序和鏈式兩種吧）；其實二叉樹是很少用順序方式存儲的。但是由於你已經說了你是完全二叉樹，那麼就可以考慮順序方式存儲了；書序二叉樹每個節點你可以編號，直接運算序號就可以找到父節點和兩個子節點了。
第二個問題 用C++寫了 就採用鏈式結構吧 每個節點內有lchild rchild指針分別指向左右兩孩子結點;結點類型就假定Node吧:
void exchange (Node * node){
exchange(node->lchild);
exchange(node->rchild)；
Node * n;
n=node->lchild;
node->lchild=node->rchild;
node->rchild=n;
}//遞歸方式實現的函數
exchange(bt);
非遞歸演算法就需要藉助隊列了 代碼較長 不想打了；隊列就是實現按層次操作每個節點；操作玩的結點一次出隊，出隊的同時他們的孩子一次入隊，最後沒有結點入隊出隊就演算法結束了；一般都是深度優先的遞歸演算法來使用樹形結構，很少有按層次結構非遞歸演算法的，樹形結構發明出來就是讓你深度搜索用的