数据结构课程期末总结三

 

第五：

森林转化为二叉树，二叉树转化为森林（链表实现，数组实现）

/*
      森林转换成二叉树
      思路：u的孩子节点为v1, v2, v3....（v1,v2,....互为兄弟节点）
      那么将u的一个孩子节点（v1）连在u的左子树上，那么其他的孩子节点都连在v1的右子树上！
 */
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
int g[15][15];
int par[15];//如果该节点有父亲节点说明该节点不是一个独立的点！
int vis[15];

struct Tree
{
    int  d;
    Tree *lchild, *rchild;
    Tree()
    {
        lchild=rchild=NULL;
    }

    Tree(int x)
    {
        lchild=rchild=NULL;
        d=x;
    }
};
int n, m;

void buildT(Tree* &T, int u)
{
    bool flag=false;
    T=new Tree(u);
    Tree *cur=T;
    vis[u]=1;
    for(int v=1; v<=n; ++v)
        if(g[u][v])
        {
            if(!flag)
            {
                buildT(cur->lchild, v);
                cur=cur->lchild;
                flag=true;
            }
            else
            {
                buildT(cur->rchild, v);
                cur=cur->rchild;
            }
        }
}


void prePrint(Tree *T)
{
    if(!T) return ;
    cout<<T->d<<" ";
    prePrint(T->lchild);
    prePrint(T->rchild);
}


int main()
{
    Tree *T=NULL;
    while(cin>>n>>m)
    {
        memset(g, 0, sizeof(g));
        memset(vis, 0, sizeof(vis));
        while(m--)
        {
            int u, v;
            cin>>u>>v;
            g[u][v]=1;
            par[v]=u;
        }
        bool flag=false;
        Tree *cur;
        for(int i=1; i<=n; ++i)
            if(!vis[i])
            {
                if(!flag)
                {
                    flag=true;
                    buildT(T, i);
                    cur=T;
                }
                else if(!par[i]) //也就是找入度为0的节点！
                {
                    buildT(cur->rchild, i);
                    cur=cur->rchild;
                }
            }
        prePrint(T);
    }
    return 0;
}
/*
测试数据.....
11 8
2 1
2 3
2 4
5 6
6 9
5 7
5 8
11 10
*/

/*
      森林转换成二叉树
      思路：u的孩子节点为v1, v2, v3....（v1,v2,....互为兄弟节点）
      那么将u的一个孩子节点（v1）连在u的左子树上，那么其他的孩子节点都连在v1的右子树上！
 */
//数组实现....森林转成二叉树以及二叉树还原成森林
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define N 100 
using namespace std;

int mp[N][N];
int pp[N][N];
int n, m;
int ld[N], rd[N], par[N];

void printT(int u){
    if(u==0) return;
    printT(ld[u]);
    printT(rd[u]); 
    printf("%d ", u);
}

void rebuildMap(int u, int fa){
    if(u==0) return ;
    if(fa!=-1)  pp[fa][u]=1;
    rebuildMap(ld[u], u);
    rebuildMap(rd[u], fa);//u节点以及其兄弟节点的父亲节点都是u的父亲节点
} 

void buildT(int u){
    int v, cur;
    bool flag=false; 
    for(v=1; v<=n; ++v)
        if(mp[u][v]){
            if(!flag){
                ld[u]=v;
                cur=v;
                flag=true;
            }
            else{
                rd[cur]=v;//将u的兄弟节点都链接在右子树上
                cur=v;
            }
            buildT(v);
        } 
}

int main(){
    while(scanf("%d%d", &n, &m)!=EOF){
        memset(par, 0, sizeof(par));
        memset(pp, 0, sizeof(pp));
        memset(mp, 0, sizeof(mp));
        while(m--){
            int u, v;
            scanf("%d%d", &u, &v);
            mp[u][v]=1;
            par[v]=u;
        } 
        int root=-1, cur;
        for(int i=1; i<=n; ++i){
             if(!par[i]){
                 if(root!=-1) rd[cur]=i;
                 if(root==-1) root=i; 
                 buildT(i); 
                 cur=i;
             }
        }
        printf("打印树.....\n"); 
        printT(root);
        printf("\n");
        rebuildMap(root, -1);
        printf("\n\n还原树....\n"); 
        for(int i=1; i<=n; ++i)
              for(int j=1; j<=n; ++j)
                  if(pp[i][j])
                        printf("%d %d\n", i, j);
        printf("KO!\n"); 
    }
    return 0;
} 
/*
测试数据.....
11 8
2 1
2 3
2 4
5 6
6 9
5 7
5 8
11 10
*/

 

 

第六

DFS 深度优先算法和BFS 广度优先算法

DFS

BFS

广搜

 

 

第七

 最小生成树算法 ：prim 和 Kruskal

代码见文章最小生成树

 

 

第八

最短路问题算法：Dijkstra 和 Floyd

代码见最短路问题

 

 

第九

排序算法：插入排序 希尔排序 冒泡法 快排 选择排序 堆排序 归并排序

代码见排序算法专题

 

至此数据结构课程所讲内容总结完毕

Edit by :dong zhe yu