嚴蔚敏版總結

一.線性表

數組形式

#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef struct {
    ElemType *elem;
    int length;
    int listsize;
}SqList;

int InitList_Sq(SqList &L){
    L.elem = (ElemType *) malloc(LIST_INIT_SIZE * sizeof(ElemType));
    //初始化length和listsize;
    return 1;
}

鏈表形式

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

二.棧和隊列

1.順序棧

//定義
typedef struct{
    int data[maxSize];
    int top;
}SqStack;
//棧的狀態
//若top=-1為空，那么top=maxSize-1為棧滿。若top=0,類比。

//鏈棧定義
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode;

2.棧的應用

①數制轉換 ②括號匹配 ③行編輯程序 ④迷宮求解 ⑤表達式求值

3.循環隊列

typedef struct{
    int data[maxSize];
    int front;
    int rear;
}SqQueue;

//隊列狀態：空(qu.rear==qu.front)，滿(qu.rear+1)%maxSize==qu.front。
//顯然隊列在滿狀態時，必須空一個位置。

三.串

串定義

typedef struct{
    char str[maxSize+1];    //最后一個位置是'\0'
    int length;
}Str;

KMP算法

思想：利用已經部分匹配這個有效信息，保持i指針不回溯，通過修改j指針，讓模式串盡量地移動到有效的位置

算法：關鍵在于next[n+1]

public static int[] getNext(String ps) {
    char[] p = ps.toCharArray();
    int[] next = new int[p.length];
    next[0] = -1;
    int j = 0;
    int k = -1;
    while (j < p.length - 1) {
       if (k == -1 || p[j] == p[k]) {
           next[++j] = ++k;
       } else {
           k = next[k];
       }
    }
    return next;
}

四.數組和廣義表

01_稀疏矩陣.jpeg

五.樹

5.1 定義

typedef struct BTNode{
    char data;
    struct BTNode *lchild;
    struct BTNode *rchild;
}BTNode;

5.2 遍歷算法

//先序遍歷
void preOrder(BTNode *p){
    if(p!=null){
        visit(p);
        preOrder(p->lchild);
        preOrder(p->rchild);
    }
}

//中序，基本相同
//后序，基本相同

//層次遍歷
//利用循環列表，不斷將結點加入，然后訪問
void level(BTNode *p){
    int front,rear;
    BTNode *que[maxSize];
    front = rear;
    
    BTNode *q;
    if(p!=null){
        //根結點入隊
        rear=(rear+1)%maxSize;
        que[rear]=p;
        //當隊不空時
        while(front!=near){
            front=(front+1)%maxSize;
            q=que[front];
            visit(q);
            //加入左孩子
            if(q->lchild!=null){
                rear=(rear+1)%maxSize;
                que[rear]=q->lchild;
            }
            //同理，對于右孩子進行處理
        }
    }
}

5.3 樹的深度算法

int getDepth(BTNode *p){
    int LD,RD;
    if(p==null)
        return 0;
    else{
        LD = getDepth(p->lchild);
        RD = getDepth(p->rchild);
        return (LD>RD?LD:RD)+1;
    }
}

5.4 線索二叉樹

// 定義
typedef struct TBTNode{
    char data;
    int ltag,rtag;
    struct TBTNode *lchild;
    struct TBTNode *rchild;
}TBTNode;

//中序方式的線索二叉樹
void InThread(TBTNode *p,TBTNode *&pre){
    if(p!=null){
        InThread(p->lchild,pre);
        //建立當前結點的前驅線索
        if(p->lchild==null){
            p->lchild=pre;
            p->ltag=1;
        }
        //建立前驅結點和后驅結點
        if(pre!=null && pre->rchild==null){
            pre->rchild=p;
            pre->rtag=1;
        }
        //繼續遍歷
        pre=p;
        InThread(p->rchild,pre);
    }
}

六.圖

6.1 圖的鄰接表

//邊結構
typedef struct ArcNode{
    int adjvex;     //該邊指向的的結點位置
    struct ArcNode *nextarc;        //下一條邊的指針
    int info;       //可能的權值
}ArcNode;

//頂點信息
typedef struct VNode{
    char data;
    ArcNode *firstarc;      //該頂點第一條邊
}VNode;

//圖定義
typedef struct{
    VNode adjlist[maxSize];     //鄰接表
    int n,e;
}AGraph;

6.2 圖的遍歷

6.2.1 深度優先遍歷

類似二叉樹的先序遍歷

void DFS(AGraph *G,int v){      //v是起點編號
    ArcNode *p;
    visit[v]=1;     //設置訪問標記
    visit(v);
    p=G->adjlist[v].firstarc;   //該頂點的第一條邊
    while(p!=null){
        //如果邊的終點沒有被訪問
        if(visit[p->adjvex]==0)
            DFS(G,p->adjvex);
        p=p->nextarc;
    }
}

6.2.2廣度優先

類似層次遍歷算法

void BFS(AGraph *G,int v,int visit[maxSize]){
    //初始化v[n]為0
    ArcNode *p;
    int que[maxSize],front=0,rear=0;
    int j;
    Visit(v);
    visit[v]=1;
    rear=(rear+1)%maxSize;      //v進隊
    while(front!=rear){
        front=(front+1)%maxSize;        //頂點出隊
        j=que[front];
        p=G->adjlist[j].firstarc;       //取得邊
        while(p!){
            if(visit[p->adjvex]==0){
                Visit(p->adjvex);
                visit[p->adjvex]=1;
                rear=(rear+1)%maxSize;      //進隊
                que[rear]=p->adjvex;
            }
            p=p->nextarc;       //循環下一條邊
        }
    }
}

6.2.3非連通圖遍歷

通過循環每個頂點來實現遍歷。

void dfs/bfs(AGraph *g,int visit[]){
    int i;
    for(i=1;i<=g->n;++i){
        if(visit[i]==0)
            DFS/BFS(g,i);
    }
}

6.3 圖的最小生成樹

(針對點)普里姆算法n^2：任取一點，不斷找已選擇點集最小權值邊且終點為是未被選擇的點。

(針對邊)克魯斯卡爾算法O(eloge)

生成樹唯一的條件：權值相同的邊都被包括或每條邊權值不唯一

6.4 最短路徑

迪杰斯特拉算法O(n^2)

弗洛伊德算法O(n^3)：矩陣算法

6.5 拓撲排序和關鍵路徑

七.排序

八.查找樹