⑴ 順序存儲表示法為什麼不是樹的存儲形式
順序存儲表示法是樹的存儲形式的原因：順序存儲方式不僅能用於存儲線性結構，還可以用來存放非線性結構，例如完全二叉樹是屬於非線性結構，但其最佳存儲方式是順序存儲方式。
對於一般的家譜樹(一般的多叉樹)來說，我們可以很清楚的看出層次關系，樹的層數表示代數（一共多少代人），樹的最後一層表示最後一代人，由於多叉鏈表法表示的不方便，因此被迫無奈採用孩子兄弟表示法(二叉鏈表法)。
結構
二叉樹的順序存儲就是用一組連續的存儲單元存放二又樹中的結點元素，一般按照二叉樹結點自上向下、自左向右的順序存儲。使用此存儲方式，結點的前驅和後繼不一定是它們在邏輯上的鄰接關系，非常適用於滿二又樹和完全二又樹。根據完全二叉樹和滿二叉樹的特性，假設將圖1中的完全二又樹存放在一維數組bree中，將發現結點的編號正好與數組元素的下標對應。
⑵ 假設二叉樹的存儲結構是順序的，用遞歸演算法實現二叉樹上度為0、1、2結點個數的統計，並輸出統計結果
假設根結點在 a[0]，且二叉樹存儲的都是正整數、非結點元素都是0或負值，已經放在數組中了，相關的程序段如下(Pascal代碼）：
var n:array[0..2]of integer; i:integer;
procere work(k:integer);
var t:integer;
begin
if a[k]>0 then
begin
if a[k+k]>0 work(k+k);
if a[k+k+1]>0 work(k+k+1);
t:=ord(a[k+k]>0)+ord(a[k+k+1]>0);
inc(a[t]);
end;
end;
主程序調用：
word(0);
for i:=0 to 2 do
writeln('Degree[',i,'] has ',n[i]);
⑶ c語言（高分）
1.相對於遞歸演算法,遞推演算法免除了數據進出棧的過程，也就是說,不需要函數不斷的向邊界值靠攏,而直接從邊界出發,直到求出函數值.
比如階乘函數：f(n)=n*f(n-1)
在f(3)的運算過程中,遞歸的數據流動過程如下:
f(3){f(i)=f(i-1)*i}-->f(2)-->f(1)-->f(0){f(0)=1}-->f(1)-->f(2)--f(3){f(3)=6}
而遞推如下:
f(0)-->f(1)-->f(2)-->f(3)
由此可見,遞推的效率要高一些,在可能的情況下應盡量使用遞推.但是遞歸作為比較基礎的演算法,它的作用不能忽視.所以,在把握這兩種演算法的時候應該特別注意.
2.所謂排序，就是使一串記錄，按照其中的某個或某些關鍵字的大小，遞增或遞減的排列起來的操作。
分類
在計算機科學所使用的排序演算法通常被分類為：
計算的復雜度（最差、平均、和最好表現），依據串列（list）的大小（n）。一般而言，好的表現是O。(n log n)，且壞的行為是Ω(n2)。對於一個排序理想的表現是O(n)。僅使用一個抽象關鍵比較運算的排序演算法總平均上總是至少需要Ω(n log n)。
記憶體使用量（以及其他電腦資源的使用）
穩定度：穩定排序演算法會依照相等的關鍵（換言之就是值）維持紀錄的相對次序。也就是一個排序演算法是穩定的，就是當有兩個有相等關鍵的紀錄R和S，且在原本的串列中R出現在S之前，在排序過的串列中R也將會是在S之前。
一般的方法：插入、交換、選擇、合並等等。交換排序包含冒泡排序（bubble sort）和快速排序（quicksort）。選擇排序包含shaker排序和堆排序（heapsort）。
當相等的元素是無法分辨的，比如像是整數，穩定度並不是一個問題。然而，假設以下的數對將要以他們的第一個數字來排序。
(4, 1) (3, 1) (3, 7) (5, 6)
在這個狀況下，有可能產生兩種不同的結果，一個是依照相等的鍵值維持相對的次序，而另外一個則沒有：
(3, 1) (3, 7) (4, 1) (5, 6) (維持次序)
(3, 7) (3, 1) (4, 1) (5, 6) (次序被改變)
不穩定排序演算法可能會在相等的鍵值中改變紀錄的相對次序，但是穩定排序演算法從來不會如此。不穩定排序演算法可以被特別地時作為穩定。作這件事情的一個方式是人工擴充鍵值的比較，如此在其他方面相同鍵值的兩個物件間之比較，就會被決定使用在原先資料次序中的條目，當作一個同分決賽。然而，要記住這種次序通常牽涉到額外的空間負擔。
排列演算法列表
在這個表格中，n是要被排序的紀錄數量以及k是不同鍵值的數量。
穩定的
冒泡排序（bubble sort） — O(n2)
雞尾酒排序 (Cocktail sort, 雙向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 額外 記憶體
計數排序 (counting sort) — O(n+k); 需要 O(n+k) 額外 記憶體
歸並排序 （merge sort）— O(n log n); 需要 O(n) 額外記憶體
原地歸並排序 — O(n2)
二叉樹排序 （Binary tree sort） — O(n log n); 需要 O(n) 額外記憶體
鴿巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 額外記憶體
基數排序 （radix sort）— O(n·k); 需要 O(n) 額外記憶體
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 額外記憶體
不穩定
選擇排序 （selection sort）— O(n2)
希爾排序 （shell sort）— O(n log n) 如果使用最佳的現在版本
Comb sort — O(n log n)
堆排序 （heapsort）— O(n log n)
Smoothsort — O(n log n)
快速排序 （quicksort）— O(n log n) 期望時間, O(n2) 最壞情況; 對於大的、亂數串列一般相信是最快的已知排序
Introsort — O(n log n)
Patience sorting — O(n log n + k) 最外情況時間, 需要 額外的 O(n + k) 空間, 也需要找到最長的遞增子序列（longest increasing subsequence）
不實用的排序演算法
Bogo排序 — O(n × n!) 期望時間, 無窮的最壞情況。
Stupid sort — O(n3); 遞回版本需要 O(n2) 額外記憶體
Bead sort — O(n) or O(√n), 但需要特別的硬體
Pancake sorting — O(n), 但需要特別的硬體
排序的演算法
排序的演算法有很多，對空間的要求及其時間效率也不盡相同。下面列出了一些常見的排序演算法。這裡面插入排序和冒泡排序又被稱作簡單排序，他們對空間的要求不高，但是時間效率卻不穩定；而後面三種排序相對於簡單排序對空間的要求稍高一點，但時間效率卻能穩定在很高的水平。基數排序是針對關鍵字在一個較小范圍內的排序演算法。
插入排序
冒泡排序
選擇排序
快速排序
堆排序
歸並排序
基數排序
希爾排序
插入排序
插入排序是這樣實現的：
首先新建一個空列表，用於保存已排序的有序數列（我們稱之為"有序列表"）。
從原數列中取出一個數，將其插入"有序列表"中，使其仍舊保持有序狀態。
重復2號步驟，直至原數列為空。
插入排序的平均時間復雜度為平方級的，效率不高，但是容易實現。它藉助了"逐步擴大成果"的思想，使有序列表的長度逐漸增加，直至其長度等於原列表的長度。
冒泡排序
冒泡排序是這樣實現的：
首先將所有待排序的數字放入工作列表中。
從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。
重復2號步驟，直至再也不能交換。
冒泡排序的平均時間復雜度與插入排序相同，也是平方級的，但也是非常容易實現的演算法。
選擇排序
選擇排序是這樣實現的：
設數組內存放了n個待排數字，數組下標從1開始，到n結束。
i=1
從數組的第i個元素開始到第n個元素，尋找最小的元素。
將上一步找到的最小元素和第i位元素交換。
如果i=n－1演算法結束，否則回到第3步
選擇排序的平均時間復雜度也是O(n²)的。
快速排序
現在開始，我們要接觸高效排序演算法了。實踐證明，快速排序是所有排序演算法中最高效的一種。它採用了分治的思想：先保證列表的前半部分都小於後半部分，然後分別對前半部分和後半部分排序，這樣整個列表就有序了。這是一種先進的思想，也是它高效的原因。因為在排序演算法中，演算法的高效與否與列表中數字間的比較次數有直接的關系，而"保證列表的前半部分都小於後半部分"就使得前半部分的任何一個數從此以後都不再跟後半部分的數進行比較了，大大減少了數字間不必要的比較。但查找數據得另當別論了。
堆排序
堆排序與前面的演算法都不同，它是這樣的：
首先新建一個空列表，作用與插入排序中的"有序列表"相同。
找到數列中最大的數字，將其加在"有序列表"的末尾，並將其從原數列中刪除。
重復2號步驟，直至原數列為空。
堆排序的平均時間復雜度為nlogn,效率高（因為有堆這種數據結構以及它奇妙的特徵，使得"找到數列中最大的數字"這樣的操作只需要O(1)的時間復雜度，維護需要logn的時間復雜度），但是實現相對復雜（可以說是這里7種演算法中比較難實現的）。
看起來似乎堆排序與插入排序有些相像，但他們其實是本質不同的演算法。至少，他們的時間復雜度差了一個數量級，一個是平方級的，一個是對數級的。
平均時間復雜度
插入排序 O(n2)
冒泡排序 O(n2)
選擇排序 O(n2)
快速排序 O(n log n)
堆排序 O(n log n)
歸並排序 O(n log n)
基數排序 O(n)
希爾排序 O(n1.25)
3.索引查找是在索引表和主表(即線性表的索引存儲結構)上進行的查找。索引查找的過程是：首先根據給定的索引值K1，在索引表上查找出索引值等於KI的索引項，以確定對應予表在主表中的開始位置和長度，然後再根據給定的關鍵字K2，茬對應的子表中查找出關鍵字等於K2的元素(結點)。對索引表或子表進行查找時，若表是順序存儲的有序表，則既可進行順序查找，也可進行二分查找，否則只能進行順序查找。
設數組A是具有mainlist類型的一個主表，數組B是具有inde)dist類型的在主表A 上建立的一個索引表，m為索引表B的實際長度，即所含的索引項的個數，KI和K2分別為給定待查找的索引值和關鍵字(當然它們的類型應分別為索引表中索引值域的類型和主表中關鍵字域在索引存儲中，不僅便於查找單個元素，而且更便於查找一個子表中的全部元素。當需要對一個子袁中的全部元素依次處理時，只要從索引表中查找出該子表的開始位
置即可。由此開始位置可以依次取出該子表中的每一個元素，所以整個查找過程的時間復雜度為，若不是採用索引存儲，而是採用順序存儲，即使把它組織成有序表而進行二分查找時，索引查找一個子表中的所有元素與二分查找一個子表中的所有元素相比。
若在主表中的每個子表後都預留有空閑位置，則索引存儲也便於進行插入和刪除運算，因為其運算過程只涉及到索引表和相應的子表，只需要對相應子表中的元素進行比較和移動，與其它任何子表無關，不像順序表那樣需涉及到整個表中的所有元素，即牽一發而動全身。
在線性表的索引存儲結構上進行插入和刪除運算的演算法，也同查找演算法類似，其過程為：首先根據待插入或刪除元素的某個域(假定子表就是按照此域的值劃分的)的值查找索引表，確定出對應的子表，然後再根據待插入或刪除元素的關鍵字，在該子表中做插入或刪除元素的操作。因為每個子表不是順序存儲，就是鏈接存儲，所以對它們做插入或刪除操作都是很簡單的。
4.插入法排序
#define N 10
#include"stdio.h"
main()
{ int i,j,k,t,a[N];
clrscr();
printf("Please input %d numbers:\n",N);
for(i=0;i<N;i++)
scanf("%d",&a[i]);
for(i=1;i<N;i++)
{
for(j=0;j<i;j++)
{if(a[j]>a[i])
{t=a[i];
for(k=i;k>=j;k--)
a[k]=a[k-1];
a[j]=t;
}
}
}
printf("small to big order:\n");
for(i=0;i<N;i++)
printf("%-2d",a[i]);
printf("\n");
getch();
}
⑷ 二叉樹的中序、前序、後序的遞歸、非遞歸遍歷演算法，層次序的非遞歸遍歷演算法的實現，應包含建樹的實現。
二叉樹的遍歷是指按照一定次序訪問二叉樹中的所有節點，且每個節點僅被訪問一次的過程。是最基本的運算，是其他運算的基礎。
二叉樹有兩種存儲結構：順序存儲和鏈式存儲
順序存儲： （對完全二叉樹來說，可以充分利用存儲空間，但對於一般的二叉樹，只有少數的存儲單元被利用）
[cpp] view plain
typedef struct
{
ElemType data[MaxSize];
int n;
}SqBTree;
鏈式存儲：
[csharp] view plain
typedef struct node
{
ElemType data;
struct node *lchild;
struct node *rchild;
} BTNode;
二叉樹三種遞歸的遍歷方法：
先序遍歷 訪問根節點→先序遍歷左子樹→先序遍歷右子樹
中序遍歷 中序遍歷左子樹→訪問根節點→中序遍歷右子樹
後序遍歷 後序遍歷左子樹→後序遍歷右子樹→訪問根節點
二叉樹遍歷的遞歸演算法：
[cpp] view plain
void preOrder(BTNode *b) //先序遍歷遞歸演算法
{
if (b!=NULL)
{
visit(b);
preOrder(b->lchild);
preOrder(b->rchild);
}
}
void InOrder(BTNode *b) //中序遍歷遞歸演算法
{
if(b!=NULL)
{
InOrder(b->lchild);
visit(b);
InOrder(b->rchild);
}
}
void PostOrder(BTNode *b) //後序遍歷遞歸演算法
{
if(b!=NULL){
PostOrder(b->lchild);
PostOrder(b->rchild);
visit(b);
}
}
二叉樹非遞歸遍歷演算法：
有兩種方法：①用棧存儲信息的方法 ②增加指向父節點的指針的方法 暫時只介紹下棧的方法
先序遍歷：
[cpp] view plain
void PreOrder(BTNode *b)
{
Stack s;
while(b!=NULL||!s.empty())
{
if(b!=NULL){
visit(b);
s.push(b);
b=b->left;
}
else{
b=s.pop();
b=b->right;
}
}
}
中序遍歷：
[cpp] view plain
void InOrder(BTNode *b){
Stack s;
while(b!=NULL||!s.empty()){
if (b!=NULL)
{
s.push(b);
s=s->left
}
if(!s.empty()){
b=s.pop();
visit(b);
b=b->right;
}
}
}
後序遍歷：
[cpp] view plain
void PostOrder(BTNode *b){
Stack s;
while(b!=NULL){
s.push(b);
}
while(!s.empty()){
BTNode* node=s.pop();
if(node->bPushed){
visit(node);
}
else{
s.push(node);
if(node->right!=NULL){
node->right->bPushed=false;
s.push(node->right);
}
if(node->left!=NULL){
node->left->bpushed=false;
s.push(node->left);
}
node->bPushed=true; //如果標識位為true,則表示入棧
}
}
}
層次遍歷演算法：（用隊列的方法）
[cpp] view plain
void levelOrder(BTNode *b){
Queue Q;
Q.push(b);
while(!Q.empty()){
node=Q.front();
visit(node);
if(NULL!=node->left){
Q.push(node->left);
}
if(NULL!=right){
Q.push(node->right);
}
}
}<span style=""></span>
已知先序和中序求後序的演算法：（已知後序和中序求先序的演算法類似，但已知先序和後序無法求出中序）
[cpp] view plain
int find(char c,char A[],int s,int e) /* 找出中序中根的位置。 */
{
int i;
for(i=s;i<=e;i++)
if(A[i]==c) return i;
}
/* 其中pre[]表示先序序，pre_s為先序的起始位置，pre_e為先序的終止位置。 */
/* 其中in[]表示中序，in_s為中序的起始位置，in_e為中序的終止位置。 */
/* pronum()求出pre[pre_s～pre_e]、in[in_s～in_e]構成的後序序列。 */
void pronum(char pre[],int pre_s,int pre_e,char in[],int in_s,int in_e)
{
char c;
int k;
if(in_s>in_e) return ; /* 非法子樹，完成。 */
if(in_s==in_e){printf("%c",in[in_s]); /* 子樹子僅為一個節點時直接輸出並完成。 */
return ;
}
c=pre[pre_s]; /* c儲存根節點。 */
k=find(c,in,in_s,in_e); /* 在中序中找出根節點的位置。 */
pronum(pre,pre_s+1,pre_s+k-in_s,in,in_s,k-1); /* 遞歸求解分割的左子樹。 */
pronum(pre,pre_s+k-in_s+1,pre_e,in,k+1,in_e); /* 遞歸求解分割的右子樹。 */
printf("%c",c); /* 根節點輸出。 */
}
main()
{
char pre[]="abdc";
char in[]="bdac";
printf("The result:");
pronum(pre,0,strlen(in)-1,in,0,strlen(pre)-1);
getch();
}
⑸ 一棵完全二叉樹以順序方式存儲，設計一個遞歸演算法，對該完全二叉樹進行中序遍歷。
這棵樹根節點是tree[1],順序存儲。最後一個葉子節點是tree[maxnode];
void mid(int treenode)
{ if (treenode > maxnode) return;
mid(treenode * 2);
visit(treenode) /*訪問treenode節點*/
mid(treenode * 2 + 1);
}
⑹ 題目是1.___是實現遞歸所必須的存儲結構。
肯定是棧啊，遞歸函數中先調用的函數後結束，滿足後進先出的性質。
邏輯結構描述的是元素之間的位置關系，而存儲結構是元素在內存中是怎樣存儲的，順序存儲或鏈式存儲。
⑺ 順序存儲方式只能用於存儲線性結構嗎
不是。
順序存儲方式不僅能用於存儲線性結構，還可以用來存放非線性結構，例如完全二叉樹是屬於非線性結構，但其最佳存儲方式是順序存儲方式。
數據的邏輯結構包括線性結構、樹、圖、集合這四種，在線性結構裡面又有線性表、棧、隊列等等。而數據的存儲結構只有兩種：順序存儲結構和鏈式存儲結構，這兩種存儲結構，前面一個是利用數據元素在存儲器中的相對位置表示其邏輯結構，另外一個是用指針來表示其邏輯關系。
順序存儲結構
的主要優點是節省存儲空間，因為分配給數據的存儲單元全用存放結點的數據（不考慮c/c++語言中數組需指定大小的情況），結點之間的邏輯關系沒有佔用額外的存儲空間。
採用這種方法時，可實現對結點的隨機存取，即每一個結點對應一個序號，由該序號可以直接計算出來結點的存儲地址。但順序存儲方法的主要缺點是不便於修改，對結點的插入、刪除運算時，可能要移動一系列的結點。
⑻ 二叉樹先序遍歷遞歸演算法和非遞歸演算法本質區別
1. 先序遍歷
在先序遍歷中，對節點的訪問工作是在它的左右兒子被訪問之前進行的。換言之，先序遍歷訪問節點的順序是根節點-左兒子-右兒子。由於樹可以通過遞歸來定義，所以樹的常見操作用遞歸實現常常是方便清晰的。遞歸實現的代碼如下：
void PreOrderTraversal(BinTree BT)
{
if( BT )
{
printf(「%d\n」, BT->Data); //對節點做些訪問比如列印
PreOrderTraversal(BT->Left); //訪問左兒子
PreOrderTraversal(BT->Right); //訪問右兒子
}
}
由遞歸代碼可以看出，該遞歸為尾遞歸（尾遞歸即遞歸形式在函數末尾或者說在函數即將返回前）。尾遞歸的遞歸調用需要用棧存儲調用的信息，當數據規模較大時容易越出棧空間。雖然現在大部分的編譯器能夠自動去除尾遞歸，但是即使如此，我們不妨自己去除。非遞歸先序遍歷演算法基本思路：使用堆棧
a. 遇到一個節點，訪問它，然後把它壓棧，並去遍歷它的左子樹；
b. 當左子樹遍歷結束後，從棧頂彈出該節點並將其指向右兒子，繼續a步驟；
c. 當所有節點訪問完即最後訪問的樹節點為空且棧空時，停止。
實現代碼如下：
void PreOrderTraversal(BinTree BT)
{
BinTree T = BT;
Stack S = CreatStack(MAX_SIZE); //創建並初始化堆棧S
while(T || !IsEmpty(S))
{
while(T) //一直向左並將沿途節點訪問（列印）後壓入堆棧
{
printf("%d\n", T->Data);
Push(S, T);
T = T->Left;
}
if (!IsEmpty(S))
{
T = Pop(S); //節點彈出堆棧
T = T->Right; //轉向右子樹
}
}
}
由以上例子可以看出，遞歸與非遞歸的本質區別就是遞歸是不斷循環調用同一過程，非遞歸是循環執行同一個動作，並且非遞歸有入棧與出棧的過程，因此更節省存儲空間。個人淺見，歡迎指正。