机试中的常见模板

1. 根据先序遍历和中序遍历建立二叉树

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX 27

using namespace std;

struct Node
{
    char value;
    struct Node* left;
    struct Node* right;
};

int findData(char mid[], char a, int s)
{
    int i;
    for(i=0; i<s; i++)
    {
        if(mid[i] == a)
            return i;
    }
    return -1;
}

struct Node* build(char first[], char mid[], int s)
{
    if(s == 0)
        return NULL;
    struct Node* T = (struct Node*)malloc(sizeof(struct Node));
    T->value = first[0];
    int mPos = findData(mid, first[0], s);
    T->left = build(first+1, mid, mPos);
    T->right = build(first+1+mPos, mid+mPos+1, s-mPos-1);
    return T;
}

void lastTral(struct Node* T)
{
    if(T == NULL)
        return;
    lastTral(T->left);
    lastTral(T->right);
    printf("%c", T->value);
}

int main()
{
    char first[MAX], mid[MAX];
    while(scanf("%s%s", first, mid) != EOF)
    {
        int s = strlen(first);
        struct Node* T = build(first, mid, s);
        lastTral(T);
        printf("\n");
    }
}

2. 根据输出数据建立二叉排序树

注意使用递归建立会更加方便

struct Node
{
    int value;
    struct Node* left;
    struct Node* right;
};

struct Node* Insert(struct Node* T,  int data)
{
    if(T == NULL)
    {
        struct Node* t = (struct Node*)malloc(sizeof(struct Node));
        t->left = NULL;
        t->right = NULL;
        t->value = data;
        return t;
    }
    if(T->value > data)
    {
        T->left = Insert(T->left, data);
    }
    else if(T->value < data)
    {
        T->right = Insert(T->right, data);
    }
    return T;
}

struct Node* build(int a[], int n)
{
    int i;
    struct Node* T = NULL;
    for(i=0; i<n; i++)
    {
        T = Insert(T, a[i]);
    }
    return T;
}

3. 快速判断两棵树是否相等的方法

bool judgeSame(struct Node* t1, struct Node* t2)
{
    if(t1 == NULL && t2 == NULL)
        return true;

    if(t1->value == t2->value && judgeSame(t1->left, t2->left) && judgeSame(t1->right, t2->right))
        return true;
    else
        return false;
}

4. 求解最大公约数

int gcd(int a, int b)
{
    if(a < b)
    {
        int t = a;
        a = b;
        b = t;
    }
    if(b == 0)
        return a;
    else
        return gcd(b, a % b);
}

5. 素数打表

void init()
{
    memset(mark, 1, sizeof(mark));
    int i, j;
    for(i=2; i<=MAX; i++)
    {
        if(mark[i] == true)
        {
            for(j=i*i; j<=MAX; j+=i)
            {
                mark[j] = false;
            }
        }
    }
}

6. 二分求幂

int topow(int a, int b)
{
    int res = 1;
    int temp = a;
    while(b > 0)
    {
        if(b % 2 != 0)
            res = res * (b % 2) * temp;
        temp = temp * temp
        b = b / 2;
    }
    return res;
}

7. 大整数高精度乘法

使用int数组存储大整数，有关乘法的实现如下

int digit[MAX];
int s;

void hugeMutiple(int a)
{
    int i, temp;
    int carry = 0;
    for(i=0; i<s; i++)
    {
        temp = digit[i] * a + carry;
        digit[i] = temp % 10;
        carry = temp / 10;
    }
    while(carry != 0)
    {
        digit[s++] = carry % 10;
        carry /= 10;
    }
}

7. 哈夫曼树找根

int tree[MAX];

int findRoot(int x)
{
    if(tree[x] == -1)
        return x;
    int root = findRoot(tree[x]);
    tree[x] = root;
    return root;
}

8. Floyd算法

for(i=1; i<=n; i++)
{
	for(j=1; j<=n; j++)
    {
        for(k=1; k<=n; k++)
        {
            if(data[j][i] != -1 && data[i][k] != -1 && (data[j][k] == -1 || data[j][i] + data[i][k] < data[j][k]))
            {
                data[j][k] = data[j][i] + data[i][k];
            }

        }
    }
}

9. Dijistra算法

#define MAX 102
#define MAXX 12345678

using namespace std;

int data[MAX][MAX];
int dis[MAX];
int mark[MAX];

int main()
{
    int n, m, i, j, a, b, weight, minn;
    while(scanf("%d%d", &n, &m) != EOF)
    {
        memset(data, -1, sizeof(data));
        memset(mark, 0, sizeof(mark));
        memset(dis, -1, sizeof(dis));
        if(n == 0 && m == 0)
            break;
        for(i=1; i<=m; i++)
        {
            scanf("%d%d%d", &a, &b, &weight);
            if(data[a][b] == -1 || data[a][b] > weight)
            {
                data[a][b] = weight;
                data[b][a] = weight;
            }
        }
        int newp = 1;
        dis[newp] = 0;
        mark[newp] = true;
        for(i=2; i<=n; i++)
        {

            for(j=1; j<=n; j++)
            {
                if(!mark[j] && data[newp][j] != -1 && (dis[j] == -1 || dis[newp] + data[newp][j] < dis[j]))
                {
                    dis[j] = dis[newp] + data[newp][j];
                }
            }
            minn = MAXX;
            for(j=1; j<=n; j++)
            {
                if(!mark[j] && dis[j] != -1 && dis[j] < minn)
                {
                    minn = dis[j];
                    newp = j;
                }
            }
            mark[newp] = true;
        }
        printf("%d\n", dis[n]);
    }
}

10. DFS

在进行DFS时需要注意在遍历完一个点的情况之后要将其的mark还原

void dfs(int x)
{
    int i;
    if(x == n)
    {
        if(prime[data[n] + data[1]] == true)
        {
            for(i=1; i<=n; i++)
            {
                if(i == n)
                    printf("%d\n", data[i]);
                else
                    printf("%d ", data[i]);
            }
        }
        return;
    }
    for(i=2; i<=n; i++)
    {
        if(mark[i] == false && prime[data[x]+i] == true)
        {
            data[x+1] = i;
            mark[i] = true;
            dfs(x + 1);
            mark[i] = false;
        }
    }
}