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

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

阿新 • • 發佈：2019-04-15
hang oid aps 大寫轉小寫 small hat 數組 正式 das

　　一道天梯賽搞得全場人崩潰的題，幾乎現場就沒幾個人AC，現在回頭看看，真的很考細節耐心地題目。

-----------------------------題目-----------------------------

  1. 無論用戶說什麽，首先把對方說的話在一行中原樣打印出來；
  2. 消除原文中多余空格：把相鄰單詞間的多個空格換成 1 個空格，把行首尾的空格全部刪掉，把標點符號前面的空格刪掉；
  3. 把原文中所有大寫英文字母變成小寫，除了 I；
  4. 把原文中所有獨立的 I 和 me 換成 you；
  5. 把原文中所有的問號 ? 換成驚嘆號 !；
  6. 把原文中所有獨立的 can you 換成 I can —— 這裏“獨立”是指被空格或標點符號分隔開的單詞；
  7. 在一行中輸出替換後的句子作為 AI 的回答

輸入樣例:

6
Hello ?
 Good to chat   with you
can   you speak Chinese?
Really?
Could you show me 5
What Is this prime? I,don ‘t know

輸出樣例:

Hello ?
AI: hello!
 Good to chat   with you
AI: good to chat with you
can   you speak Chinese?
AI: I can speak chinese!
Really
 
?
AI: really!
Could you show me 5
AI: could you show you 5
What Is this prime? I,don ‘t know
AI: what Is this prime! you,don‘t know

-----------------------------題目-----------------------------

一、正式題解：

　　　　1* 函數原型聲明：

void deleteSymbolSpace();
void deleteSpace();
void bigToSmall();

 
void changePersonY();
void changePersonI();
void changeQ();
bool isIndenpend(char temp);

　　　　　　deleteSymbolSpace —— 刪除符號前的空格

　　　　　　deleteSpace —— 刪除多余空格

　　　　　　bigToSmall —— 將大寫轉小寫

　　　　　　changePersonY —— 改變人稱You

　　　　　　changePersonI —— 改變人稱I me

　　　　　　changeQ —— 問號改為感嘆號

　　　　　　isIndenpend —— 判斷是否獨立函數

　　　　2* 主函數框架構建：

int main()
{
    scanf("%d",&times);
    getchar();
    while(times--)
    {
        memset(temp,0,sizeof(temp));
        memset(tMark,0,sizeof(tMark));
        cin.getline(temp,1000);
        puts(temp);
        changeQ();
        bigToSmall();
        deleteSpace();
        changePersonY();
        changePersonI();
        deleteSpace();
        deleteSymbolSpace();
        printf("AI: ");
        puts(temp);
    }
    return 0;
}

　　　　　　拋開細節的實現方式，從大局角度思考程序的運行方式。

　　　　3*deleteSymbolSpace的實現：

void deleteSymbolSpace()
{
    memset(dealing,0,sizeof(dealing));
    count = 0;
    for(int i = 0;i<strlen(temp);i++)
    {
        if(temp[i] == 32)
        {
            int flag = 0;
            if(temp[i+1]>=33 && temp[i+1]<=47) flag = 1;
            else if(temp[i+1]>=58 && temp[i+1]<=64) flag = 1;
            else if(temp[i+1]>=91 && temp[i+1]<=96) flag = 1;
            else if(temp[i+1]>=123 && temp[i+1]<=126) flag = 1;
            
            if(flag == 1)
            {
                dealing[count] = temp[i+1];
                count++;
                i=i+1;
            }
            else
            {
                dealing[count] = temp[i];
                count++;
            }
        }
        else
        {
            dealing[count] = temp[i];
            count++;
        }
    }
    dealing[count] = ‘\0‘;
    memset(temp,0,sizeof(temp));
    strcpy(temp,dealing);
}

　　　　因為剛開始不知道判斷字母和數字的函數，所以幹脆直接簡單粗暴，ASCII掃獨立。

　　　　4* deleteSpace函數的實現：

void deleteSpace()
{
    int start = 0;
    int space = 0;
    memset(dealing,0,sizeof(dealing));
    count = 0;
    for(int i = 0;i<strlen(temp);i++)
    {
        if(start == 0 && temp[i] == 32) continue;
        else if(start == 0 && temp[i] != 32)
        {
            start = 1;
            dealing[count] = temp[i];
            count++;
            continue;
        }
        
        if(temp[i] == 32)
        {
            if(space == 1) continue;
            if(tMark[i] == 1) continue;
            space = 1;
            dealing[count] = 32;
            count++;
        }
        else
        {
            space = 0;
            dealing[count] = temp[i];
            count++;
        }
    }
    if(dealing[count-1] == 32) dealing[count-1] = ‘\0‘;
    else dealing[count] = ‘\0‘;
    memset(temp,0,sizeof(temp));
    strcpy(temp,dealing);
}

　　　　核心思路很簡單，就是拿一個新數組去存新的結果，通過打標記判斷是否是句頭空行。

　　　　5* bigToSmall函數的實現：

void bigToSmall()//實際上可以用tolower代替 
{
    for(int i = 0;i<strlen(temp);i++)
    {
        if( temp[i] >= 65 && temp[i] <= 90)
        {
            if(temp[i] == ‘I‘) continue;
            temp[i] = temp[i] + 32;
        }
    }
}

　　　　　　這裏也是因為不知道有tolower這個魔鬼函數，所以依舊簡單粗暴，暴力用ASCII解決問題。

　　　　6* changePersonY函數的實現：

void changePersonY()
{
    for(int i = 0;i<strlen(temp);i++)
    {
        int flag = -1;
        if(i != 0 && !isIndenpend(temp[i-1])) continue;
        if(temp[i] == ‘c‘ && temp[i+1] == ‘a‘ && temp[i+2] == ‘n‘) flag = 3;
        else if(temp[i] == ‘c‘ && temp[i+1] == ‘o‘ && temp[i+2] == ‘u‘ && temp[i+3] == ‘l‘ && temp[i+4] == ‘d‘) flag = 5;
        
        if(flag != -1)
        {
            int mark = 0;
            if(temp[i+flag]>=32 && temp[i+flag]<=47) mark = 1;
            else if(temp[i+flag]>=58 && temp[i+flag]<=64) mark = 1;
            else if(temp[i+flag]>=91 && temp[i+flag]<=96) mark = 1;
            else if(temp[i+flag]>=123 && temp[i+flag]<=126) mark = 1;
            if(mark == 1)
            {
                if(temp[i+flag+mark] == ‘y‘ && temp[i+flag+mark+1] == ‘o‘ && temp[i+flag+mark+2] == ‘u‘)
                {
                    if(temp[i+flag+mark+3] != ‘\0‘ && !isIndenpend(temp[i+flag+mark+3])) continue;
                    temp[i] = ‘I‘;
                    tMark[i] = 1;
                    temp[i+1] = temp[i+flag];
                    if(flag == 3)
                    {
                        temp[i+2] = ‘c‘;
                        temp[i+3] = ‘a‘;
                        temp[i+4] = ‘n‘;
                    }
                    else if(flag == 5)
                    {
                        temp[i+2] = ‘c‘;
                        temp[i+3] = ‘o‘;
                        temp[i+4] = ‘u‘;
                        temp[i+5] = ‘l‘;
                        temp[i+6] = ‘d‘;
                    }
                    
                    temp[i +flag+2] = ‘ ‘;
                    temp[i +flag+3] = ‘ ‘;
                    tMark[i +flag+2] = tMark[i +flag+3] = 1;
                    i = i +flag+3;
                }
            }
        }
    }
}

　　　　　轉換人稱是所有限制條件最麻煩最難的地方，需要註意打上標記，因為對string還是有點小反感，雖然挺好用，但是習慣用char進行單個強行處理，所以這裏一直是用char來處理的~

　　　　7* changePersonI函數的實現：

void changePersonI()
{
    memset(dealing,0,sizeof(dealing));
    count = 0;
    for(int i = 0;i<strlen(temp);i++)
    {
        if(temp[i] == ‘I‘ && isIndenpend(temp[i+1]) && tMark[i] == 0)
        {
            if(i != 0 && !isIndenpend(temp[i-1])) 
            {
                dealing[count] = temp[i];
                count++;
                continue;
            }
            dealing[count] = ‘y‘;
            dealing[count+1] = ‘o‘;
            dealing[count+2] = ‘u‘;
            count += 3;
        }
        else if(temp[i] == ‘m‘ && temp[i+1] == ‘e‘ && isIndenpend(temp[i+2]))
        {
            if(i != 0 && !isIndenpend(temp[i-1]))
            {
                dealing[count] = temp[i];
                count++;
                continue;
            }
            dealing[count] = ‘y‘;
            dealing[count+1] = ‘o‘;
            dealing[count+2] = ‘u‘;
            count += 3;
            i = i + 1;
        }
        else
        {
            dealing[count] = temp[i];
            count++;
        }
    }
    dealing[count] = ‘\0‘;
    memset(temp,0,sizeof(temp));
    strcpy(temp,dealing);
}

　　　　　　這裏尤其需要註意，不能把已經換過的人稱再換一次，所以需要對標記進行判斷。

　　　　8* changeQ的函數實現：

void changeQ()
{
    for(int i = 0;i<strlen(temp);i++)
        if(temp[i] == ‘?‘)
            temp[i] = ‘!‘;
}

　　　　　　盡管函數簡單，但盡量單獨列出，使程序更加結構化。

　　　　9* isIndenpend函數的實現：

bool isIndenpend(char temp)
{
    int mark = 0;
    if(temp>=32 && temp<=64) mark = 1;
    else if(temp>=91 && temp<=96) mark = 1;
    else if(temp>=123 && temp<=126) mark = 1;
    else if(temp == ‘\0‘) mark = 1;
    return mark;
}

　　　　　　暴力ASCII碼解決，雖然不是最佳的處理方式。

二、完整代碼展示：

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;

//------------------------
void deleteSymbolSpace();
void deleteSpace();
void bigToSmall();
void changePersonY();
void changePersonI();
void changeQ();
bool isIndenpend(char temp);
//------------------------

int times;
char dealing[1001];
int count;
char temp[1001];
int tMark[1001];
int main()
{
    scanf("%d",&times);
    getchar();
    while(times--)
    {
        memset(temp,0,sizeof(temp));
        memset(tMark,0,sizeof(tMark));
        cin.getline(temp,1000);
        puts(temp);
        changeQ();
        bigToSmall();
        deleteSpace();
        changePersonY();
        changePersonI();
        deleteSpace();
        deleteSymbolSpace();
        printf("AI: ");
        puts(temp);
    }
    return 0;
}

void deleteSymbolSpace()
{
    memset(dealing,0,sizeof(dealing));
    count = 0;
    for(int i = 0;i<strlen(temp);i++)
    {
        if(temp[i] == 32)
        {
            int flag = 0;
            if(temp[i+1]>=33 && temp[i+1]<=47) flag = 1;
            else if(temp[i+1]>=58 && temp[i+1]<=64) flag = 1;
            else if(temp[i+1]>=91 && temp[i+1]<=96) flag = 1;
            else if(temp[i+1]>=123 && temp[i+1]<=126) flag = 1;
            
            if(flag == 1)
            {
                dealing[count] = temp[i+1];
                count++;
                i=i+1;
            }
            else
            {
                dealing[count] = temp[i];
                count++;
            }
        }
        else
        {
            dealing[count] = temp[i];
            count++;
        }
    }
    dealing[count] = ‘\0‘;
    memset(temp,0,sizeof(temp));
    strcpy(temp,dealing);
}


void deleteSpace()
{
    int start = 0;
    int space = 0;
    memset(dealing,0,sizeof(dealing));
    count = 0;
    for(int i = 0;i<strlen(temp);i++)
    {
        if(start == 0 && temp[i] == 32) continue;
        else if(start == 0 && temp[i] != 32)
        {
            start = 1;
            dealing[count] = temp[i];
            count++;
            continue;
        }
        
        if(temp[i] == 32)
        {
            if(space == 1) continue;
            if(tMark[i] == 1) continue;
            space = 1;
            dealing[count] = 32;
            count++;
        }
        else
        {
            space = 0;
            dealing[count] = temp[i];
            count++;
        }
    }
    if(dealing[count-1] == 32) dealing[count-1] = ‘\0‘;
    else dealing[count] = ‘\0‘;
    memset(temp,0,sizeof(temp));
    strcpy(temp,dealing);
}

void bigToSmall()//實際上可以用tolower代替 
{
    for(int i = 0;i<strlen(temp);i++)
    {
        if( temp[i] >= 65 && temp[i] <= 90)
        {
            if(temp[i] == ‘I‘) continue;
            temp[i] = temp[i] + 32;
        }
    }
}

void changePersonY()
{
    for(int i = 0;i<strlen(temp);i++)
    {
        int flag = -1;
        if(i != 0 && !isIndenpend(temp[i-1])) continue;
        if(temp[i] == ‘c‘ && temp[i+1] == ‘a‘ && temp[i+2] == ‘n‘) flag = 3;
        else if(temp[i] == ‘c‘ && temp[i+1] == ‘o‘ && temp[i+2] == ‘u‘ && temp[i+3] == ‘l‘ && temp[i+4] == ‘d‘) flag = 5;
        
        if(flag != -1)
        {
            int mark = 0;
            if(temp[i+flag]>=32 && temp[i+flag]<=47) mark = 1;
            else if(temp[i+flag]>=58 && temp[i+flag]<=64) mark = 1;
            else if(temp[i+flag]>=91 && temp[i+flag]<=96) mark = 1;
            else if(temp[i+flag]>=123 && temp[i+flag]<=126) mark = 1;
            if(mark == 1)
            {
                if(temp[i+flag+mark] == ‘y‘ && temp[i+flag+mark+1] == ‘o‘ && temp[i+flag+mark+2] == ‘u‘)
                {
                    if(temp[i+flag+mark+3] != ‘\0‘ && !isIndenpend(temp[i+flag+mark+3])) continue;
                    temp[i] = ‘I‘;
                    tMark[i] = 1;
                    temp[i+1] = temp[i+flag];
                    if(flag == 3)
                    {
                        temp[i+2] = ‘c‘;
                        temp[i+3] = ‘a‘;
                        temp[i+4] = ‘n‘;
                    }
                    else if(flag == 5)
                    {
                        temp[i+2] = ‘c‘;
                        temp[i+3] = ‘o‘;
                        temp[i+4] = ‘u‘;
                        temp[i+5] = ‘l‘;
                        temp[i+6] = ‘d‘;
                    }
                    
                    temp[i +flag+2] = ‘ ‘;
                    temp[i +flag+3] = ‘ ‘;
                    tMark[i +flag+2] = tMark[i +flag+3] = 1;
                    i = i +flag+3;
                }
            }
        }
    }
}

void changePersonI()
{
    memset(dealing,0,sizeof(dealing));
    count = 0;
    for(int i = 0;i<strlen(temp);i++)
    {
        if(temp[i] == ‘I‘ && isIndenpend(temp[i+1]) && tMark[i] == 0)
        {
            if(i != 0 && !isIndenpend(temp[i-1])) 
            {
                dealing[count] = temp[i];
                count++;
                continue;
            }
            dealing[count] = ‘y‘;
            dealing[count+1] = ‘o‘;
            dealing[count+2] = ‘u‘;
            count += 3;
        }
        else if(temp[i] == ‘m‘ && temp[i+1] == ‘e‘ && isIndenpend(temp[i+2]))
        {
            if(i != 0 && !isIndenpend(temp[i-1]))
            {
                dealing[count] = temp[i];
                count++;
                continue;
            }
            dealing[count] = ‘y‘;
            dealing[count+1] = ‘o‘;
            dealing[count+2] = ‘u‘;
            count += 3;
            i = i + 1;
        }
        else
        {
            dealing[count] = temp[i];
            count++;
        }
    }
    dealing[count] = ‘\0‘;
    memset(temp,0,sizeof(temp));
    strcpy(temp,dealing);
}

void changeQ()
{
    for(int i = 0;i<strlen(temp);i++)
        if(temp[i] == ‘?‘)
            temp[i] = ‘!‘;
}

bool isIndenpend(char temp)
{
    int mark = 0;
    if(temp>=32 && temp<=64) mark = 1;
    else if(temp>=91 && temp<=96) mark = 1;
    else if(temp>=123 && temp<=126) mark = 1;
    else if(temp == ‘\0‘) mark = 1;
    return mark;
}

三、個人反思：

　　　　AI這道題還有待進一步優化和升級，還有一個bug沒有發現，還會繼續解決，重點想講的是程序設計的架構：

　　　　框架化的程序設計方法，是很早在Quanta冬令營中安卓JAVA的設計學習而得，由此類比過來的。我覺得，倘若要成為合格的程序設計師，出外工作的話，對框架的把握是非常重要的一個關卡，代碼是否結構化明顯，是否符合公司開發要求，是否易讀都是程序設計過程中非常關鍵的地方。在安卓中，有分層WEB層、底層、數據層、素材動畫層等等，選用合理的框架，能對團隊的程序設計帶來極大的效益，因此這個思想需要堅持並保留下來。

　　　　接下來的學習歷程吧：

　　　　=》學習十字鏈表以及線性樹、主席樹、區間更新等ACM問題，為5月12日的廣東省ACM省賽做準備

　　　　=》學習統計學習方法，掌握模型評估、決策樹、向量機等知識，為數據挖掘實驗室——多模態情感分析項目組努力。

　　　　=》前陣子七周都在英劇上花了不少時間，學習有些耽誤，後續時間將慢慢追回學業，保證學業狀態。

　　　　哦對了，順便附加ACM中的KMP模板吧，挺好用的，直接背下來用就好了~

技術分享圖片 
int KMP(char* str,char* pat)
{
    int i,j,k;
    memset(fail,-1,sizeof(fail));
    for(i = 1;pat[i];++i)
    {
        for(k = fail[i-1];k>=0 && pat[i] != pat[k+1];k = fail[k]);
        if(pat[k+1] == pat[i]) fail[i] = k + 1;
    }
    i = j = 0;
    while(str[i] && pat[j])
    {
        if(pat[j] == str[i]) ++i,++j;
        else if(j == 0) ++i;
        else j = fail[j-1] + 1;
    }
    if(pat[j]) return 0;
    else return i-j+1;
 }
View Code

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

相關推薦

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

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

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

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

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

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

數據結構第三章學習小結

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

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

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

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

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

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

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

Python培訓知識總結系列- 第二章Python數據結構第四部分-字典操作

... 哈希 int lis san 變量 ems python python字典 python字典鍵值對的添加和遍歷 添加鍵值對 首先定義一個空字典 dic={}1直接對字典中不存在的key進行賦值來添加 dic[‘name‘]=‘zhangsan‘dic{‘name‘:

數據結構——第三章樹和二叉樹：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 雙向循環鏈表 delet alt 分享 函數 ima truct cli ?註：未經博主同意，不得轉載。 　　鏈表是另一種形式的鏈式存儲結構，它是線性鏈表的一種變形。在線性鏈表中，每個結點的指針都指向它的下一個結點，最後一個結點的指針域為空，表示鏈表的結束。若使最後

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

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

數據結構第八篇——鏈棧

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

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

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

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

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

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

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