2. 程式人生 > >『嗨威說』數據結構 - 第五章學習內容小結

『嗨威說』數據結構 - 第五章學習內容小結

阿新 • • 發佈：2019-05-04
方法 you b樹 二叉 log microsoft 三種 back isp

本文主要內容：

　　一、樹的概念

　　二、樹的重中之重——二叉樹

　　三、樹的升級應用：哈夫曼樹

　　四、本節應用習題

　　五、個人反思與未來計劃

一、樹的基本概念：

　　　　（1）樹的定義：

　　　　　　　　樹（Tree）：n(n >= 0)個節點構成的有限集合。

        • 當n = 0時，稱為空樹；
        • 對任意一棵空樹(n > 0)，它具備以下性質：
        • 樹中有一個稱為**根(Root)**的特殊節點，用r(root)表示；
        • 其余節點可分為m(m > 0)個互不相交的有限集T1,T2,...Tm，其中每個集合本省又是一棵樹，稱為原來樹的子樹（SubTree）

　　　　　　　　註意：　　　①子樹不能相交

　　　　　　　　　　　　　　②除了根節點外，每個節點有且僅有一個父節點

　　　　　　　　　　　　　　③一個N個節點的樹有N-1條邊

　　　　（2）樹的基本術語：

        • 節點的度（Degree）：節點的子樹個數。
        • 樹的度：樹的所有節點中最大的度數（樹的度通常為節點個數的N-1）。
        • 葉節點（Leaf）：度為0的節點（也稱葉子節點）。
        • 父節點（Parent）：有子樹的節點是其子樹的父節點。
        • 子節點（Child）：若A節點是B節點的父節點，則稱B節點是A節點的子節點。
        • 兄弟節點（Sibling）：具有同一個父節點的各節點彼此是兄弟節點。
        • 路徑和路徑長度：從節點n1到nk的路徑為一個節點序列n1,n2,n3,...,nk，ni是ni+1的父節點。路徑所包含邊的個數為路徑長度。
        • 節點的層次（Level）：規定根節點在第0層，它的子節點是第1層，子節點的子節點是第2層，以此類推。
        • 樹的深度（Depth）：樹中所有節點中的最大層次是這棵樹的深度（因為上面是從第0層開始，深度 = 第最大層數 + 1）

技術分享圖片

　　　　

　　　　（3）樹的四種遍歷方式：

　　　　　　　　　　先序遍歷、中序遍歷、後序遍歷、層次遍歷。

　　　　　　　　　　前三種遍歷方式都是以根的遍歷先後為基準，層次遍歷就比較簡單了，按深度層次遍歷，不再贅述。先中後序遍歷做了一張圖，可以用下面這張圖來清晰解釋：

技術分享圖片

二、樹的重中之重——二叉樹：

　　（1）二叉樹的性質：

　　　　　　二叉樹的每個結點至多有二棵子樹(不存在度大於2的結點)，二叉樹的子樹有左右之分，次序不能顛倒。

　　　　　　① 在二叉樹的第K層上，最多有 2k-1 (K >= 1）個結點
　　　　　　② 深度為K的二叉樹，最多有 2k - 1 個結點（K>=1）
　　　　　　③ 對於任何一棵二叉樹，如果其葉子結點的個數為K，度為2的結點數為M,則K=M+1
　　　　　　④ 對於一棵有 n 個結點的完全二叉樹的結點按層次進行編號（如上圖，從第一層到第 （log 2n 向下取整），每層從左到右），對任意結點 i （1<i<n）,有：
　　　　　　　　→如果i=1，則結點i無父結點，是二叉樹的根，如果i>1,則父結點為 i/2 向下取整
　　　　　　　　→如果2i>n,則結點i為葉子結點，無左子結點，否則，其左子結點為2i
　　　　　　　　→如果2i+1>n，則結點i無右子結點，否則，其右子結點是結點2i+1

　　（2）二叉樹的存儲結構表示方法：

　　　　　　① 孩子表示法：用指針指出每個節點的孩子節點

　　　　　　　　#優點：尋找一個節點的孩子節點比較方便。

　　　　　　　　#缺點：尋找一個節點得雙親節點很不方便。

　　　　　　② 雙親表示法：用指針表示出每個節點的雙親節點

　　　　　　　　#優點：尋找一個節點得雙親節點操作實現很方便

　　　　　　　　#缺點：尋找一個節點的孩子節點很不方便

　　　　　　③ 孩子雙親表示法：用指針既表示出每個節點得雙親節點，也表示出每個節點的孩子節點

　　　　　　　　#優點：找某個節點的雙親節點和孩子節點非常方便

　　　　　　④ 孩子兄弟表示法：即表示出每個節點的第一個孩子節點，也表示出每個節點的下一個兄弟節點

　　　　　　　　#優點：找某個節點的兄弟結點節點和孩子節點非常方便

　　（3）二叉樹的基本建立與使用：

　　　　　　此處應用老師作業1的編程例題進行講解——List Leaves

　　　　　　題目：

技術分享圖片 
Given a tree, you are supposed to list all the leaves in the order of top down, and left to right.

Input Specification:
Each input file contains one test case. For each case, the first line gives a positive integer N (≤10) which is the total number of nodes in the tree -- and hence the nodes are numbered from 0 to N−1. Then N lines follow, each corresponds to a node, and gives the indices of the left and right children of the node. If the child does not exist, a "-" will be put at the position. Any pair of children are separated by a space.

Output Specification:
For each test case, print in one line all the leaves‘ indices in the order of top down, and left to right. There must be exactly one space between any adjacent numbers, and no extra space at the end of the line.

Sample Input:
8
1 -
- -
0 -
2 7
- -
- -
5 -
4 6
Sample Output:
4 1 5
7-1 List Leaves (30 分)題目

　　　　　　①首先：二叉樹的基本數據結構的建立

　　　　　　　　對於樹的建立，主要以打包結構體來實現，可打包加入左右孩子、數據data、編號等，這裏以最簡單的只保留左右孩子編號的結構體進行初涉講解。

struct BiTree{
    int l;
    int r;
};

　　　　　　②其次：建樹，找出根節點編號返回

int buildTree(BiTree tree[])
{
    //標記節點是否出現 
    bool number[MAX] = {false};
    
    //輸入節點數 
    int times;
    scanf("%d",&times);
    
    //存儲節點 
    for(int i = 0;i<times;i++)
    {
        char a,b;
        int Ta,Tb;
        getchar();
        scanf("%c %c",&a,&b);
        Ta = changeLegal(a);
        Tb = changeLegal(b);
         tree[i].l = Ta;
         tree[i].r = Tb;
         number[Ta] = true;
        number[Tb] = true;    
    }
    
    //搜索根節點 
    for(int i = 0;i<times;i++)
        if(number[i] == false)
            return i;
}

　　　　　　③對簡單二叉樹的應用：實現本題目的要求——找葉子節點

void findLeaves(BiTree tree[],int rt)
{
    //輸出空格標記 
    int mark = 0;
    
    //申請隊列並讓根節點入隊 
    queue<int> temp;
    temp.push(rt);
    
    //隊列循環 
    while(!temp.empty())
    {
        //輸出隊列出隊首個元素 
        int T = temp.front();
        temp.pop();
        
        //節點入隊 
        if(tree[T].l!=-1) temp.push(tree[T].l);
        if(tree[T].r!=-1) temp.push(tree[T].r);
        //如果搜到左右孩子都是空的，那就是葉子節點了 直接輸出即可 因為是層序遍歷 
        if(tree[T].l == -1 && tree[T].r == -1) 
        {
            if(mark == 0)
            {
                printf("%d",T);
                mark = 1;
            }
            else printf(" %d",T);
        }
    }
}

　　　　　　完整代碼展示：

技術分享圖片 
#include<stdio.h>
#include<queue> 
#define MAX 11
using namespace std;

//結構體樹節點建立 
struct BiTree{
    int l;
    int r;
};

//函數原型聲明 
int buildTree(BiTree tree[]);
void findLeaves(BiTree tree[],int rt);

int main()
{
    //建立基於數組的樹 
    BiTree tree[MAX];
    //存儲樹節點並識別根節點 
    int root = buildTree(tree);
    //搜索葉子節點並輸出 
    findLeaves(tree,root);
    return 0;
}

//轉換輸入的內容，將char類型轉為int 
int changeLegal(char x)
{
    if(x == ‘-‘) return -1;
    else return x - ‘0‘;
}

int buildTree(BiTree tree[])
{
    //標記節點是否出現 
    bool number[MAX] = {false};
    
    //輸入節點數 
    int times;
    scanf("%d",&times);
    
    //存儲節點 
    for(int i = 0;i<times;i++)
    {
        char a,b;
        int Ta,Tb;
        getchar();
        scanf("%c %c",&a,&b);
        Ta = changeLegal(a);
        Tb = changeLegal(b);
         tree[i].l = Ta;
         tree[i].r = Tb;
         number[Ta] = true;
        number[Tb] = true;    
    }
    
    //搜索根節點 
    for(int i = 0;i<times;i++)
        if(number[i] == false)
            return i;
}
 
void findLeaves(BiTree tree[],int rt)
{
    //輸出空格標記 
    int mark = 0;
    
    //申請隊列並讓根節點入隊 
    queue<int> temp;
    temp.push(rt);
    
    //隊列循環 
    while(!temp.empty())
    {
        //輸出隊列出隊首個元素 
        int T = temp.front();
        temp.pop();
        
        //節點入隊 
        if(tree[T].l!=-1) temp.push(tree[T].l);
        if(tree[T].r!=-1) temp.push(tree[T].r);
        //如果搜到左右孩子都是空的，那就是葉子節點了 直接輸出即可 因為是層序遍歷 
        if(tree[T].l == -1 && tree[T].r == -1) 
        {
            if(mark == 0)
            {
                printf("%d",T);
                mark = 1;
            }
            else printf(" %d",T);
        }
    }
}
本題作者答案寫法

三、樹的升級拓展之一：哈夫曼樹：

　　（1）定義：

　　　　　　哈夫曼樹，又稱最優樹，是一類帶權路徑長度最短的樹。首先有幾個概念需要清楚：

　　　　　　1、路徑和路徑長度

　　　　　　從樹中一個結點到另一個結點之間的分支構成兩個結點的路徑，路徑上的分支數目叫做路徑長度。樹的路徑長度是從樹根到每一個結點的路徑長度之和。

　　　　　　2、帶權路徑長度

　　　　　　結點的帶權路徑長度為從該結點到樹根之間的路徑長度與結點上權的乘積。樹的帶權路徑長度為樹中所有葉子結點的帶權路徑長度之和，通常記作WPL。

　　　　　　若有n個權值為w1,w2,...,wn的結點構成一棵有n個葉子結點的二叉樹，則樹的帶權路徑最小的二叉樹叫做哈夫曼樹或最優二叉樹。

技術分享圖片

　　　　　　在上圖中，3棵二叉樹都有4個葉子結點a、b、c、d，分別帶權7、5、2、4，則它們的帶權路徑長度為

　　　　　　（a）WPL = 7*2 + 5*2 + 2*2 + 4*2 = 36

　　　　　　（b）WPL = 4*2 + 7*3 + 5*3 + 2*1 = 46

　　　　　　（c）WPL = 7*1 + 5*2 + 2*3 + 4*3 = 35

　　　　　　其中（c）的WPL最小，可以驗證，（c）恰為哈夫曼樹。

　　（2）創建哈夫曼樹：

　　　　　　假設有n個結點，n個結點的權值分別為w1,w2,...,wn，構成的二叉樹的集合為F={T1,T2,...,Tn}，則可構造一棵含有n個葉子結點的哈夫曼樹。步驟如下：

　　　　　　（1）從F中選取兩棵根結點權值最小的樹作為左右子樹構造一棵新的二叉樹，其新的二叉樹的權值為其左右子樹根結點權值之和；

　　　　　　（2）從F中刪除上一步選取的兩棵二叉樹，將新構造的樹放到F中；

　　　　　　（3）重復（1）（2），直到F只含一棵樹為止。

　　　　　　技術分享圖片

　　（3）哈夫曼編碼：

　　　　　　我們約定左分支表示字符‘0‘，右分支表示字符‘1‘，在哈夫曼樹中從根結點開始，到葉子結點的路徑上分支字符組成的字符串為該葉子結點的哈夫曼編碼。上面代碼所創建的哈夫曼樹如下所示：

技術分享圖片

　　　　　　可以看出3被編碼為00，1為010，2為011,4為10,5為11。在這些編碼中，任何一個字符的編碼均不是另一個字符編碼的前綴。

　　　註：因本內容在本學期要求僅理解創建過程和哈夫曼編碼即可，故具體代碼實現暫未總結。

四、本章習題練習：

　　　　（1）深入虎穴：

技術分享圖片 
深入虎穴 (30 分)
著名的王牌間諜 007 需要執行一次任務，獲取敵方的機密情報。已知情報藏在一個地下迷宮裏，迷宮只有一個入口，裏面有很多條通路，每條路通向一扇門。每一扇門背後或者是一個房間，或者又有很多條路，同樣是每條路通向一扇門…… 他的手裏有一張表格，是其他間諜幫他收集到的情報，他們記下了每扇門的編號，以及這扇門背後的每一條通路所到達的門的編號。007 發現不存在兩條路通向同一扇門。

內線告訴他，情報就藏在迷宮的最深處。但是這個迷宮太大了，他需要你的幫助 —— 請編程幫他找出距離入口最遠的那扇門。

輸入格式：
輸入首先在一行中給出正整數 N（<10
?5
?? ），是門的數量。最後 N 行，第 i 行（1≤i≤N）按以下格式描述編號為 i 的那扇門背後能通向的門：

K D[1] D[2] ... D[K]
其中 K 是通道的數量，其後是每扇門的編號。

輸出格式：
在一行中輸出距離入口最遠的那扇門的編號。題目保證這樣的結果是唯一的。

輸入樣例：
13
3 2 3 4
2 5 6
1 7
1 8
1 9
0
2 11 10
1 13
0
0
1 12
0
0
輸出樣例：
12
深入虎穴-題目

　　　　　　　　簡單級難度，理清思路一個dfs就搞定了，關鍵部分：

void dfs(int rt,int step)
{
    if(step>step_max) {
        ans=rt;
        step_max=step;
    }
    for(int i=0;i<E[rt].size();++i){
        int to=E[rt][i];
        dfs(to,step+1);
    }    
}

　　　　　　　　完整代碼展示：幹凈整潔

#include <iostream>
#include <queue>
#include <stdio.h>
#include <vector>
using namespace std;
const int maxn = 1e5+10;
queue<int>q;
vector<int>E[maxn];
int N,to,ans=0,step_max=0;
void dfs(int rt,int step)
{
    if(step>step_max) {
        ans=rt;
        step_max=step;
    }
    for(int i=0;i<E[rt].size();++i){
        int to=E[rt][i];
        dfs(to,step+1);
    }    
}
int main()
{
    int step=1;
    scanf("%d",&N);
    for(int i=1;i<=N;++i){
        int num;
        scanf("%d",&num);
        while(num--)
        {
            scanf("%d",&to);
            E[i].push_back(to);
        }
    }
    dfs(1,1);
    printf("%d",ans);
    return 0;
}

　　（2）樹的同構：

技術分享圖片 
樹的同構 (30 分)
給定兩棵樹T1和T2。如果T1可以通過若幹次左右孩子互換就變成T2，則我們稱兩棵樹是“同構”的。例如圖1給出的兩棵樹就是同構的，因為我們把其中一棵樹的結點A、B、G的左右孩子互換後，就得到另外一棵樹。而圖2就不是同構的。
圖1
圖2
現給定兩棵樹，請你判斷它們是否是同構的。
輸入格式:
輸入給出2棵二叉樹樹的信息。對於每棵樹，首先在一行中給出一個非負整數N (≤10)，即該樹的結點數（此時假設結點從0到N−1編號）；隨後N行，第i行對應編號第i個結點，給出該結點中存儲的1個英文大寫字母、其左孩子結點的編號、右孩子結點的編號。如果孩子結點為空，則在相應位置上給出“-”。給出的數據間用一個空格分隔。註意：題目保證每個結點中存儲的字母是不同的。

輸出格式:
如果兩棵樹是同構的，輸出“Yes”，否則輸出“No”。

輸入樣例1（對應圖1）：
8
A 1 2
B 3 4
C 5 -
D - -
E 6 -
G 7 -
F - -
H - -
8
G - 4
B 7 6
F - -
A 5 1
H - -
C 0 -
D - -
E 2 -
輸出樣例1:
Yes
輸入樣例2（對應圖2）：
8
B 5 7
F - -
A 0 3
C 6 -
H - -
D - -
G 4 -
E 1 -
8
D 6 -
B 5 -
E - -
H - -
C 0 2
G - 3
F - -
A 1 4
輸出樣例2:
No
樹的同構 - 題目

　　　　　　本題的難度主要在於如何判斷兩個樹是否同構，一開始給自己挖坑了，想用叠代法去寫，結果發現越寫越復雜，後來換了一種騷遞歸的方法居然發現是如此的簡單，把握好老師說的：停留在本層的方法，一切就很容易了。

　　　　　　①首先：搜索到當前的節點沒有孩子，即自己是葉子，那他的兩個孩子一定是判為相等的，true返回

　　　　　　②其次：如果當前節點兩邊都有孩子，並且當前兩棵樹的孩子一樣，那麽就繼續往下搜，並且搜索有四種方向：

　　　　　　　　A樹左孩子與B樹左孩子、A樹左孩子與B樹右孩子、A樹右孩子與B樹左孩子、A樹右孩子與B樹右孩子

　　　　　　因此關鍵的判定函數就可以寫出來了：

//judge function
bool isEqual(Tree *a,int root_a,Tree *b,int root_b)
{
    if(root_a == -1 && root_b == -1)
        return true;
        
    if((root_a != -1 && root_b !=-1))
        if(a[root_a].name == b[root_b].name)
        {
            if(isEqual(a,a[root_a].lchild,b,b[root_b].lchild) && isEqual(a,a[root_a].rchild,b,b[root_b].rchild))
                return true;
            if(isEqual(a,a[root_a].lchild,b,b[root_b].rchild) && isEqual(a,a[root_a].rchild,b,b[root_b].lchild))
                return true;
        }
    return false;
}

　　　　　　完整代碼展示：（時刻提醒自己模塊化書寫）

#include<stdio.h>

//define Node
typedef struct{
    char name;
    int lchild;
    int rchild;
}Tree;

//define variable
int times1,times2;

//define function
int buildTree(Tree *&t,int node);
bool isEqual(Tree *a,int root_a,Tree *b,int root_b);

//MAIN
int main()
{
    //create Tree
    Tree *a,*b;
    
    //build Tree
    scanf("%d",&times1);
    int root_a = buildTree(a,times1);
    scanf("%d",&times2);
    int root_b = buildTree(b,times2);
    
    //find equal Tree
    if(isEqual(a,root_a,b,root_b)) printf("Yes");
    else printf("No");
    
    return 0;
}

//build Tree Function
int buildTree(Tree *&t,int node)
{
    t = new Tree[node];
    bool* mark = new bool[node];
    for(int i = 0;i<node;i++) mark[i] = false;
    for(int i = 0;i<node;i++)
    {
        //Warning!↓ 
        getchar();
        //Warning!↑
         
        char temp_n,temp_l,temp_r;
        scanf("%c %c %c",&temp_n,&temp_l,&temp_r);
        t[i].name = temp_n;
        if(temp_l != ‘-‘) 
        {
            t[i].lchild = temp_l - ‘0‘;
            mark[temp_l - ‘0‘] = true;
        }
        else t[i].lchild = -1;
        if(temp_r != ‘-‘) 
        {
            t[i].rchild = temp_r - ‘0‘;
            mark[temp_r - ‘0‘] = true;
        }
        else t[i].rchild = -1;
    }
    for(int i = 0;i<node;i++)
        if(mark[i] != true)
            return i;
    return -1;
}

//judge function
bool isEqual(Tree *a,int root_a,Tree *b,int root_b)
{
    if(root_a == -1 && root_b == -1)
        return true;
        
    if((root_a != -1 && root_b !=-1))
        if(a[root_a].name == b[root_b].name)
        {
            if(isEqual(a,a[root_a].lchild,b,b[root_b].lchild) && isEqual(a,a[root_a].rchild,b,b[root_b].rchild))
                return true;
            if(isEqual(a,a[root_a].lchild,b,b[root_b].rchild) && isEqual(a,a[root_a].rchild,b,b[root_b].lchild))
                return true;
        }
    return false;
}

五、個人反思及未來計劃：

　　　　（1）對樹和圖比較抽象的數據結構上基礎有些不牢，特別是碰到鏈式存儲的指針使用的時候，需要找時間給自己多加強這方面的學習。

　　　　（2）2019年5月12日即將參加CCPC廣東省ACM省賽，在此之前熟練學習『BFS』『DFS』『雙搜』『啟發式搜索』『A*』『叠代加深搜索』『IDA*』『回溯法』

　　　　（3）為樹蛙預備隊員轉型樹蛙正式成員準備復習高數以及Python　　　　

　　　　（4）完成論文標解『Improving patch-based scene text script identification with ensembles of conjoined networks』

『嗨威說』數據結構 - 第五章學習內容小結

相關推薦

『嗨威說』數據結構 - 第五章學習內容小結

方法 you b樹 二叉 log microsoft 三種 back isp 本文主要內容： 　　一、樹的概念 　　二、樹的重中之重——二叉樹 　　三、樹的升級應用：哈夫曼樹 　　四、本節應用習題 　　五、個人反思與未來計劃

『嗨威說』數據結構 - 第四章學習內容小結

hang oid aps 大寫轉小寫 small hat 數組 正式 das 　　一道天梯賽搞得全場人崩潰的題，幾乎現場就沒幾個人AC，現在回頭看看，真的很考細節耐心地題目。 -----------------------------題目-------

『嗨威說』資料結構 - 第六章學習內容小結

   本文主要內容：（與樹類似） 　　一、圖的概念 　　二、圖的重中之重——兩種重要儲存結構 　　三、樹的升級拓展應用：最小生成樹 　　四、本節應用習題 　　五、個人反思與未來計劃   一、圖的基本概念： 　　（1）圖的定義：

數據結構——第五章 樹與二叉樹

http alt 個數 一對多 技術分享 info 圖片 blog inf 樹是一對多的結構 結點：樹的小圓圈 度：結點有多少個分叉 葉子結點：結點的度為0 雙親：parent 孩子：child 二叉樹：樹的度不超過2 滿二叉樹：每一層都是滿的 完全二叉

數據結構第三章學習小結

不同的 結果 方法 == 網上 優點 感受 lin 運行 一、內容小結： 第三章學習了棧和隊列的有關知識，不僅學習了兩種結構的定義、表示方法，並且在實現的過程中，也感受到了結構的應用的不同之處。開始形成了一種學習數據結構的步驟思維，也就是在新定義一種數據數據結構時，我們首

『Python CoolBook』數據結構和算法_字典比較&字典和集合

pytho 轉換 amp 重復元素 註意 鍵值 相同 values 返回 一、字典元素排序 dict.keys()，dict.values()，dict.items() 結合max、min、sorted、zip進行排序是個很好的辦法，另外註意不使用zip時，字典的lamb

數據結構第五篇——線性表的鏈式存儲之循環鏈表

lan 雙向循環鏈表 delet alt 分享 函數 ima truct cli ?註：未經博主同意，不得轉載。 　　鏈表是另一種形式的鏈式存儲結構，它是線性鏈表的一種變形。在線性鏈表中，每個結點的指針都指向它的下一個結點，最後一個結點的指針域為空，表示鏈表的結束。若使最後

數據結構第五課筆記--------------狄泰軟件學院

學院 語句 軟件學院 軟件 嚴重 操作 循環 結構 筆記 算法的復雜度 時間復雜度：算法運行後對時間需求量的定性描述。空間復雜度：算法運行後對空間需求量的定性描述。本章重點討論時間復雜度符號定性——大O表示法：——算法效率嚴重依賴於操作（Operation）數量——操作數量

數據結構——第三章樹和二叉樹：01樹和二叉樹的類型定義

有序 存在 lin 深度 操作 root 判定樹 delet eem 1.樹的類型定義： （1）數據對象D：D是具有相同特性的數據元素的集合。 （2）數據關系R：若D為空集，則成為空樹 否則：在D中存在唯一的稱為根的數據元素root。當n>1時，其余結點可分為n(n&

數據結構 第5章 樹的二叉樹 單元小結（2）遍歷二叉樹和線索二叉樹

進行 深度 bsp iteration oid 基礎 二叉樹 線索 push 概念： 遍歷二叉樹： 遍歷：指按某條搜索路線遍訪每個結點且不重復（又稱周遊）。 遍歷的用途：它是樹結構插入、刪除、修改、查找和排序運算的前提，是二叉樹一切運算的基礎和核心。 時間效率: O

數據結構 第4章 串、數組和廣義表 單元小結（1）重點 BF算法

小結 廣義表 str 其中 算法 int 指針 重新開始 存在 BF算法 考試必考 ！！！！！背下來！！！！ int lndex_BF(string s,string t,int pos) {//返回模式t在主串s中第pos個字符開始第一次出現的位置下標 //若不存在

『嗨威說』數據結構 - 第二章學習內容小結

.com 循環鏈表 程序設計 單元 tar 自己 大牛 http 理由 　本文內容： 本章內容的小結 完成作業或實踐時解決困難的經驗分享 參考資料、說明推薦理由及列出相關鏈接(或書目名稱，具體頁碼) 目前學習過程中存在的困難，待解決或待改進的問題 接

數據結構-第10周作業（二叉樹的創建和遍歷算法）

樹的創建 創建 -1 數據結構 二叉 分享 com jpg 遍歷算法 數據結構-第10周作業（二叉樹的創建和遍歷算法）

數據結構第三篇——線性表的鏈式存儲之單鏈表

創建 int 超出 內容 存儲結構 cat com style 找到 　　線性表的鏈式存儲結構的特點是用一組任意的存儲單元來存儲線性表的數據元素，這些單元可以分散在內存中的任意位置上，其在物理上可以是連續的，也可以是不連續的。具有鏈式存儲結構的線性表稱為線性鏈表。 　　為了

數據結構第七篇——順序棧

lan pre .cn 是否為空 == class 部分 定義 blog ?註：未經博主同意，不得轉載。 　　棧（stack）是常用的重要數據結構，其應用十分廣泛。棧是一個操作受限的線性表，其插入和刪除操作都在表的同一端進行。 　　其中允許操作的一端稱為棧頂（top），另一

數據結構第八篇——鏈棧

val 條件 isempty pop 存儲 操作 部分 get sem ?註：未經博主同意，不得轉載。 鏈棧 鏈式存儲的棧稱為鏈棧。可用單鏈表來實現鏈棧，因此其節點結構與單鏈表的結構相同。下面給出這種結構的定義： 若要了解順序棧的內容請跳轉至http://www.cnb

數據結構第九篇——棧與遞歸

分解 是什麽 運行時 使用 執行過程 非遞歸算法 long 應該 char 棧還有一個重要應用是在程序設計中實現遞歸。遞歸是計算機 科學和數學中一種解決問題的及其重要的方法。在數據結構中，可以用它來設計簡單。易於理解的算法，特別是在一些具有遞歸定義的結構上設計算法。 遞歸的

數據結構第十一篇——鏈隊列

數據 需要 長度 logs cnblogs next color back 判斷 鏈式存儲的隊列稱為鏈隊列。和鏈棧類似，用單鏈表來實現鏈隊，根據隊列的FIFO原則，為了操作上的方便，分別需要一個頭指針和尾指針。隊頭在鏈頭，隊尾在鏈尾。鏈式隊列在進隊時無隊滿問題，但有隊空問題

數據結構第三課筆記----------------狄泰軟件學院

並且 之間 滿足 資源 strong 自己 有一個 算法 計算 程序的靈魂 引出問題程序是否越短越好？程序是不是別人讀不懂就證明自己很厲害？數據結構靜態的描述了數據元素之間的關系。高效的的程序需要在數據結構的基礎上選擇合適的算法。算法是特定問題求解的步驟，在計算機中表現為指

數據結構第四課筆記------------狄泰軟件學院

方法 策略 輸入 學院 部分 得出 測試數據 ret 功能性 程序的效率 問題：如果兩個算法都符合功能性需求，那工程中最關心的其他特性是什麽？如何比較評判？性價比（效率）是工程中最關註的的算法附加特性！算法效率的度量1.事後統計法：比較不同算法對同一組輸入數據的處理時間。缺