算法模板梳理3--全国大学生算法设计与编程挑战赛（秋季赛）

19.顶点和连通分量计数

实现一个函数，打印给定的图中包含顶点数量最多的连通分量中顶点的数量，并返回连通分量的数量。

/顶点和连通分量计数
int max = 0,maxtemp = 0;
void dfs(int n,struct Graph *g) {
    visited[n] = 1;
    maxtemp++;
    for(int j = 0;j < g->v;j++) {
        if(g->Adj[n][j] == 1) {
            if(!visited[j]) {
                dfs(j,g);
            }
        }
    }
}

int countComponents(struct Graph* g) {
    int count = 0;
    for(int i = 0;i < g->v;i++) {
        if(!visited[i]) {
            dfs(i,g);
            count++;
            if(maxtemp > max) {
                max = maxtemp;
            }
            maxtemp = 0;
        }
    }
    printf("%d\n",max);
    return count;
}

20.两顶点之间是否有路径

对于给定的无向图及两个图中的顶点，请实现一个函数，分别打印包含这两个顶点的连通分量中的顶点数，并判断这两个顶点之间是否有路径。

//判断两个顶点之间是否有路径
int F = 0;

void travel(struct Graph *g,int v);

int hasPath(struct Graph *g,int v,int w) {
    int q[1000];
    int l = 0;
    int r = 0;
    int t;
    visited[v] = 1;
    q[r++] = v;
    while(l < r) {
        t = q[l++];
        if(t == w) {F = 1;break;}
        for(int i = 0;i < g->v;i++) {
            if(g->Adj(t,i)&&visited[i] == 0) {
                q[r++] = i;
                visited[i] = 1;
            }
        }
    }
    travel(g,v);
    travel(g,w);
    return F;
}


void travel(struct Graph *g,int v) {
    for(int i = 0;i < g->v;i++) {
        visited[i] = 0;
    }
    int q[1000];
    int l = 0;
    int r = 0;
    int c = 0;
    int t;
    visited[v] = 1;
    q[r++] = v;
    while(l < r) {
        t = q[l++];
        c++;
        for(int i = 0;i < g->v;i++) {
            if(g->Adj(t,i)&&visited[i] == 0) {
                q[r++] = i;
                visited[i] = 1;
            }
        }
    }
    printf("%d\n",c);
}

21.希尔排序的实现

//希尔排序的实现
void ShellInsert(SqList L,int dk) {
    for(int i = dk+1;i<=L.Length;i++) {
        if(L.elem[i-dk] > L.elem[i]) {
            L.elem[0] = L.elem[i-dk];
            L.elem[i-dk] = L.elem[i];
            L.elem[i] = L.elem[0];
            i = dk+1;
        }
    }
}

22.冒泡排序

//冒泡排序
void bubble_sort(SqList L) {
    int len = L.Length;
    int temp;
    for(int i = 1;i < len;i++) {
        for(int j = 1;j <= len-i;j++) {
            if(L.elem[j] > L.elem[j+1]) {
                temp = L.elem[j];
                L.elem[j] = L.elem[j+1];
                L.elem[j+1] =temp;
            }
        }
    }
}

33.快速排序

//快速排序
int Partition(SqList L,int low,int high) {
    int temp = L.elem[low];
    L.elem[0] = L.elem[low];
    while(low < high) {
        while(low < high&&L.elem[high] >= temp) high--;
        L.elem[low] = L.elem[high];
        while(low < high&&L.elem[low] <= temp) low++;
        L.elem[high] = L.elem[low];
    }
    L.elem[low] = L.elem[0];
    return low;
}

34.简单选择排序

//简单选择排序
void SelectSort(SqList L) {
    int i,j,k,temp;
    for(i = 1;i < L.Length;i++) {
        k = i;
        for(j = i + 1;j <= L.Length;j++) 
            if(L.elem[j] < L.elem[k]) {
                k = j;
            }
        if(k != i) {
            temp = L.elem[i];
            L.elem[i] = L.elem[k];
            L.elem[k] = temp;
        }
    }
}

35.堆排序

//堆排序
void HeapAdjust(HeapType H,int s,int m) {
    KeyType a;
    int i;
    a = H.elem[s];
    for(i = 2*s;i <= m;i *= 2) {
        if(i < m&&H.elem[i] < H.elem[i+1]) i++;
        if(a >= H.elem[i]) break;
        H.elem[s] = H.elem[i];
        s = i;
    }
    H.elem[s] = a;
}

36.归并排序

//归并排序
void Merge(SqList L,int low,int m,int high) {
    int B[high-low+1];
    int a = low,b = m + 1,k = 0;
    while(a <= m&&b <= high) {
        if(L.elem[a] <= L.elem[b]) {
            B[k++] = L.elem[a++];
        }
        else if(L.elem[b] <= L.elem[a]) {
            B[k++] = L.elem[b++];
        }
    }
    while(a <= m) {
        B[k++] = L.elem[a++];
    }
    while(b <= high) {
        B[k++] = L.elem[b++];
    }
    for(int i = low,k = 0;i <= high;i++) {
        L.elem[i] = B[k++];
    }
}