排序&&最小生成树

算法

//快速排序，一般效率还是挺高的

#include<bits/stdc++.h>
using namespace std;
int a[9]={15,29,135,18,32,1,27,25,5};
void print(){
    for(int i=0;i<10;i++){
        printf(" %d",a[i]);
    }
    printf("\n");

}

void quicksort(int a[],int left,int right){//从大到小排
    if(left>=right)
        return;
    int temp;
    int i=left,j=right;

    int key = a[left];//将第一个数字设为标记位
    //bool Issort=false;//标记是否可以进行接着排序

    while(i<j){
        while(a[j]<=key&&i<j)//如果需要从小到大只需要改这里
            j--;
        while(a[i]>=key&&i<j)
            i++;
        if(i<j){
           temp = a[i];
           a[i] = a[j];
           a[j] = temp;
        }
    }//当i=j,一轮排序结束
    a[left] = a[i];
    a[i] = key;//key归位
    print();
    //分治
    quicksort(a,left,i-1);//因为上一轮排好之后，只需要分别再排i的左右就行了
    quicksort(a,i+1,right);





}

int main()
{
    quicksort(a,0,8);




}


//归并排序，先分再合

#include<bits/stdc++.h>
using namespace std;
int a[9]= {15,29,135,18,32,1,27,25,5};
void print()
{
    for(int i=0; i<9; i++)
    {
        printf(" %d",a[i]);
    }
    printf("\n");

}


void Mergea(int a[],int l,int m,int r)
{
    int n1 = m - l;
    int n2 = r -m;
    int *left = new int[n1];
    int *right = new int[n2];//动态分配空间

    for(int i=0; i<n1; i++)
    {
        left[i] = a[l+i];

    }
    for(int j=0; j<n2; j++)
        right[j] = a[m+j];

    //归并排序
    int i=0,j=0,key;
    for(key = l; key<r; key++)
    {
        if(i<n1&&left[i]<=right[j])
            a[key] = left[i++];//谁合适就放谁
        else if(j<n2&&left[i]>right[j])
            a[key] = right[j++];
        else if(i == n1&&j<n2)//如果left或者right已经排完
            a[key] = right[j++];
        else if(j==n2 && i<n1)
            a[key] = left[i++];
    }


}
void Mergesort(int a[],int left,int right) //从小到大排
{
    if(left+1>=right)
        return ;//适时退出
    int mid = (left+right)/2;//取中点分割
    Mergesort(a,left,mid);//递归
    Mergesort(a,mid,right);//从mid+1开始，因为mid之前已经被mergesort了
    //归并
    Mergea(a,left,mid,right);






}
int main()
{
    Mergesort(a,0,9);
    print();



}

Prim 和 克鲁斯卡尔算法

//prime
/*
从图中某一个顶点出发，寻找它相连的所有结点，比较这些结点的权值大小，然后连接权值最小的那个结点。
然后将寻找这两个结点相连的所有结点，找到权值最小的连接。.
重复上一步，直到所有结点都连接上。
主要是lowcost表的更新，
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define MAXN 110
int map[MAXN][MAXN], lowcost[MAXN];// 使用了map存储两点之间的距离
bool visit[MAXN];
int nodenum, sum;
 
void prim()
{
	int temp, k;
	sum = 0;
	memset(visit, false, sizeof(visit)); //初始化visit
	visit[1] = true;//从1开始
	for(int i = 1; i <= nodenum; ++i) //初始化lowcost[i]
		lowcost[i] = map[1][i];
	for(int i = 1; i <= nodenum; ++i)//找生成树集合点集相连最小权值的边
	{
		temp = INF;
		for(int j = 1; j <= nodenum; ++j)
			if(!visit[j] && temp > lowcost[j])
				temp = lowcost[k = j];//k=j,lowcost[j]
		if(temp == INF) break;//没找到，break
		visit[k] = true; //加入最小生成树集合
		sum += temp;//记录权值之和
		for(int j = 1; j <= nodenum; ++j) //更新lowcost数组
			if(!visit[j] && lowcost[j] > map[k][j])  //主要是lowcost表的更新
				lowcost[j] = map[k][j];
	}
}
 
int main()
{
	int a, b, cost, edgenum;
	while(scanf("%d", &nodenum) && nodenum)//输入点的个数
	{
		memset(map, INF, sizeof(map));  //先将每条边长度设为最大，可以表示没有连接，后面输入的如果比INF小就表示相连
		edgenum = nodenum * (nodenum - 1) / 2;
		for(int i = 1; i <= edgenum; ++i) //输入边的信息
		{
			scanf("%d%d%d", &a, &b, &cost);
			if(cost < map[a][b])
				map[a][b] = map[b][a] = cost;
		}
		prim();
		printf("%d\n", sum); //最小生成树权值之和
	}
	return 0;
}





//克鲁斯卡尔算法（边）
/*
普里姆算法是从某一顶点为起点，逐步找各个顶点最小权值的边来构成最小生成树。那我们也可以直接从边出发，寻找权值最小的边来构建最小生成树。不过在构建的过程中要考虑是否会形成环的情况
*/
#include <stdio.h>
#include <stdlib.h>
#define Max 50

typedef struct road *Road; //储存图的结构
typedef struct road
{
	int a, b;
	int w;
}road;

typedef struct graph *Graph;
typedef struct graph
{
	int e, n;
	Road data;
}graph;

Graph initGraph(int m, int n) //初始化图
{
	Graph g = (Graph)malloc(sizeof(graph));
	g->n = m;
	g->e = n;
	g->data = (Road)malloc(sizeof(road) * (g->e));
	return g;
}

void create(Graph g)
{
	int i;
	for (i = 1; i <= g->e; i++)
	{
		int x, y, w;
		scanf("%d %d %d", &x, &y, &w);
		if (x < y)
		{
			g->data[i].a = x;
			g->data[i].b = y;
		}
		else
		{
			g->data[i].a = y;
			g->data[i].b = x;
		}
		g->data[i].w = w;
	}
}

int getRoot(int v[], int x)
{
	while (v[x] != x)
	{
		x = v[x];
	}
	return x;
}

void sort(Road data, int n)
{
	int i, j;
	for (i = 1; i <= n - 1; i++)
	{
		for (j = 1; j <= n - i; j++)
		{
			if (data[j].w > data[j + 1].w)
			{
				road t = data[j];
				data[j] = data[j + 1];
				data[j + 1] = t;
			}
		}
	}
}

void Kruskal(Graph g)
{
	int sum = 0;
	int v[Max];
	int i;
	for (i = 1; i <= g->n; i++)
	{
		v[i] = i;
	}
	sort(g->data, g->e); //排序
	for (i = 1; i <= g->e; i++)
	{
		int a, b;
		a = getRoot(v, g->data[i].a);
		b = getRoot(v, g->data[i].b);
		if (a != b)
		{
			v[a] = b;
			sum += g->data[i].w;
			printf("%d--->%d权值为：%d\n", a, b, g->data[i].w);
		}
	}
	printf("最小权值为：%d\n", sum);
}

int main()
{
	int m, n, id = 1;
	scanf("%d %d", &m, &n);
	int i;
	Graph g = initGraph(m, n);
	create(g);
	Kruskal(g);
	free(g);
	return 0;
}