データ構造、アルゴリズム、およびリニアテーブルまとめたもので

データの構造

1、データ構造の概念

　　データ構造は、各セットの間の特定の関係の一個の以上のデータ要素の存在です。データ要素によって、データアイテムのデータ要素は、データ要素は、データの基本単位、データ項目は、データの最小単位です。

図2に示すように、論理構造

　　論理構造データは、線形構造、文字列のような線形テーブル、スタック、キュー、および含む線形および非線形構造の構成に分割され、非線形構造は、ツリー構造グラフィック接合含む構造等が挙げられます。

図3に示すように、ストレージ構造

　　順次記憶構造とチェーン記憶構造に構成データを格納します。順次記憶構造は、論理的に、このような隣接する配列のような物理的記憶部に隣接する記憶位置である;鎖メモリ構造は、間の論理ポインタボローデータで表すことができる論理的に接続されたノードに隣接する物理的な場所であることが要求されません関係。

4、アルゴリズム

　　五個の特徴（1）は有限のアルゴリズム、確実性、実現可能性、および出力を含みます。

　　（2）アルゴリズムに記載された方法は、自然言語から開始して、言語の擬似コードをプログラミングすることができます。どこで自然言語記述最強、それは複雑書き、プログラミング言語が、最悪の書き込みを簡単に読みやすさを、利点2の擬似コードの組み合わせの前に、より頻繁にコードの書き込み処理を行います。

　　時間の複雑さと空間複雑度のアルゴリズムの効率を分析する（3）アルゴリズム：このアルゴリズムの効率を測定する方法は、事後および事前の分析統計推定方法が挙げられます。

　　　　①時間複雑に：回数アルゴリズムを行う基本的な操作T（n）がT（N）= O（F（N））nと表される問題のサイズの関数です。多くの場合、オーダーO（log2n）の一定の順序O（1）、線形順序O（N）、オーダーはO（n ^ 2）の正方形を、表示され、時間複雑度を計算することは、最上位の唯一T（n）を取得無視されます問題のサイズnとして見ることができるため、低次の定数は、アルゴリズムの大きな時間効率です。

　　　　②スペースの複雑さ：ストレージスペースの動作の一時的占領中の測定アルゴリズム。

　　　　一般に、計算は、多くの場合、メリットのアルゴリズムアルゴリズム測定の空間的複雑さ、より豊富な空間です。

図5に示すように、データ型およびデータ構造。

　　抽象データ型（ADT）フレーム：

　　{データ型名

　　　　データオブジェクト。

　　　　データの関係;

　　　　基本的な操作;

　　}

第二に、線状

1、シーケンステーブル

#define MAXSIZE 50 
のtypedef int型Elemtype。
typedefは構造体{ 
    Elemtypeデータ[MAXSIZE]。
    int型の長さ。
} SqList。

特徴：①論理的に隣接する< - >隣接する物理アドレス、②ランダム・アクセス・メモリ（高速アクセス）。

長所：①フル（だけでなく、割り当てられたメモリへのポインタとしてリスト好きではない）と、比較的高い空間利用、②高速な読み出し速度、ストレージにランダムに優れ。

デメリット：①あなたがメモリ空間を割り当てたい場合はメモリ空間やスペースの不足の多くの結果がオーバフロー無駄にどのくらいになります事前に知っていない、②の挿入と削除操作が遅いです。

（1）インサート要素

BOOL InsertList（SqList *＆L、INT I、Elemtype E）
{ 
    場合（I < 1 || L->長さ+ 1 ）
         戻り 偽。
    I - ;
    用（INT J = L->長さ; J> I ; j-- ）
        L - >データ[J] = L->データ[J - 1 ]。
    L - >データ[I] = E。
    L - >長++ ;
    返す 真; 
}

時間複雑：O（L->の長さ）。

（2）削除要素

BOOL DeleteList（SqList *＆L、int型 I、Elemtype＆E）
{ 
    場合（iは< 1 || I->長さ+ 1 ）
         戻り 偽。
    I - ; 
    E = L-> データ[I]。
    用（INT J = I; J <L->長さ- 1 ; J ++ ）
        L - >データ[J] = L->データ[J + 1 ]。
    L - > length-- 。
    返す 真; 
}

時間複雑：O（L->の長さ）。

2、リスト

typedefは構造体lノード{ 
    Elemtypeデータ。
    構造体 lノード* 次の; 
} LINKLIST。

特徴：次メモリとの間の任意のストレージノードの接続のグループアドレスに格納されたリニアテーブルデータ要素を。

利点：①動的なメモリ割り当て、②削除、挿入操作をテーブルの要素の位置を移動させず。

短所：①順次アクセス・ストレージ要素の構造が比較的遅いと比較して、②次のノードへのポインタのためのスペースを割り当てる必要があります。

ノード構成：ポインタデータエレメント+;前記データ記憶ノードのデータ要素の値は、ノードの次ノードポインタ格納アドレス。

データ要素は、（1）テーブルで指定された場所を探します

bool GetElem(LinkList* L, int i, Elemtype& e)
{
    int j = 0;
    LinkList* p = L;
    while (j < i && p != NULL) {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else {
        e = p->data;
        return true;
    }
}

时间复杂度：O(L->length)

(2)插入元素

bool InsertList(LinkList*& L, int i, Elemtype e)
{
    int j = 0;
    LinkList* p = L;
    while (j < i - 1 && p != NULL) {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else {
        s = new LNode;
        s->data = e;
        s->next = p->next;
        p->next = s;
    }
}

时间复杂度：O(L->length)。

(3)删除元素

bool DeleteList(LinkList*& L, int i, Elemtype e)
{
    int j = 0;
    LinkList* p = L, * q;
    while (j < i - 1 && p != NULL) {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else {
        q = p->next;
        if (q == NULL)
            return false;
        e = q->data;
        p->next = q->next;
        delete p;
        return true;
    }
}

时间复杂度：O(L->length)。

(4)建单链表-头插法

void CreateListF(LinkList*& L, Elemtype a[], int n)
{
    LinkList* s;
    L = new LNode;
    L->next = NULL;
    for (int i = 0; i < n; i++) {
        s = new LNode;
        s->data = a[i];
        s->next = L->next;
        L->next = s;
    }
}

输出的结果与输入相反。

(5)建单链表-尾插法

void CreateListR(LinkList*& L, Elemtype a[], int n)
{
    LinkList* s, * r;
    L = new LNode;
    r = L;
    for (int i = 0; i < n; i++) {
        s = new LNode;
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}

输出的结果与输入相同。

3、双链表

typedef struct DNode {
    Elemtype data;
    struct DNode* prior;
    struct DNode* next;
}DLinkList;

(1)节点插入

s->next = p->next;
p->next = s;
s->next->prior = s;
s->prior = p;

(2)节点删除

q = p->next;
p->next = q->next;
q->next->prior = p;
delete q

4、有序表：其中所有元素以递增或递减的方式有序排列

(1)插入

//顺序表
void ListInsert(SqList*& L, Elemtype e)
{
    int i = 0, j;
    while (i < L->length && L->data[i] < e)
        i++;
    for (j = L->length; j > i; j--)
        L->data[j] = L->data[j - 1];
    L->data[i] = e;
    L->length++;
}

//链式表
void ListInsert(LinkList*& L, Elemtype e)
{
    LinkList* pre = L, * p;
    while (pre->next != NULL && pre->next->data < e)
        pre = pre->next;
    p = new LNode;
    p->data = e;
    p->next = pre->next;
    pre->next = p;
}

三、栈

1、栈

　　概念：栈是限制仅在线性表的一端进行插入与删除操作的线性表

　　特点：后进先出(LIFO)

2、顺序栈

#define Maxsize 100
typedef struct {
    Elemtype data[Maxsize];
    int top;
}SqStack;

(1)进栈

bool Push(SqStack*& s, ELemtype e)
{
    if (s->top == Maxsize - 1)
        return false;
    s->top++;
    s->data[s->top] = e;
    return true;
}

(2)出栈

bool Pop(SqStack*& s, Elemtype& e)
{
    if (s->top == -1)
        return false;
    e = s->data[s->top];
    s->top--;
    return true;
}

(3)取栈顶元素

bool GetTop(SqStack* s, Elemtype& e)
{
    if (s->top == -1)
        return false;
    e = s->data[s->top];
    return true;
}

3、链式栈

typedef struct linknode {
    Elemtype data;
    struct linknode* next;    
}LiStack;

(1)进栈

void Push(LiStack*& s, Elemtype e)
{
    LiStack* p;
    p = new LiStack;
    p->data = e;
    p->next = s->next;
    s->next = p;
}

(2)出栈

void Pop(LiStack*& s, Elemtype& e)
{
    LiStack* p;
    if (s->next == NULL)
        return false;
    p = s->next;
    e = p->data;
    s->next = p->next;
    delete p;
    return true;
}

(3)取栈顶元素

void GetTop(LiStack* s, Elemtype& e)
{
    if (s->next == NULL)
        return false;
    e = s->next->data;
    return true;
}

4、#include<stack>

stack

stack模板类的定义在<stack>头文件中。

stack模板类需要两个模板参数，一个是元素类型，一个容器类型，但只有元素类型是必要的，在不指定容器类型时，默认的容器类型为deque。

定义stack对象的示例代码如下：

stack<int> s1;
stack<string> s2;

stack的基本操作有：

入栈，如例：s1.push(x);

出栈，如例：s1.pop();注意，出栈操作只是删除栈顶元素，并不返回该元素。

访问栈顶，如例：s1.top()

判断栈空，如例：s1.empty()，当栈空时，返回true。

访问栈中的元素个数，如例：s1.size()

四、队列

1、队列

　　概念：只允许在表的一端(队尾)进行插入，而在表的另一端(队头)进行删除。

　　特点：先进先出(FIFO)。

2、顺序队列

#define MaxSize 100
typedef struct {
    Elemtype data[Maxsize];
    int front;
    int rear;
}SqQu

(1)入队

bool enQueue(SeCiQueue*& q, Elemtype e)
{
    if ((q->rear+1)%Maxsize==q->front)
        return false;
    q->rear = (q->rear + 1) % Maxsize;
    q->data[q->rear] = e;
    return true;
}

(2)出队

bool deQueue(SeciQueue*& q, Elemtype& e)
{
    if (QueueEmpty(q))
        return false;
    q->front = (q->front + 1) % Maxsize;
    e = q->data[q->front];
    return true;
}

3、链式队伍

typedef struct QNode {
    Elemtype data;
    struct QNode* next;
}QNode;

(1)入队

void enQueue(LiQueue*& q, Elemtype e)
{
    QNode* newNode = new QNode;
    newNode->data = e;
    newNode->next = NULL;
    if (QueueEmpty(q)) {
        q->rear = newNode;
        q->front = newNode;
    }
    else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

(2)出队

bool deQueue(LiQueue*& q, Elemtype& e)
{
    QNode* del;
    if (QueueEmpty(q))
        return false;
    del = q->front;
    if (q->front = q->rear)
        q = front = q->rear = NULL;
    else
        q->front = q->front->next;
    e = del->data;
    delete del;
    return true;
}

4、#include<queue>

queue

queue模板类的定义在<queue>头文件中。

与stack模板类很相似，queue模板类也需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque类型。

定义queue对象的示例代码如下：

queue<int> q1;
queue<double> q2;

queue的基本操作有：

入队，如例：q1.push(x); 将x接到队列的末端。
出队，如例：q1.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。
访问队首元素，如例：q1.front()，即最早被压入队列的元素。
访问队尾元素，如例：q1.back()，即最后被压入队列的元素。
判断队列空，如例：q1.empty()，当队列空时，返回true。
访问队列中的元素个数，如例：q1.size()

五、串

1、串

　　概念：由零个或多个字符组成的有限序列。

2、#include<string>

　　详情访帖：http://blog.sina.com.cn/s/blog_453a02280100r8tv.html

3、BF算法

1.在串S和串T中设置比较的起始下标i=0，j=0
2.重复下述操作，直到S或T的所有字符比较完毕
    ①如果S[i]=T[j]，则继续比较S和T的下一对字符
    ②否则，回溯下标i=i-j+1，j=0
3.如果T中所有字符比较完毕，则返回匹配的开始位置
    i-t.length(t为T字串)；否则返回-1
时间复杂度：O(n*m)

4、KMP算法

1.在串S和串T中，分别设置比较的起始下标，i=0，j=0
2.重复下述操作，直到S或T的所有字符均比较完毕
    ①如果S[i]等于T[j]，则继续比较S和T的下一对字符
    ②否则，将下标j回溯到next[j]位置，即j=next[j]
    ③如果j=-1，则将下标i和j分别加1，准备下一趟比较
3.如果T中所有字符均比较完毕，则返回本趟匹配的开始位置，否则返回-1

六、总结

1、在这次总结中，巩固了几种线性表的基本操作，对数据结构中结构部分有了更深的了解。

2、因为总结的时间没有把握好，写的仍不是很具体，有些操作还没有彻底理解。

3、在实际操作中仍不熟练，之后会加深代码的应用，增加熟练度。

データ構造、アルゴリズム、およびリニアテーブルまとめたもので

おすすめ