算法实习准备之一：数据结构复习（四）

数据结构复习（四）

图

1.广度优先搜索（Breadth-First-Search，BFS）
2.深度优先搜索（Depth-First-Search，DFS）
3.最小生成树（Minimum-Spanning-Tree，MST）
1）Prim算法：依次选择代价最小的边。
2）Kruskal算法：按权值的递增次序选择合适的边。
4.最短路径
1）Dijkstra算法求单源最短路径：Dijkstra算法不适用于边上带有负权值的情况。
2）Floyd算法求各顶点之间最短路径：Floyd算法允许图中有带负权值的边，但不允许有包含带负权值的边组成的回路。Floyd算法同样也适用于带权无向图。

查找

折半查找

int Binary_Search(SeqList L, ElemType key){
	int low=0, high=L.TableLen-1, mid;
	while(low<=high){
		mid=(low+high)/2;
		if(L.elem[mid]==key)
			return mid;
		else if(L.elem[mid]>key)
			high=mid-1;
		else
			low=mid+1;
	}
		return -1;
}

字符串模式匹配

KMP匹配算法

排序

插入排序

1.直接插入排序

void InsertSort(ElemType A[], int n){
	int i, j;
	for(i=2; i<=n; i++)
		if(A[i].key<A[i-1].key){
			A[0]=A[i];
			for(j=i-1;A[0].key<A[j].key;--j)
				A[j+1]=A[j];
			A[j+1]=A[0];
		}
}

2.折半插入排序

void InsertSort(ElemType A[], int n){
	int i, j;
	int low, high, mid;
	for(i=2; i<=n; i++)
		A[0]=A[i];
		low=1;
		high=i-1;
		while(low<=high){
			mid=(low+high)/2;
			if(A[mid].key>A[0].key)
				high=mid-1;
			else
				low=mid+1;
		}
		for(j=i-1;j>=high+1;--j)
			A[j+1]=A[j];
		A[high+1]=A[0];
	}
}

交换排序

1.冒泡排序：每趟冒泡时，前一趟确定的最小元素不再参与比较，每趟冒泡的结果把序列中的最小元素放到了序列的最终位置。

void BubbleSort(ElemType A[], int n){
	for(i=0;i<n-1;i++){
		flag=false;
		for(j=n-1;j>1;j--)
			if(A[j-1].key>A[j].key){
				swap(A[j-1],A[j]);
				flag=true;
			}
		if(flag==false)
			return;
	}
}

选择排序

1.简单选择排序：每一趟在后面n-i+1个待排序元素中选取关键字最小的元素，作为有序子序列的第i个元素，共进行n-1趟。

void SelectSort(ElemType A[], int n){
	for(i=0;1<n-1;i++){
		min=i;
		for(j=i+1;j<n;j++)
			if(A[j]<A[min])
				min=j;
			if(min!=i)
				swap(A[i], A[min]);
		}
}