线性查找

顺序查找

减少一半比较次数
查找成功时，平均比较次数为(n+1)/2
查找不成功时，平均比较次数为n+1

折半查找

int SearchBin(int a[],int n,int key)
{
    int low=1,high=n;
    while(low<=high)
    {
        int mid=(low+high)/2;
        if(a[mid]==key)
            return mid;
        else if(a[mid]<key)
            low=mid-1;
        else
            high=mid+1;
    }
    return 0;
}

折半查找的递归实现

int SearchBin(int a[],int low,int high,int key)
{
    if(low <= high)
    {
        int mid=(low+high)/2;
        if(a[mid]==key)
            return mid;
        else if(a[mid]<key)
            return SearchBin(a,mid+1,high,key);
        else
            return SearchBin(a,low,mid-1,key);
    }
    else
    return 0;
}

查找成功时 $$ \mathrm{ASL_{bs}} = \frac{1}{n} \sum_{i=1}^{n} C_i = \frac{1}{n} \left[ \sum_{j=1}^{h} j \times 2^{j-1} \right] = \frac{n+1}{n} \log_2 (n+1) - 1 $$

在 $n>50$ 时，可得近似结果：

$$ \mathrm{ASL_{bs}} \approx \log_2 (n+1) - 1 $$

若查找不成功，则

$$ \mathrm{ASL} = h \approx \log_2 n + 1 $$

索引查找

一般情况下，将长度为 $n$ 的主表分成 $b$ 块，每块含有 $s$ 条记录，即 $b \approx n/s$，假设查找概率相等，则每块查找的概率为 $1/b$，块中每条记录查找的概率为 $1/s$。 若索引表采用顺序查找，则

$$ \mathrm{ASL} = \frac{b+1}{2} + \frac{s+1}{2} = \frac{\frac{n}{s} + s}{2} + 1 $$

若索引采用折半查找，则

$$ \mathrm{ASL} \approx \log_2 (b+1) + \frac{s+1}{2} = \log_2 \left(\frac{n}{s}+1\right) + \frac{s+1}{2} $$

树表查找

二叉排序树查找

特点：每个节点的值大于其左子树的所有节点的值，小于其右子树的所有节点的值。

#include <iostream>
using namespace std;

template <class T>
class BiNode {
public:
    T data;
    BiNode<T> *lch;
    BiNode<T> *rch;
    BiNode() : lch(NULL), rch(NULL) {}
};

template <class T>
class BST {
public:
    BST(T r[], int n);
    ~BST() {}
    BiNode<T> *Search(BiNode<T> *R, T key);
    void InsertBST(BiNode<T> *&R, BiNode<T> *s);
    void Delete(BiNode<T> *&R);
    bool DeleteBST(BiNode<T> *&R, T key);

private:
    BiNode<T> *Root;
};

template <class T>
BiNode<T> *BST<T>::Search(BiNode<T> *R, T key) {
    if (R == NULL)
        return NULL;
    if (key == R->data)
        return R;
    else if (key < R->data)
        return Search(R->lch, key);
    else
        return Search(R->rch, key);
}

template <class T>
void BST<T>::InsertBST(BiNode<T> *&R, BiNode<T> *s) {
    if (R == NULL)
        R = s;
    else if (s->data < R->data)
        InsertBST(R->lch, s);
    else
        InsertBST(R->rch, s);
}

template <class T>
BST<T>::BST(T r[], int n) {
    Root = NULL;
    for (int i = 0; i < n; i++) {
        BiNode<T> *s = new BiNode<T>;
        s->data = r[i];
        s->lch = s->rch = NULL;
        InsertBST(Root, s);
    }
}

template <class T>
bool BST<T>::DeleteBST(BiNode<T> *&R, T key) {
    if (R == NULL)
        return false;
    else {
        if (key == R->data) {
            Delete(R);
            return true;
        } else if (key < R->data)
            return DeleteBST(R->lch, key);
        else
            return DeleteBST(R->rch, key);
    }
}

template <class T>
void BST<T>::Delete(BiNode<T> *&R) {
    BiNode<T> *q, *s;
    if (R->lch == NULL) {
        q = R;
        R = R->rch;
        delete q;
    } else if (R->rch == NULL) {
        q = R;
        R = R->lch;
        delete q;
    } else {
        q = R;
        s = R->lch;
        while (s->rch != NULL) {
            q = s;
            s = s->rch;
        }
        R->data = s->data;
        if (q != R)
            q->rch = s->lch;
        else
            R->lch = s->lch;
        delete s;
    }
}
template <class T>
BST<T>::~BST() {
    while (Root != NULL)
        Delete(Root);
}

最好情况： $\log_2 (n+1)-1$
最坏情况： $(n+1)/2$

平衡二叉树查找

特点：任一节点的左、右子树的高度差不超过1，即平衡因子(左子树高度 - 右子树高度)的绝对值不超过1。 (1) LL 型 由于在结点 A 的左孩子的左子树上插入结点，使结点 A 的平衡因子由 1 增至 2 而失去平衡，需进行一次顺时针旋转操作

(2) RR 型 由于在结点 A 的右孩子的右子树上插入结点，使结点 A 的平衡因子由 $-1$ 减至 $-2$ 而失去平衡，需进行一次逆时针旋转操作，如图 6-17(b)所示。 (3) LR 型 由于在结点 A 的左孩子的右子树上插入结点，使结点 A 的平衡因子由 1 增至 2 而失去平衡，需进行两次旋转操作(先逆时针，后顺时针)，如图 6-17(c)所示。 (4) RL 型 由于在结点 A 的右孩子的左子树上插入结点，使结点 A 的平衡因子由 $-1$ 减至 $-2$ 而失去平衡，需进行两次旋转操作(先顺时针，后逆时针)，如图 6-17(d)所示。

B-树

有n个点，n(n-1)/2条边的图为完全无向图。
有n个点，n(n-1)条边的图为完全有向图。
简单路径：路径序列中，顶点不重复出现的路径。
简单回路：除了起点和终点外，其余顶点不重复出现。
连通图：在无向图中，若任意一对顶点都存在路径，则称其为连通图，否则为非连通图。
连通分量：无向图中的极大连通子图。极大连通子图包含所有连通的顶点以及和这些顶点相关联的所有边。
强连通图：在有向图中，若任意一对顶点都存在路径，则称其为强连通图，否则为非强连通图。
强连通分量：有向图中的极大强连通子图。极大强连通子图包含所有强连通的顶点以及和这些顶点相关联的所有边。
生成树：连通图的一个极小连通子图，包含图中所有顶点且有n-1条边。
生成森林：非连通图的极小连通子图，包含图中所有顶点且有n-k条边，k为连通分量个数。

#include<bits/stdc++.h>
using namespace std;
int n, m;
vector<bool> vis;
vector<vector<int>> adj;
bool find_edge(int u, int v)
{
    for (int i = 0; i < adj[u].size(); ++i)
    {
        if (adj[u][i] == v)
        {
            return true;
        }
    }
    return false;
}
void dfs(int u)
{
    if (vis[u])
        return;
    vis[u] = true;
    for (int i = 0; i < adj[u].size(); ++i)
        dfs(adj[u][i]);
}
void bfs(int u)//广度优先搜索
{
    vector<int> queue;
    int front = 0, rear = 0;
    queue.push_back(u);
    rear++;
    vis[u] = true;
    while (front < rear)
    {
        int v = queue[front];
        front++;
        for (int i = 0; i < adj[v].size(); ++i)
        {
            int w = adj[v][i];
            if (!vis[w])
            {
                queue.push_back(w);
                rear++;
                vis[w] = true;
            }
        }
    }
}
int main()
{
    cin >> n >> m;

    vis.resize(n + 1);
    adj.resize(n + 1);

    for (int i = 1; i <= m; ++i)
    {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
    }

    return 0;
}

//Prim算法
#include<bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int>> graph;
vector<bool> inMST;
vector<int> minEdge;
void Prim(int start)//时间复杂度：O(n^2)
{
    inMST[start] = true;
    for (int i = 1; i <= n; ++i)
    {
        minEdge[i] = graph[start][i];
    }
    for (int i = 1; i < n; ++i)
    {
        int u = -1;
        int minWeight = INT_MAX;
        for (int j = 1; j <= n; ++j)
        {
            if (!inMST[j] && minEdge[j] < minWeight)
            {
                minWeight = minEdge[j];
                u = j;
            }
        }
        if (u == -1)
            break; // 图不连通
        inMST[u] = true;
        for (int v = 1; v <= n; ++v)
        {
            if (!inMST[v] && graph[u][v] < minEdge[v])
            {   
                minEdge[v] = graph[u][v];
            }
        }
    }
}
//使用优先队列优化的prim算法
void Prim_Optimized(int start)//时间复杂度：O(m log n)
{
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    inMST[start] = true;
    for (int i = 1; i <= n; ++i)
    {
        if (graph[start][i] < INT_MAX)
            pq.push({graph[start][i], i});
    }
    while (!pq.empty())
    {
        auto [weight, u] = pq.top();
        pq.pop();
        if (inMST[u])
            continue;
        inMST[u] = true;
        for (int v = 1; v <= n; ++v)
        {
            if (!inMST[v] && graph[u][v] < INT_MAX)
            {
                pq.push({graph[u][v], v});
            }
        }
    }
}

//使用邻接表存储的prim算法
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct Edge
{
    int to;
    int weight;
};
vector<vector<Edge>> adj; // 邻接表，假设节点编号为 1..n

// 返回 MST 总权重，若图不连通则返回 -1；同时填 parent（父节点，root 的 parent = -1）
long long Prim_Simple(int start, vector<int> &parent)//时间复杂度：O(n^2)
{
    vector<bool> inMST(n + 1, false);
    vector<int> minEdge(n + 1, INT_MAX);
    parent.assign(n + 1, -1);

    minEdge[start] = 0;
    long long total = 0;
    for (int i = 1; i <= n; ++i)
    {
        int u = -1, best = INT_MAX;
        for (int v = 1; v <= n; ++v)
        {
            if (!inMST[v] && minEdge[v] < best)
            {
                best = minEdge[v];
                u = v;
            }
        }
        if (u == -1)
            return -1; // 不连通
        inMST[u] = true;
        total += (best == INT_MAX ? 0 : best);
        for (const auto &e : adj[u])
        {
            if (!inMST[e.to] && e.weight < minEdge[e.to])
            {
                minEdge[e.to] = e.weight;
                parent[e.to] = u;
            }
        }
    }
    return total;
}

// 使用优先队列的 Prim（更快），返回 MST 权重或 -1（不连通），并填 parent
long long Prim_Optimized(int start, vector<int> &parent)//时间复杂度：O(m log n)
{
    vector<bool> inMST(n + 1, false);
    vector<int> minEdge(n + 1, INT_MAX);
    parent.assign(n + 1, -1);

    using P = pair<int, int>; // {weight, node}
    priority_queue<P, vector<P>, greater<P>> pq;

    minEdge[start] = 0;
    pq.push({0, start});
    long long total = 0;
    int cnt = 0;

    while (!pq.empty())
    {
        auto [w, u] = pq.top();
        pq.pop();
        if (inMST[u])
            continue;
        inMST[u] = true;
        total += w;
        ++cnt;
        for (const auto &e : adj[u])
        {
            if (!inMST[e.to] && e.weight < minEdge[e.to])
            {
                minEdge[e.to] = e.weight;
                parent[e.to] = u;
                pq.push({e.weight, e.to});
            }
        }
    }
    if (cnt != n)
        return -1; // 不连通
    return total;
}

//Kruskal算法，时间复杂度：O(m log m)
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN = 100; // 假设最大节点数为 100
const int INF = 1e9;  // 用于表示无穷大
int n;                // 节点数
int graph[MAXN][MAXN]; // 邻接矩阵表示图
struct Edge {
    int u, v, weight;
    bool operator<(const Edge &other) const {
        return weight < other.weight;
    }
};
vector<Edge> edges; // 边列表
int parent[MAXN];  // 并查集父节点数组
int find(int x) {
    if (parent[x] != x) {
        parent[x] = find(parent[x]); // 路径压缩
    }
    return parent[x];
}
void unionSets(int x, int y) {
    int rootX = find(x);
    int rootY = find(y);
    if (rootX != rootY) {
        parent[rootY] = rootX; // 合并集合
    }
}
long long Kruskal() {
    // 初始化并查集
    for (int i = 0; i < n; i++) {
        parent[i] = i;
    }
    // 按权重排序边
    sort(edges.begin(), edges.end());
    long long mstWeight = 0;
    int edgesUsed = 0;  // 记录已使用的边数
    for (const auto &edge : edges) {
        if (find(edge.u) != find(edge.v)) {
            unionSets(edge.u, edge.v);
            mstWeight += edge.weight;
            edgesUsed++;
            if (edgesUsed == n - 1) break; // 提前结束
        }
    }
    // 检查是否所有节点都连通
    if (edgesUsed != n - 1) return -1; // 图不连通
    return mstWeight;
}

#define MAX_EDGE 100
#define MAX_VERTEX 100
#define MAX 9999

struct VEdge {
    int fromV;  // 起始顶点
    int endV;    // 终止顶点
    int weight; // 边的权值
};

VEdge EdgeList[MAX_EDGE];
void GenSortEdge(MGraph G, VEdge EdgeList[]) {
    int k = 0, i, j;
    for (i = 0; i < G.vNum; i++) { // 边赋值
        for (j = i; j < G.vNum; j++) {
            if (G.arcs[i][j] != MAX) {
                EdgeList[k].fromV = i;
                EdgeList[k].endV = j;
                EdgeList[k].weight = G.arcs[i][j];
                k++;
            }
        }
    }
    for (i = 0; i < G.e - 1; i++) { // 边排序，这里用起泡排序，可以用其他排序方法替代
        for (j = i + 1; j < G.e; j++) {
            if (EdgeList[i].weight > EdgeList[j].weight) {
                VEdge t = EdgeList[i];
                EdgeList[i] = EdgeList[j];
                EdgeList[j] = t;
            }
        }
    }
}
void Kruskal(VEdge EdgeList[], int n, int e) {
    int vset[MAX_VERTEX];
    int i;
    for (i = 0; i < n; i++) {
        vset[i] = i; // 初始化vset
    }
    int k = 0, j = 0;
    while (k < n - 1) {
        int m = EdgeList[j].fromV, n_edge = EdgeList[j].endV;
        int sn1 = vset[m]; // m所属集合
        int sn2 = vset[n_edge]; // n所属集合
        if (sn1 != sn2) { // 两个顶点属于不同的集合
            printf("V%d -> V%d\n", m, n_edge);
            k++;
            for (i = 0; i < n; i++) {
                if (vset[i] == sn2) { // 集合编号为sn2的全部改为sn1
                    vset[i] = sn1;
                }
            }
        }
        j++;
    }
}

#include <bits/stdc++.h>
using namespace std;
const int MAXV = 100;
const int MAX_VALUE = INT_MAX / 4;
int i, j, k;
int dist[MAXV][MAXV];
string path[MAXV][MAXV];
struct MGraph {
    int vNum;
    string vertex[MAXV];
    int arc[MAXV][MAXV];
};

void Floyd(MGraph G)
{
    for (i = 0; i < G.vNum; i++)
        for (j = 0; j < G.vNum; j++)
        {
            dist[i][j] = G.arc[i][j];
            if (dist[i][j] != MAX_VALUE)
                path[i][j] = G.vertex[i] + G.vertex[j];
            else
                path[i][j] = "";
        }
    for (k = 0; k < G.vNum; k++)
        for (i = 0; i < G.vNum; i++)
            for (j = 0; j < G.vNum; j++)
                if (dist[i][k] + dist[k][j] < dist[i][j])
                {
                    dist[i][j] = dist[i][k] + dist[k][j];
                    path[i][j] = path[i][k] + path[k][j];
                }
}

dijkstra算法：单源最短路径

#include <bits/stdc++.h>
using namespace std;
#define MAX_VERTEX 100
#define MAX 65535

typedef struct
{
    int arcs[MAX_VERTEX][MAX_VERTEX];
    int vNum;
} MGraph;

int FindMin(int Disk[], bool S[], int n)
{
    int k = 0, min = MAX;
    for (int i = 0; i < n; i++)
    {
        if (!S[i] && min > Disk[i])
        {
            min = Disk[i];
            k = i;
        }
    }
    if (min == MAX)
        return -1;
    return k;
}

void Print(int D[], int P[], int n)
{
    for (int i = 0; i < n; i++)
    {
        cout << "V" << i << ": " << D[i] << "\tV" << i;
        int pre = P[i];
        while (pre != -1)
        {
            cout << "<-V" << pre;
            pre = P[pre];
        }
        cout << endl;
    }
}

void ShortPath(MGraph G, int v, int Disk[], int Path[])
{
    bool S[MAX_VERTEX];
    for (int i = 0; i < G.vNum; i++)
    {
        S[i] = false;
        Disk[i] = G.arcs[v][i];
        if (Disk[i] != MAX)
            Path[i] = v;
        else
            Path[i] = -1;
    }
    S[v] = true;
    Disk[v] = 0;
    for (int i = 0; i < G.vNum; i++)
    {
        if ((v = FindMin(Disk, S, G.vNum)) == -1)
            return;
        S[v] = true;
        for (int j = 0; j < G.vNum; j++)
        {
            if (!S[j] && (Disk[j] > G.arcs[v][j] + Disk[v]))
            {
                Disk[j] = G.arcs[v][j] + Disk[v];
                Path[j] = v;
            }
        }
    }
    Print(Disk, Path, G.vNum);
}

void ShortPath_Optimized(MGraph G, int v, int Disk[], int Path[]){
    bool S[MAX_VERTEX];
    for(int i = 0;i < G.vNum;i++){
        S[i] = false;
        Disk[i] = G.arcs[v][i];
        if(Disk[i] != MAX)
        Path[i] = v;
        else
        Path[i] = -1;
    }
    S[v] = true;
    Disk[v] = 0;
    priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;
    for(int i = 0;i < G.vNum;i++){
        pq.push({Disk[i],i});
    }
    while(!pq.empty()){
        auto p = pq.top();
        pq.pop();
        int u = p.second;
        if(S[u]) continue;
        S[u] = true;
        for(int j = 0;j < G.vNum;j++){
            if(!S[j] && (Disk[j] > G.arcs[u][j] + Disk[u])){
                Disk[j] = G.arcs[u][j] + Disk[u];
                Path[j] = u;
                pq.push({Disk[j],j});
            }
        }
    }
    Print(Disk,Path,G.vNum);
}

二叉树

二叉树可以结点为0，但是树的结点最少为1
完全二叉树：倒数第二层是满的，且最后一层必须左对齐

二叉树性质

性质 1： 一棵非空二叉树的第 $i$ 层上至多有 $2^{i - 1}$ 个结点（$i \geq 1$）。

性质 2： 深度为 $h$ 的二叉树至多有 $2^h - 1$ 个结点（其中 $h \geq 1$）。

性质 3： 对于任何一棵二叉树 $T$，如果其终端结点数（叶子结点数）为 $n_0$，度为 2 的结点数为 $n_2$，则 $n_0 = n_2 + 1$。

性质 4： 具有 $n$ 个结点的完全二叉树的深度为 $\lfloor \log_2 n \rfloor + 1$（其中 $\lfloor x \rfloor$ 表示不大于 $x$ 的最大整数）。

性质 5： 对于具有 $n$ 个结点的完全二叉树，如果按照从上到下、同一层次上的结点按从左到右的顺序对二叉树中的所有结点从 1 开始顺序编号，则对于序号为 $i$ 的结点，有：

1. 双亲结点： 如果 $i > 1$，则序号为 $i$ 的结点的双亲结点的序号为 $\lfloor i/2 \rfloor$（$\lfloor i/2 \rfloor$ 表示对 $i/2$ 的值取整）。如果 $i = 1$，则结点 $i$ 为根结点，没有双亲。
2. 左孩子结点： 如果 $2i > n$，则结点 $i$ 无左孩子（此时结点 $i$ 为终端结点）；否则其左孩子结点的序号为 $2i$。
3. 右孩子结点： 如果 $2i + 1 > n$，则结点 $i$ 无右孩子；否则其右孩子结点的序号为 $2i + 1$。

树的遍历

前序遍历、后序遍历、层序遍历

二叉树的遍历

前中后三种遍历，两种遍历方式(一定要包含中序遍历)才能确定唯一二叉树

森林的遍历

前序遍历和后序遍历
① 前序遍历森林 ≡ 前序遍历该森林转换为的二叉树；
② 后序遍历森林 ≡ 中序遍历该森林转换为的二叉树；
③ 前序遍历树 ≡ 前序遍历该树对应的二叉树；
④ 后序遍历树 ≡ 中序遍历该树对应的二叉树。

树、森林与二叉树的转换

树转化为二叉树

1、将树的各兄弟结点连线
2、每个结点仅保留于其长子的连线，去掉该结点与其他子结点的连线

森林转化为二叉树

先把每个树转化为二叉树然后再把每个树的根结点连线作为兄弟节点

二叉树转换为树、森林

如果一个节点 x 是它双亲 y 的左孩子，那就要把 x 的右孩子、x 右孩子的右孩子这些，都直接和 y 连起来。连好之后，把所有双亲到右孩子的连线都去掉

顺序栈

const int StackSize = 1024;
template<class T>
class SeqStack
{
    public:
        SeqStack(){top = -1;}
        void Push(T x);
        T Pop();
        T GetTop();
        bool Empty(){return top == -1};
    private:
        int top;
        T data[StackSize];
};
template<class T>
void SeqStack<T>::Push(T x){
    if(top >= StackSize - 1)
    throw"溢出";
    data[++top] = x;
}
template <class T>
T SeqStack<T>::GetTop()
{
    if(Empty())
    throw"溢出";
    return data[top];
}
template <class T>
T SeqStack<T>::Pop(){
    if(Empty())
    throw"溢出";
    return data[top--];
}

共享双栈

栈满 ：top1 +1 == top2

#include <iostream>
using namespace std;

template <class T, int N = 1024>
class TwoStack
{
public:
    TwoStack() : top1(-1), top2(N) {}

    // 第一个栈（左侧）
    void Push1(const T &x)
    {
        if (top1 + 1 == top2)
            throw "栈满";
        data[++top1] = x;
    }
    T Pop1()
    {
        if (Empty1())
            throw "栈1为空";
        return data[top1--];
    }
    T Top1() const
    {
        if (Empty1())
            throw "栈1为空";
        return data[top1];
    }
    bool Empty1() const { return top1 == -1; }
    int Size1() const { return top1 + 1; }

    // 第二个栈（右侧）
    void Push2(const T &x)
    {
        if (top1 + 1 == top2)
            throw "栈满";
        data[--top2] = x;
    }
    T Pop2()
    {
        if (Empty2())
            throw "栈2为空";
        return data[top2++];
    }
    T Top2() const
    {
        if (Empty2())
            throw "栈2为空";
        return data[top2];
    }
    bool Empty2() const { return top2 == N; }
    int Size2() const { return N - top2; }

    // 剩余可用空间
    int FreeSpace() const { return top2 - top1 - 1; }

private:
    T data[N];
    int top1; // 初始 -1，向右增长
    int top2; // 初始 N，向左增长
};

链式栈

template<class T>
struct Node
{
    T data;
    Node<T> *next;
};
template <class T>
class LinkStack
{
private:
    Node<T> *top;
public:
    LinkStack(){top = NULL;}
    ~LinkStack();
    void push(T x);
    T pop();
    T GetTop();
    bool Empty(){return top == nullptr;}

};

template <class T>
LinkStack<T>::~LinkStack()
{
    while(top){
        Node<T> *p = top;
        top = top->next;
        delete p;
    }
}
template<class T>
void LinkStack<T>::push(T x){
    Node<T> *now = new Node<T>;
    now->data = x;
    now->next = top;
    top = now;
}
template <class T>
T LinkStack<T>::pop()
{
    if(Empty())
    throw"栈空";
    T x = top->data;
    Node<T> *tmp = top;
    top = top->next;
    delete tmp;
    return x;
}
template<class T>
T LinkStack<T>::GetTop(){
    if (Empty())
        throw "栈空";
    return top->data;
}

循环队列

const int QueueSize = 1000;
template<class T>
class CircleQueue
{
    public:
        CircleQueue(){front=rear = 0;}
        void EnQueue(T x);
        T DeQueue();
        T GetFront();
        int GetLength();
        bool Empty(){return front == rear;}

    private:
        T data[QueueSize];
        int front;
        int rear;
};
template <class T>
void CircleQueue<T>::EnQueue(T x){
    if((rear + 1)%QueueSize == front)
    throw"满";
    rear = (rear + 1) % QueueSize
    data[rear] = x;
}
template<class T>
int CircleQueue<T>::GetLength(){
    return (rear - front + QueueSize)%QueueSize;
}
template <class T>
T CircleQueue<T>::DeQueue(){
    if(Empty())
    throw"空";
    T x = data[(front+1)%QueueSize];
    front = (front + 1) % QueueSize;\
    return x;
}
template <class T>
T CircleQueue<T>::GetFront(){
    if (Empty())
        throw "空";
    return data[(front + 1) % QueueSize];
}

链式队列

template <class T>
struct Node
{
    T data;
    Node<T> *next;
};
template <class T>
class LinkQueue
{
    public:
        LinkQueue(){
            front = rear = new Node<T>;
            front -> next = NULL;
        }
        ~LinkQueue();
        void EnQueue(T x);
        T DeQueue();
        T GetQueue();
        bool Empty(){return rear == front;}
    private:
        Node<T> *front;
        Node<T> *rear;
};
template <class T>
LinkQueue<T>:: ~LinkQueue(){
    while(front){
        rear = front->next;
        delete front;
        front = rear;
    }
}
template <class T>
void LinkQueue<T>::EnQueue(T x){
    Node<T> *now = new Node<T>;
    now->data = x;
    rear->next = now;
    rear = now;
    rear->next = NULL;
}
template <class T>
T LinkQueue<T>::DeQueue(){
    
    if(Empty())
    throw"空";
    Node<T> *now = front->next;
    front->next = now->next;
    T x = now->data;
    if(!(front->next))//if (rear == now)
    rear = front;
    delete now;
    return x;
}
template <class T>
T LinkQueue<T>::GetQueue(){
    if (Empty())
        throw "空";
    return front->next->data;
}

字符串

// bf 字符串匹配
int SeqString::Index(SeqString &t){
    int i = j = 1; // 注意 这里字符串以1为起始，如果是0
    while(i <= GetLength() and j <= t.GetLength()){
        if(Get(i) == t.Get(j)){
            i++;j++;
        }
        else{
            i = j - i + 2;j = 1;//i = j - i + 1,j = 0;
        }
    }
    if(j > t.GetLength())
        return i+1-j; //i- j;
    else
    return -1;
}

// KMP 算法
void SeqString::GetNextArray(SeqString &t,int *&next){
    next = new int[t.GetLength() +1];
    next[1] = 0;
    next[2] = 1;
    int p = 1;
    for(int i = 3;i >= t.GetLength();j++){
        while (p > 1 and t.Get(p) != t.Get(i-1))
        {
            p = next[p];
            if(t.Get(p) == t.Get(j-1))
                ++p;
            next[j] = p;
        }
        
    }
}

int SeqString::KMP(SeqString &t){
    int *next;
    GetNextArray(t,next);
    int i = 1,j = 1;
    while(i <= GetLength() and j <= t.GetLength()){
        if(Get(i) == t.Get(j)){
            i++,j++;
        }
        else{
            if(!next(j))
            j = 1,i++;
            else
            j = next(j);
        }
    }
    delete []next;
    if(j > t.GetLength())
        return i-j+1;
    else
        return -1;
}

多维数组

• 二维数组
  行优先存储
  Loc(a[i][j] = Loc(a[1][1]) + (i-1) * n + j-1) *c
  列优先存储
  Loc(a[i][j] = Loc(a[1][1]) + (j-1) * m + i-1) *c
• k维数组
  行优先存储：
  $\text{Loc}(A[i_1][i_2]...[i_k]) = \text{Loc}(A[1][1]...[1]) + \left( \sum_{p=1}^{k} \left[ (i_p - 1) \cdot \left( \prod_{q=p+1}^{k} D_q \right) \right] \right) \cdot c$
  列优先存储：
  $\text{Loc}(A[i_1][i_2]...[i_k]) = \text{Loc}(A[1][1]...[1]) + \left( \sum_{p=1}^{k} \left[ (i_p - 1) \cdot \left( \prod_{q=1}^{p-1} D_q \right) \right] \right) \cdot c$

多维矩阵的转置

# define MAX_ELEMENT_NYMBER 1000
template<class T>
struct MatrixNode
{
    int row;
    int col;
    int value;
};
template <class T>
struct SpareMatrix
{
    int m;
    int n;
    int t;
    MatrixNode<T>data[MAX_ELEMENT_NYMBER];
};

// O(nt)
template <class T>
void TransMat(SpareMatrix<T> *OrigMat, SpareMatrix<T> *TransMat)
{
    TransMat->m = OrigMat->n; // 设置转置矩阵的行数
    TransMat->n = OrigMat->m; // 设置转置矩阵的列数
    TransMat->t = 0;          // 初始时转置矩阵的非零元素个数为零

    for (int col = 0; col < OrigMat->n; col++)
        for (int j = 0; j < OrigMat->t; j++)
            if (OrigMat->data[j].col == col) // 找出列号为 col 的三元组
            {
                TransMat->data[TransMat->t].col = OrigMat->data[j].row;
                TransMat->data[TransMat->t].row = OrigMat->data[j].col;
                TransMat->data[TransMat->t].value = OrigMat->data[j].value;
                TransMat->t++; // 非零元素个数增加
            }
}
// 优化版O(n+t)

template <class T>
void QuickTransMat(SpareMatrix<T> *OrigMat, SpareMatrix<T> *TransMat)
{
    int i;
    TransMat->m = OrigMat->n;
    TransMat->n = OrigMat->m;
    TransMat->t = OrigMat->t;
    if (OrigMat->t)
    {
        int *number = new int[OrigMat->n];
        memset(number, 0, OrigMat->n * sizeof(int));// 存储每一列的非零元素个数
        
        for (i = 0; i < OrigMat->t; i++)
            number[OrigMat->data[i].col]++;

        int *position = new int[OrigMat->n];// 存储每一列第一个非零元素在转置矩阵中的位置
        position[0] = 0;
        for (i = 1; i < OrigMat->n; i++)
            position[i] = position[i - 1] + number[i - 1];

        for (i = 0; i < OrigMat->t; i++)
        {
            int pos = position[OrigMat->data[i].col]++;
            TransMat->data[pos].col = OrigMat->data[i].row;
            TransMat->data[pos].row = OrigMat->data[i].col;
            TransMat->data[pos].value = OrigMat->data[i].value;
        }
        delete[] number;
        delete[] position;
    }
}

特点：相同类型元素、有限集合

1.1顺序表

template <class T, int N>
class SeqList
{
public:
    SeqList() { length = 0 };
    SeqList(T a[], int n);
    int GetLength() { return length; }
    void PrintList();
    void Insert(int i, T x);
    T Delete(int i);
    T Get(int i);
    int Locate(T x);

private:
    T data[N];
    int length;
};
template <class T, int N>
SeqList<T, N>::SeqList(T a[], int n)
{
    if (n > N)
        throw("数组长度超过最大限制");
    for (int i = 0; i < n; i++)
        data[i] = a[i];
    length = n;
}
template <class T, int N>
void SeqList<T, N>::PrintList()
{
    for (int i = 0; i < length; i++)
        cout << data[i] << " ";
    cout << endl;
}
template <class T, int N>
void SeqList<T, N>::Insert(int i, T x)
{
    if (n + 1 > N)
        throw("超出最大长度");
    if (i < 1 || i >= length)
        throw("位置异常");
    for (int j = length; j >= i; j--)
    {
        data[j] = data[j - 1];
    }
    data[i] = x;
    length++;
}
template <class T, int N>
T SeqList<T, N>::Delete(int i)
{
    if (i < 1 || i > length)
        throw("位置异常");
    if (length == 0)
        throw("溢出");
    T x = data[i];
    for (int j = i; j < length; j++)
    {
        data[j] = data[j + 1];
    }
    length--;
    return x;
}
template <class T, int N>
T SeqList<T, N>::Get(int i)
{
    if (i < 1 || i > length)
        throw("位置异常");
    return data[i - 1];
}
template <class T, int N>
int SeqList<T, N>::Locate(T x)
{
    int ans = 0;
    for (int i = 0; i < length; i++)
    {
        if (data[i] == x) // 注意除了基本数据类型外，需要对==进行重载
        {
            ans = i + 1;
            break;
        }·
    }
    return ans;
}

单链表

#include<iostream>
using namespace std;

template <class T>
struct Node
{
    T data;
    struct Node <T> *next;
};
template <class T>
class LinkList
{
    public:
        LinkList(){front = new Node<T>;front -> next = NULL;}
        LinkList(T a[],int n);
        ~LinkList();
        void PrintList();
        int GetLength();
        Node<T> *Get(int i);
        T Delete(int i);
        void Insert(int i,T x);
        void Insert1(int i, T x);
        int Locate(T x);
    private:
        Node<T> *front;
};

//带头结点的头插法
template<class T>
LinkList<T>::LinkList(T a[],int n){
    Node<T> *front = new Node<T>;
    front->next = NULL;
    for(int i = n-1;i >= 0;i--){
        Node<T> *tmp = new Node<T>;
        tmp->data = a[i];
        tmp->next = front->next;
        front->next = tmp;
    }
}
//不带头结点的头插法
template<class T>
LinkList<T>::LinkList(T a[],int n){
    if(n == 0)
    return NULL;
    else
    Node<T> *front = new Node<T>;
    front->data = a[n-1];
    for(int i = n-2;i >= 0;i--){
        Node<T> *tmp = new Node<T>;
        tmp->next = front;
        tmp->data = a[i];
        front = tmp;
    }
}
//尾插法
template <class T>
LinkList<T>::LinkList(T a[], int n)
{
    Node<T>* front = new Node<T>;
    front->next = nullptr;
    Node<T>* now = front;
    for(int i = 0;i < n;i++){
        Node<T> *p = new Node<T>;
        p -> data = a[i];
        now->next = p;
        now = p;
    }
    now->next = NULL;//注意
}

template<class T>
LinkList<T>::~LinkList(){
    Node<T>* p = front;
    while(p){
        front = p;
        p = p -> next;
        delete front;
    }
}

template<class T>
int LinkList<T>::GetLength(){
    Node<T> *p = front->next;
    int len = 1;
    while(p){
        len++;
        p = p->next;
    }
    return len;
}

template<class T>
void LinkList<T>::PrintList(){
    Node<T> *p = front->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}
template<class T>
Node<T> * LinkList<T>::Get(int i){
    if(i < 1)throw"位置异常";

    Node<T>*p = front -> next;
    while(i > 1){
        i--;
        if(p){
            p = p->next;
        }
        else throw"溢出";
    }
    return p;
}
//优化后的
template <class T>
Node<T> *LinkList<T>::Get(int i)
{
    if (i < 1)
        throw "位置异常";
    Node<T> *p = front->next; // 第1个数据结点
    if (!p)
        throw "溢出"; // 空表没有第1个节点
    for (int k = 1; k < i; ++k)
    {
        p = p->next;
        if (!p)
            throw "溢出";
    }
    return p;
}

template<class T>
int LinkList<T>::Locate(T x){
    int ans = 0;
    Node<T> *p = front->next;
    while(p){
        ans++;
        if (p->data == x) // 重载
            return ans;
        p = p-> next;
    }
    return -1;
}

template<class T>
void LinkList<T>::Insert(int i,T x){
   
    Node<T> *p = front;
    Node<T> *tmp = new Node<T>;
    tmp->data = x;
    int count = 1;
    while(p){
        if(count == i){
            tmp->next = p->next;
            p->next = tmp;
            break;
        }
        count++;
        p = p -> next;
    }
    if(p == NULL and count == i)//这种写法的问题就是如何保证我第i-1个数存在
    throw "位置异常";
    if(count < i || i < 1)
    throw"位置异常";
}
//使用Get的写法
template <class T>
void LinkList<T>::Insert1(int i, T x){
    Node<T> *p = front;
    if(i!=1) p = Get(i-1);//这里细节一下。如果是1就是更新头结点，为了防止Get函数抛出异常，一定要判断
    if(p){

        Node<T> tmp = new Node<T>;
        tmp->data = x;
        tmp->next = p->next;
        p->next = tmp;
    }
    else
    throw"位置异常";
}
/*
如果 给定某节点p 要求在该节点后插入，那么流程:
new --> new.data --> new->next = p->next --> p->next = new;
对于前插操作流程
只需 交换p 与 new的值

*/
template<class T>
T LinkList<T>::Delete(int i){
    Node <T> *p = front;
    if(i!=1) p = Get(i-1);
    p->next = p->next->next;
    T x = del->data;
    delete p;
    return x;
}

循环链表

使用尾指针就够了rear->next 就是头指针、

双链表

template<class T>
struct Node
{
   T data;
   Node<T> * prior;
   Node<T> * next;
};
//p后插入q

q->prior = p; 1️⃣
p->next->prior = q; 2️⃣
q->next = p->next; 3️⃣
p ->next = q;4️⃣
// ⚠️ 2️⃣ 3️⃣ 一定要在 4️⃣前面

 // 删除p的后继
q = p->next 1️⃣
p->next->next->prior = p; 2️⃣
p->next = p->next->next 3️⃣
// ⚠️ 1️⃣一定要在3️⃣前面
// 删除p所指的节点
思路：交换 p 与 next 的值 == 删除p的后继