数据结构实验考试

数据结构实验考试

1. 二叉树遍历算法

1.1 先序遍历

Status PreOrderTraverse(BiTree T) {
    if(T == NULL) return OK;        // 空二叉树
    else {
        cout << T->data;            // 访问根结点
        PreOrderTraverse(T->lchild); // 递归遍历左子树
        PreOrderTraverse(T->rchild); // 递归遍历右子树
    }
}

1.2 中序遍历

Status InOrderTraverse(BiTree T) {
    if(T == NULL) return OK;        // 空二叉树
    else {
        InOrderTraverse(T->lchild);  // 递归遍历左子树
        cout << T->data;            // 访问根结点
        InOrderTraverse(T->rchild);  // 递归遍历右子树
    }
}

1.3 后序遍历

Status PostOrderTraverse(BiTree T) {
    if(T == NULL) return OK;         // 空二叉树
    else {
        PostOrderTraverse(T->lchild); // 递归遍历左子树
        PostOrderTraverse(T->rchild); // 递归遍历右子树
        cout << T->data;             // 访问根结点
    }
}

2. 哈夫曼树相关算法

2.1 哈夫曼树初始化

void CreateHuffmanTree(HuffmanTree& HT, int n) {
    if (n <= 1) return;
    m = 2 * n - 1;
    HT = new HTNode[m + 1];
    
    for (i = 1; i <= m; ++i) {
        HT[i].parent = 0;
        HT[i].lchild = 0;
        HT[i].rchild = 0;
    }
    
    cout << "请输入叶子结点的权值：\n";
    for (i = 1; i <= n; ++i)
        cin >> HT[i].weight;
}

2.2 哈夫曼编码构造

void CreatHuffmanCode(HuffmanTree HT, HuffmanCode& HC, int n) {
    int i, start, c, f;
    HC = new char* [n + 1];
    char* cd = new char[n];
    cd[n - 1] = '\0';
    
    for (i = 1; i <= n; ++i) {
        start = n - 1;
        c = i;
        f = HT[i].parent;
        
        while (f != 0) {
            --start;
            if (HT[f].lchild == c)
                cd[start] = '0';
            else
                cd[start] = '1';
            c = f;
            f = HT[f].parent;
        }
        
        HC[i] = new char[n - start];
        strcpy(HC[i], &cd[start]);
    }
}

2.3 哈夫曼译码

void HuffmanDecode(HuffmanTree tree, char* bitstreame) {
    int i, j = 0;
    char endflag = '\0';
    int m = tree[0].data;
    i = m;
    
    printf("译码后的字符为:");
    while (bitstreame[j] != endflag) {
        if (bitstreame[j] == '0')
            i = tree[i].lchild;
        else
            i = tree[i].rchild;
            
        if (tree[i].lchild == 0) {
            printf("%d", tree[i].data);
            i = m;
        }
        j++;
    }
    printf("\n");
}

3. 图相关算法

3.1 邻接矩阵创建无向网

Status CreateUDN(AMGraph &G) {
    cin >> G.vexnum >> G.arcnum;
    
    for(i = 0; i < G.vexnum; ++i)
        cin >> G.vexs[i];
        
    for(i = 0; i < G.vexnum; ++i)
        for(j = 0; j < G.vexnum; ++j)
            G.arcs[i][j] = MaxInt;
            
    for(k = 0; k < G.arcnum; ++k) {
        cin >> v1 >> v2 >> w;
        i = LocateVex(G, v1);
        j = LocateVex(G, v2);
        G.arcs[i][j] = w;
        G.arcs[j][i] = G.arcs[i][j];
    }
    return OK;
}

3.2 DFS算法

void DFS(ALGraph G, int v) {
    cout << v;
    visited[v] = true;
    p = G.vertices[v].firstarc;
    
    while(p != NULL) {
        w = p->adjvex;
        if(!visited[w])
            DFS(G, w);
        p = p->nextarc;
    }
}

3.3 BFS算法

void BFS(Graph G, int v) {
    cout << v;
    visited[v] = true;
    InitQueue(Q);
    EnQueue(Q, v);
    
    while(!QueueEmpty(Q)) {
        DeQueue(Q, u);
        for(w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w))
            if(!visited[w]) {
                cout << w;
                visited[w] = true;
                EnQueue(Q, w);
            }
    }
}

4. 排序算法

4.1 直接插入排序

void InsertSort(SqList &L) {
    for(i = 2; i <= L.length; ++i)
        if(L.r[i].key < L.r[i-1].key) {
            L.r[0] = L.r[i];
            L.r[i] = L.r[i-1];
            for(j = i-2; L.r[0].key < L.r[j].key; --j)
                L.r[j+1] = L.r[j];
            L.r[j+1] = L.r[0];
        }
}

4.2 折半查找排序

// 折半查找部分
low = 1;
high = i-1;
while (low <= high) {
    mid = (low + high) / 2;
    if (L.r[0].key < L.r[mid].key)
        high = mid - 1;
    else
        low = mid + 1;
}
for (j = i-1; j >= high+1; --j)
    L.r[j+1] = L.r[j];
L.r[high+1] = L.r[0];

4.3 希尔排序

void ShellInsert(SqList &L, int dk) {
    for(i = dk+1; i <= L.length; ++i)
        if(L.r[i].key < L.r[i-dk].key) {
            L.r[0] = L.r[i];
            for(j = i-dk; j > 0 && (L.r[0].key < L.r[j].key); j -= dk)
                L.r[j+dk] = L.r[j];
            L.r[j+dk] = L.r[0];
        }
}

void ShellSort(SqList &L, int dlta[], int t) {
    for(k = 0; k < t; ++k)
        ShellInsert(L, dlta[k]);
}

4.4 改进冒泡排序

void BubbleSort(SqList &L) {
    m = L.length - 1;
    flag = 1;
    while((m > 0) && (flag == 1)) {
        flag = 0;
        for(j = 1; j <= m; j++)
            if(L.r[j].key > L.r[j+1].key) {
                flag = 1;
                t = L.r[j];
                L.r[j] = L.r[j+1];
                L.r[j+1] = t;
            }
        --m;
    }
}

4.5 快速排序

int Partition(SqList &L, int low, int high) {
    L.r[0] = L.r[low];
    pivotkey = L.r[low].key;
    while(low < high) {
        while(low < high && L.r[high].key >= pivotkey)
            --high;
        L.r[low] = L.r[high];
        while(low < high && L.r[low].key <= pivotkey)
            ++low;
        L.r[high] = L.r[low];
    }
    L.r[low] = L.r[0];
    return low;
}

void QSort(SqList &L, int low, int high) {
    if(low < high) {
        pivotloc = Partition(L, low, high);
        QSort(L, low, pivotloc-1);
        QSort(L, pivotloc+1, high);
    }
}

4.6 简单选择排序

void SelectSort(RecType R[], int n) {
    int i, j, k;
    for(i = 0; i < n-1; i++) {
        k = i;
        for(j = i+1; j < n; j++)
            if(R[j].key < R[k].key)
                k = j;
        if(k != i) {
            copyNK(R[k], temp);
            for(j = k; j > i; j--)
                copyNK(R[k-1], R[k]);
            copyNK(temp, R[i]);
        }
    }
}

5. 查找算法

5.1 线性表查找

int LocateELem(SqList L, ElemType e) {
    for(i = 0; i < L.length; i++)
        if(L.elem[i] == e)
            return i+1;
    return 0;
}

int Search_Seq(SSTable ST, KeyType key) {
    ST.R[0].key = key;
    for(i = ST.length; ST.R[i].key != key; --i);
    return i;
}

5.2 折半查找

int Search_Bin(SSTable ST, KeyType key) {
    low = 1;
    high = ST.length;
    while(low <= high) {
        mid = (low + high) / 2;
        if(key == ST.R[mid].key)
            return mid;
        else if(key < ST.R[mid].key)
            high = mid - 1;
        else
            low = mid + 1;
    }
    return 0;
}

5.3 二叉排序树操作

5.3.1 插入操作

void InsertBST(BSTree &T, ElemType e) {
    if(!T) {
        BSTree S = new BSTNode;
        S->data = e;
        S->lchild = S->rchild = NULL;
        T = S;
    }
    else if(e.key < T->data.key)
        InsertBST(T->lchild, e);
    else if(e.key > T->data.key)
        InsertBST(T->rchild, e);
}

5.3.2 生成二叉排序树

void CreateBST(BSTree &T) {
    T = NULL;
    ElemType e;
    cin >> e.key;
    while(e.key != ENDFLAG) {
        InsertBST(T, e);
        cin >> e.key;
    }
}

5.4 哈希表查找

int SearchHash(HashTable HT[], int key) {
    int H0 = H(key);
    if(HT[H0].key == NULLKEY)
        return -1;
    else if(HT[H0].key == key)
        return H0;
    else {
        for(int i = 1; i < m; ++i) {
            Hi = (H0 + i) % m;
            if(HT[Hi].key == NULLKEY)
                return -1;
            else if(HT[Hi].key == key)
                return Hi;
        }
        return -1;
    }
}