2. 程式人生 > >資料結構開發(14)：KMP 子串查詢演算法

資料結構開發(14)：KMP 子串查詢演算法

阿新 • • 發佈：2018-12-19

0.目錄

1.KMP 子串查詢演算法

2.KMP 演算法的應用

3.小結

1.KMP 子串查詢演算法

問題：
如何在目標字串S中，查詢是否存在子串P？

樸素解法：

樸素解法的一個優化線索：

示例：

偉大的發現：

  • 匹配失敗時的右移位數與子串本身相關，與目標串無關
  • 移動位數 = 已匹配的字元數 - 對應的部分匹配值
  • 任意子串都存在一個唯一的部分匹配表

部分匹配表示例：

問題：
部分匹配表是怎麼得到的？

  • 字首
    1. 除了最後一個字元以外，一個字串的全部頭部組合
  • 字尾
    1. 除了第一個字元以外，一個字串的全部尾部組合
  • 部分匹配值
    1. 字首和字尾最長共有元素的長度

示例：ABCDABD

問題：

  • 怎麼程式設計產生部分匹配表？

實現關鍵：

  • PMT[1] = 0 ( 下標為0的元素匹配值為0 )
  • 從 2 個字元開始遞推 ( 從下標為 1 的字元開始遞推 )
  • 假設 PMT[n] = PMT[n-1] + 1 ( 最長共有元素的長度 )
  • 當假設不成立，PMT[n] 在 PMT[n-1] 的基礎上減小

程式設計產生部分匹配表：
（ll代表longest length，即最長共有元素的長度。推導過程遵循下列原則：
(1). 當前欲求的ll值，通過歷史ll值推導。
(2). 當可選ll值為0時，直接比對首尾元素。
在求ababax的最後一項ll值時，
字首為aba b，
字尾為aba x。
重疊部分的長度就是當前的ll值，即：3；PMT(3)的含義是查詢3個字元時的ll值，而3個字元時的ll值對應著下標為2的情形；程式設計實現時注意長度與下標的對應關係。）

#include <iostream>
#include <cstring>

using namespace std;

int* make_pmt(const char* p)
{
    int len = strlen(p);
    int* ret = static_cast<int*>(malloc(sizeof(int) * len));

    if( ret != NULL )
    {
        int ll = 0;

        ret[0] = 0;

        for(int i=1; i<len; i++)
        {
            while( (ll > 0) && (p[ll] != p[i]) )
            {
                ll = ret[ll-1];
            }

            if( p[ll] == p[i] )
            {
                ll++;
            }

            ret[i] = ll;
        }
    }

    return ret;
}

int main()
{
    int* pmt_1 = make_pmt("ababax");

    cout << "ababax:" << endl;
    for(int i=0; i<strlen("ababax"); i++)
    {
        cout << i << " : " << pmt_1[i] << endl;
    }
    cout << endl;

    int* pmt_2 = make_pmt("ABCDABD");

    cout << "ABCDABD:" << endl;
    for(int i=0; i<strlen("ABCDABD"); i++)
    {
        cout << i << " : " << pmt_2[i] << endl;
    }

    return 0;
}

執行結果為：

ababax:
0 : 0
1 : 0
2 : 1
3 : 2
4 : 3
5 : 0

ABCDABD:
0 : 0
1 : 0
2 : 0
3 : 0
4 : 1
5 : 2
6 : 0

部分匹配表的使用 ( KMP 演算法 )：

實現KMP演算法：

#include <iostream>
#include <cstring>

using namespace std;

int* make_pmt(const char* p)
{
    int len = strlen(p);
    int* ret = static_cast<int*>(malloc(sizeof(int) * len));

    if( (ret != NULL) && (len > 0) )
    {
        int ll = 0;

        ret[0] = 0;

        for(int i=1; i<len; i++)
        {
            while( (ll > 0) && (p[ll] != p[i]) )
            {
                ll = ret[ll-1];
            }

            if( p[ll] == p[i] )
            {
                ll++;
            }

            ret[i] = ll;
        }
    }

    return ret;
}

int kmp(const char* s, const char* p)
{
    int ret = -1;
    int sl = strlen(s);
    int pl = strlen(p);
    int* pmt = make_pmt(p);

    if( (pmt != NULL) && (0 < pl) && (pl <= sl) )
    {
        for(int i=0, j=0; i<sl; i++)
        {
            while( (j > 0) && (s[i] != p[j]) )
            {
                j = pmt[j-1];
            }

            if( s[i] == p[j] )
            {
                j++;
            }

            if( j == pl )
            {
                ret = i + 1 - pl;
                break;
            }
        }
    }

    free(pmt);

    return ret;
}

int main()
{
    cout << kmp("abcde", "cde") << endl;
    cout << kmp("ababax", "ba") << endl;
    cout << kmp("ababax", "ax") << endl;
    cout << kmp("ababax", "") << endl;
    cout << kmp("ababax", "ababaxy") << endl;

    return 0;
}

執行結果為：

2
1
4
-1
-1

2.KMP 演算法的應用

思考：

  • 如何在目標字串中查詢是否存在指定的子串？

字串類中的新功能：

將kmp演算法的程式碼整合到自定義字串類中去：

protected:
    static int* make_pmt(const char* p);
    static int kmp(const char* s, const char* p);

具體實現：

int* String::make_pmt(const char* p)
{
    int len = strlen(p);
    int* ret = static_cast<int*>(malloc(sizeof(int) * len));

    if( (ret != NULL) && (len > 0) )
    {
        int ll = 0;

        ret[0] = 0;

        for(int i=1; i<len; i++)
        {
            while( (ll > 0) && (p[ll] != p[i]) )
            {
                ll = ret[ll-1];
            }

            if( p[ll] == p[i] )
            {
                ll++;
            }

            ret[i] = ll;
        }
    }

    return ret;
}

int String::kmp(const char* s, const char* p)
{
    int ret = -1;
    int sl = strlen(s);
    int pl = strlen(p);
    int* pmt = make_pmt(p);

    if( (pmt != NULL) && (0 < pl) && (pl <= sl) )
    {
        for(int i=0, j=0; i<sl; i++)
        {
            while( (j > 0) && (s[i] != p[j]) )
            {
                j = pmt[j-1];
            }

            if( s[i] == p[j] )
            {
                j++;
            }

            if( j == pl )
            {
                ret = i + 1 - pl;
                break;
            }
        }
    }

    free(pmt);

    return ret;
}

子串查詢 ( KMP 演算法的直接運用 )：

  • int indexOf(const char* s) const
  • int indexOf(const String& s) const

子串查詢：

public:
    int indexOf(const char* s) const;
    int indexOf(const String& s) const;

具體實現：

int String::indexOf(const char* s) const
{
    return kmp(m_str, s ? s : "");
}

int String::indexOf(const String& s) const
{
    return kmp(m_str, s.m_str);
}

在字串中將指定的子串刪除：

  • String& remove(const char* s)
  • String& remove(const String& s)

在字串中將指定的子串刪除：

public:
    String& remove(int i, int len);
    String& remove(const char* s);
    String& remove(const String& s);

具體實現：

String& String::remove(int i, int len)
{
    if( (0 <= i) && (i < m_length) )
    {
        int n = i;
        int m = i + len;

        while( (n < m) && (m < m_length) )
        {
            m_str[n++] = m_str[m++];
        }

        m_str[n] = '\0';
        m_length = n;
    }

    return *this;
}
String& String::remove(const char* s)
{
    return remove(indexOf(s), s ? strlen(s) : 0);
}

String& String::remove(const String& s)
{
    return remove(indexOf(s), s.length());
}

字串的減法操作定義 ( operator - )：

  • 使用 remove 實現字串間的減法操作
    1. 字串自身不被修改
    2. 返回產生的新串

字串的減法操作定義：

public:
    String operator - (const String& s) const;
    String operator - (const char* s) const;
    String& operator -= (const String& s);
    String& operator -= (const char* s);

具體實現：

String String::operator - (const String& s) const
{
    return String(*this).remove(s);
}

String String::operator - (const char* s) const
{
    return String(*this).remove(s);
}

String& String::operator -= (const String& s)
{
    return remove(s);
}

String& String::operator -= (const char* s)
{
    return remove(s);
}

字串中的子串替換：

  • String& replace(const char* t, const char* s)
  • String& replace(const String& t, const char* s)
  • String& replace(const char* t, const String& s)
  • String& replace(const String& t, const String& s)

字串中的子串替換：

public:
    String& replace(const char* t, const char* s);
    String& replace(const String& t, const char* s);
    String& replace(const char* t, const String& s);
    String& replace(const String& t, const String& s);

具體實現：

String& String::replace(const char* t, const char* s)
{
    int index = indexOf(t);

    if( index >= 0 )
    {
        remove(t);
        insert(index, s);
    }

    return *this;
}

String& String::replace(const String& t, const char* s)
{
    return replace(t.m_str, s);
}

String& String::replace(const char* t, const String& s)
{
    return replace(t, s.m_str);
}

String& String::replace(const String& t, const String& s)
{
    return replace(t.m_str, s.m_str);
}

從字串中建立子串：

  • String sub(int i, int len) const
    1. 以 i 為起點提取長度為 len 的子串
    2. 子串提取不會改變字串本身的狀態

從字串中建立子串：

public:
    String sub(int i, int len) const;

具體實現：

String String::sub(int i, int len) const
{
    String ret;

    if( (0 <= i) && (i < m_length) )
    {
        if( len < 0 ) len = 0;
        if( len + i > m_length ) len = m_length - i;
        char* str = reinterpret_cast<char*>(malloc(len + 1));

        strncpy(str, m_str + i, len);

        str[len] = '\0';

        ret = str;
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
    }

    return ret;
}

3.小結

  • 部分匹配表是提高子串查詢效率的關鍵
  • 部分匹配值定義為字首和字尾最長共有元素的長度
  • 可以用遞推的方法產生部分匹配表
  • KMP 利用部分匹配值與子串移動位數的關係提高查詢效率
  • 字串類是工程開發中必不可少的元件
  • 字串中應該包含常用字串操作函式
    1. 增 : insert , operator + , ...
    2. 刪 : remove , operator - , ...
    3. 查 : indexOf , ...
    4. 改 : replace , ...

最終的自定義字串類程式碼：
StString.h

#ifndef STSTRING_H
#define STSTRING_H

#include "Object.h"

namespace StLib
{

class String : public Object
{
protected:
    char* m_str;
    int m_length;

    void init(const char* s);
    bool equal(const char* l, const char* r, int len) const;

    static int* make_pmt(const char* p);
    static int kmp(const char* s, const char* p);
public:
    String();
    String(char c);
    String(const char* s);
    String(const String& s);

    int length() const;
    const char* str() const;
    bool startWith(const char* s) const;
    bool startWith(const String& s) const;
    bool endOf(const char* s) const;
    bool endOf(const String& s) const;
    String& insert(int i, const char* s);
    String& insert(int i, const String& s);
    String& trim();
    int indexOf(const char* s) const;
    int indexOf(const String& s) const;
    String& remove(int i, int len);
    String& remove(const char* s);
    String& remove(const String& s);
    String& replace(const char* t, const char* s);
    String& replace(const String& t, const char* s);
    String& replace(const char* t, const String& s);
    String& replace(const String& t, const String& s);
    String sub(int i, int len) const;

    char& operator [] (int i);
    char operator [] (int i) const;
    bool operator == (const String& s) const;
    bool operator == (const char* s) const;
    bool operator != (const String& s) const;
    bool operator != (const char* s) const;
    bool operator > (const String& s) const;
    bool operator > (const char* s) const;
    bool operator < (const String& s) const;
    bool operator < (const char* s) const;
    bool operator >= (const String& s) const;
    bool operator >= (const char* s) const;
    bool operator <= (const String& s) const;
    bool operator <= (const char* s) const;

    String operator + (const String& s) const;
    String operator + (const char* s) const;
    String& operator += (const String& s);
    String& operator += (const char* s);

    String operator - (const String& s) const;
    String operator - (const char* s) const;
    String& operator -= (const String& s);
    String& operator -= (const char* s);

    String& operator = (const String& s);
    String& operator = (const char* s);
    String& operator = (char c);

    ~String();
};

}

#endif // STSTRING_H

StString.cpp

#include <cstring>
#include <cstdlib>
#include "StString.h"
#include "Exception.h"

using namespace std;

namespace StLib
{

int* String::make_pmt(const char* p)
{
    int len = strlen(p);
    int* ret = static_cast<int*>(malloc(sizeof(int) * len));

    if( (ret != NULL) && (len > 0) )
    {
        int ll = 0;

        ret[0] = 0;

        for(int i=1; i<len; i++)
        {
            while( (ll > 0) && (p[ll] != p[i]) )
            {
                ll = ret[ll-1];
            }

            if( p[ll] == p[i] )
            {
                ll++;
            }

            ret[i] = ll;
        }
    }

    return ret;
}

int String::kmp(const char* s, const char* p)
{
    int ret = -1;
    int sl = strlen(s);
    int pl = strlen(p);
    int* pmt = make_pmt(p);

    if( (pmt != NULL) && (0 < pl) && (pl <= sl) )
    {
        for(int i=0, j=0; i<sl; i++)
        {
            while( (j > 0) && (s[i] != p[j]) )
            {
                j = pmt[j-1];
            }

            if( s[i] == p[j] )
            {
                j++;
            }

            if( j == pl )
            {
                ret = i + 1 - pl;
                break;
            }
        }
    }

    free(pmt);

    return ret;
}

void String::init(const char *s)
{
    m_str = strdup(s);

    if( m_str )
    {
        m_length = strlen(m_str);
    }
    else
    {
        THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create String object ...");
    }
}

String::String()
{
    init("");
}

String::String(char c)
{
    char s[] = {c, '\0'};

    init(s);
}

String::String(const char *s)
{
    init(s ? s : "");
}

String::String(const String &s)
{
    init(s.m_str);
}

int String::length() const
{
    return m_length;
}

const char* String::str() const
{
    return m_str;
}

bool String::equal(const char* l, const char* r, int len) const
{
    bool ret = true;

    for(int i=0; i<len && ret; i++)
    {
        ret = ret && (l[i] == r[i]);
    }

    return ret;
}

bool String::startWith(const char* s) const
{
    bool ret = (s != NULL);

    if( ret )
    {
        int len = strlen(s);

        ret = (len < m_length) && equal(m_str, s, len);
    }

    return ret;
}

bool String::startWith(const String& s) const
{
    return startWith(s.m_str);
}

bool String::endOf(const char* s) const
{
    bool ret = (s != NULL);

    if( ret )
    {
        int len = strlen(s);
        char* str = m_str + (m_length - len);

        ret = (len < m_length) && equal(str, s, len);
    }

    return ret;
}

bool String::endOf(const String& s) const
{
    return endOf(s.m_str);
}

String& String::insert(int i, const char* s)
{
    if( (0 <= i) && (i <= m_length) )
    {
        if( (s != NULL) && (s[0] != '\0') )
        {
            int len = strlen(s);
            char* str = reinterpret_cast<char*>(malloc(m_length + len + 1));

            if( str != NULL )
            {
                strncpy(str, m_str, i);
                strncpy(str + i, s, len);
                strncpy(str + i + len, m_str + i, m_length - i);

                str[m_length + len] = '\0';

                free(m_str);

                m_str = str;
                m_length = m_length + len;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert string value ...");
            }
        }
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
    }

    return *this;
}

String& String::insert(int i, const String& s)
{
    return insert(i, s.m_str);
}

String& String::trim()
{
    int b = 0;
    int e = m_length - 1;

    while( m_str[b] == ' ' ) b++;
    while( m_str[e] == ' ' ) e--;

    if( b == 0 )
    {
        m_str[e + 1] = '\0';

        m_length = e + 1;
    }
    else
    {
        for(int i=0, j=b; j<=e; i++, j++)
        {
            m_str[i] = m_str[j];
        }

        m_str[e - b + 1] = '\0';

        m_length = e - b + 1;
    }

    return *this;
}

int String::indexOf(const char* s) const
{
    return kmp(m_str, s ? s : "");
}

int String::indexOf(const String& s) const
{
    return kmp(m_str, s.m_str);
}

String& String::remove(int i, int len)
{
    if( (0 <= i) && (i < m_length) )
    {
        int n = i;
        int m = i + len;

        while( (n < m) && (m < m_length) )
        {
            m_str[n++] = m_str[m++];
        }

        m_str[n] = '\0';
        m_length = n;
    }

    return *this;
}

String& String::remove(const char* s)
{
    return remove(indexOf(s), s ? strlen(s) : 0);
}

String& String::remove(const String& s)
{
    return remove(indexOf(s), s.length());
}

String& String::replace(const char* t, const char* s)
{
    int index = indexOf(t);

    if( index >= 0 )
    {
        remove(t);
        insert(index, s);
    }

    return *this;
}

String& String::replace(const String& t, const char* s)
{
    return replace(t.m_str, s);
}

String& String::replace(const char* t, const String& s)
{
    return replace(t, s.m_str);
}

String& String::replace(const String& t, const String& s)
{
    return replace(t.m_str, s.m_str);
}

String String::sub(int i, int len) const
{
    String ret;

    if( (0 <= i) && (i < m_length) )
    {
        if( len < 0 ) len = 0;
        if( len + i > m_length ) len = m_length - i;
        char* str = reinterpret_cast<char*>(malloc(len + 1));

        strncpy(str, m_str + i, len);

        str[len] = '\0';

        ret = str;
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
    }

    return ret;
}

char& String::operator [] (int i)
{
    if( (0 <= i) && (i < m_length) )
    {
        return m_str[i];
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
    }
}

char String::operator [] (int i) const
{
    return (const_cast<String&>(*this))[i];
}

bool String::operator == (const String& s) const
{
    return (strcmp(m_str, s.m_str) == 0);
}

bool String::operator == (const char* s) const
{
    return (strcmp(m_str, s ? s : "") == 0);
}

bool String::operator != (const String& s) const
{
    return !(*this == s);
}

bool String::operator != (const char* s) const
{
    return !(*this == s);
}

bool String::operator > (const String& s) const
{
    return (strcmp(m_str, s.m_str) > 0);
}

bool String::operator > (const char* s) const
{
    return (strcmp(m_str, s ? s : "") > 0);
}

bool String::operator < (const String& s) const
{
    return (strcmp(m_str, s.m_str) < 0);
}

bool String::operator < (const char* s) const
{
    return (strcmp(m_str, s ? s : "") < 0);
}

bool String::operator >= (const String& s) const
{
    return (strcmp(m_str, s.m_str) >= 0);
}

bool String::operator >= (const char* s) const
{
    return (strcmp(m_str, s ? s : "") >= 0);
}

bool String::operator <= (const String& s) const
{
    return (strcmp(m_str, s.m_str) <= 0);
}

bool String::operator <= (const char* s) const
{
    return (strcmp(m_str, s ? s : "") <= 0);
}

String String::operator + (const String& s) const
{
    return (*this + s.m_str);
}

String String::operator + (const char* s) const
{
    String ret;
    int len = m_length + strlen(s ? s : "");
    char* str = reinterpret_cast<char*>(malloc(len + 1));

    if( str )
    {
        strcpy(str, m_str);
        strcat(str, s ? s : "");

        free(ret.m_str);

        ret.m_str = str;
        ret.m_length = len;
    }
    else
    {
        THROW_EXCEPTION(NoEnoughMemoryException, "No memory to add String values ...");
    }

    return ret;
}

String& String::operator += (const String& s)
{
    return (*this = *this + s.m_str);
}

String& String::operator += (const char* s)
{
    return (*this = *this + s);
}

String String::operator - (const String& s) const
{
    return String(*this).remove(s);
}

String String::operator - (const char* s) const
{
    return String(*this).remove(s);
}

String& String::operator -= (const String& s)
{
    return remove(s);
}

String& String::operator -= (const char* s)
{
    return remove(s);
}

String& String::operator = (const String& s)
{
    return (*this = s.m_str);
}

String& String::operator = (const char* s)
{
    if( m_str != s )
    {
        char* str = strdup(s ? s : "");

        if( str )
        {
            free(m_str);

            m_str = str;
            m_length = strlen(m_str);
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to assign new String value ...");
        }
    }

    return *this;
}

String& String::operator = (char c)
{
    char s[] = {c, '\0'};

    return (*this = s);
}

String::~String()
{
    free(m_str);
}

}

相關推薦

資料結構開發(14)：KMP 子串查詢演算法

0.目錄 1.KMP 子串查詢演算法 2.KMP 演算法的應用 3.小結 1.KMP 子串查詢演算法 問題： 如何在目標字串S中，查詢是否存在子串P？ 樸素解法： 樸素解法的一個優化線索： 示例： 偉大的發現： 匹配失敗時的右移位數與子串本身相關，與目標串無關 移動位數 =

資料結構 筆記：KMP子串查詢演算法

發現 -匹配失敗時的右移位數與子串本身相關，與目標串無關 -移動位數=已匹配的字元數-對應的部分匹配值 -任意子串都穿在一個唯一的部位匹配表 字首 -除了最後一個字元以外，一個字串的全部頭部組合 字尾 -出了第一個字元以外，一個字串的全部尾部組合 部分匹配值 -字

資料結構/最長非重複子串

給定一個字串,找字元中的最大非重複子串 基本方法、動態規劃、動態規劃+Hash 如下方法的時間複雜度O(n) list中儲存的是最終的輸出結果 public static int lengthOfLongestSubstring(String s) { if(s.length()==0){

資料結構開發(1)：學習前的準備（上）

0.目錄 1.泛型程式設計簡介 2.智慧指標示例 3.異常類構建 3.1 C++異常簡介 3.2 異常類構建 4.小結 參考前文傳送門： C++解析(26)：函式模板與類模板 C++解析(20)：智慧指標與型別轉換函式 C++解析(28)：異常處理 1.泛型程式設計簡介 資料結構

資料結構開發(8)：再論智慧指標

0.目錄 1.Pointer與SmartPointer 2.SharedPointer 3.小結 1.Pointer與SmartPointer 本節目標： 完成 Pointer 類的具體實現 完成 SmartPointer 類的具體實現 思考 使用智慧指標( SmartPo

資料結構開發(9)：迴圈連結串列與雙向連結串列

0.目錄 1.迴圈連結串列的實現 2.雙向連結串列的實現 3.小結 1.迴圈連結串列的實現 什麼是迴圈連結串列? 概念上 任意資料元素都有一個前驅和一個後繼 所有的資料元素的關係構成一個邏輯上的環 實現上 迴圈連結串列是一種特殊的單鏈表

資料結構開發(11)：雙向迴圈連結串列的實現

0.目錄 1.雙向迴圈連結串列的實現 2.小結 1.雙向迴圈連結串列的實現 本節目標： 使用 Linux 核心連結串列實現 StLib 中的雙向迴圈連結串列 template <typename T> class DualCircleList; StLib 中雙向迴圈

資料結構開發(15)：遞迴的思想與應用

0.目錄 1.遞迴的思想 2.遞迴的應用 2.1 單向連結串列的轉置 2.2 單向排序連結串列的合併 2.3 漢諾塔問題 2.4 全排列問題 2.5 逆序列印單鏈表中的偶數結點 2.6 八皇后問題 3.小結 1.遞迴的思想 遞迴是一種數學上分而自治的思想： 將

資料結構開發(16)：選擇排序和插入排序

0.目錄 1.排序的基本概念 2.選擇排序 3.插入排序 4.小結 1.排序的基本概念 排序的一般定義： 排序是計算機內經常進行的一種操作，其目的是將一組“無序”的資料元素調整為“有序”的資料元素。 排序的數學定義： 排序的示例： 問題： 按總評排序後為什麼張無忌

資料結構開發(21)：樹中屬性操作與層次遍歷

0.目錄 1.樹中屬性操作的實現 2.樹形結構的層次遍歷 3.小結 1.樹中屬性操作的實現 樹中結點的數目： 定義功能：count(node) 在 node 為根結點的樹中統計結點數目 樹結點數目的計算示例： count(A) = count(B)

資料結構開發(23)：二叉樹中結點的查詢、插入、刪除與清除操作

0.目錄 1.二叉樹中結點的查詢操作 2.二叉樹中結點的插入操作 3.二叉樹中結點的刪除操作 4.二叉樹中結點的清除操作 5.小結 1.二叉樹中結點的查詢操作 查詢的方式： 基於資料元素值的查詢 BTreeNode<T>* find(const T&

資料結構開發(24)：二叉樹中屬性操作、層次遍歷與典型遍歷

0.目錄 1.二叉樹中屬性操作的實現 2.二叉樹結構的層次遍歷 3.二叉樹的典型遍歷方式 4.小結 1.二叉樹中屬性操作的實現 二叉樹的屬性操作： 二叉樹中結點的數目： 定義功能：count(node) 在 node 為根結點的二叉樹中統計結點數目 在

資料結構開發(25)：二叉樹中屬性操作、層次遍歷與典型遍歷

0.目錄 1.二叉樹的比較與相加 2.二叉樹的線索化實現 3.二叉樹的經典面試題分析 3.1 單度結點刪除 3.2 中序線索化二叉樹 4.小結 1.二叉樹的比較與相加 二叉樹的克隆操作： SharedPointer< BTree<T> > clone

大話資料結構讀書筆記艾提拉總結 查詢演算法 和排序演算法比較好 第1章資料結構緒論 1 第2章演算法 17 第3章線性表 41 第4章棧與佇列 87 第5章串 123 第6章樹 149 第7章圖 21

大話資料結構讀書筆記艾提拉總結   查詢演算法 和排序演算法比較好     第1章資料結構緒論 1 第2章演算法 17 第3章線性表 41 第4章棧與佇列 87 第5章串 123 第6章樹 149 第7章圖 211

【資料結構】BST：二叉排序樹演算法

建立二叉排序樹，實現樹的插入、刪除，前、中、後序遍歷（遞迴方式）等操作。 /***************************************** Copyright (c) 2015 Jingshuang Hu @filename:dem

資料結構知識整理 - 基本概念 + 線性表查詢演算法

主要內容 基本概念 線性表的查詢 順序查詢（Sequential Search） 折半查詢（Binary Search） 分塊查詢（Blocking Search） 基本概念 在介紹查詢演算法前我們先重溫幾個重要概念： 1）資料：客觀事物的符號表示

2018百度之星：1002：子串查詢

依次 每一個 出現 font 一行 簡單 otto get ont 子串查詢 Submissions: 12650 Time Limit: 3500/3000 MS (Java/Others) Memory Limit: 262144/262144 K (Ja

玩轉資料結構——第二章：棧和佇列

內容概覽： 棧和棧的應用：撤銷操作和系統棧 棧的基本實現 棧的另外一個應用：括號匹配 關於Leetcode的更多說明 陣列佇列 迴圈佇列 迴圈佇列的實現 陣列佇列和迴圈佇列的比較 2-1.棧（Stack） 棧也是一種線性結構

資料結構實驗3：C++實現順序棧類與鏈棧類

                          

資料結構實驗4：C++實現迴圈佇列

實驗4 4.1 實驗目的 熟練掌握佇列的順序儲存結構和鏈式儲存結構。 熟練掌握佇列的有關演算法設計，並在迴圈順序佇列和鏈佇列上實現。 根據具體給定的需求，合理設計並實現相關結構和演算法。 4.2 實驗要求 4.2.1 迴圈順序佇列的實驗要求 迴圈順序佇列結構和運算定義，演算法的實現以庫檔案方式實