数据结构和算法（五）
图
-
定义：图(Graph)是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)。其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。
-
线性表中把数据元素叫元素，树中叫结点，在图中数据元素则称之为顶点(Vertex)。
-
线性表可以没有数据元素，称为空表，树中可以没有结点，叫做空树，图结构顶点集合V要有穷非空。
-
线性表中，相邻的数据元素之间具有线性关系；树结构中，相邻两层的结点具有层次关系；图结构中，任意两个顶点之间都可能有关系，顶点之间的逻辑关系用边来表示，边集可以是空的。
-
无向边：若顶点Vi到Vj之间的边没有方向，则称这条边为无向边(Edge)，用无序偶(Vi，Vj)来表示。
-
有向边：若从顶点Vi到Vj的边有方向，则称这条边为有向边，也成为弧(Arc)，用有序偶<Vi，Vj>来表示，Vi称为弧尾，Vj称为弧头。
-
简单图：在图结构中，若不存在顶点到其自身的边，且同一条边不重复出现，则称这样的图为简单图。
-
无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。含有n个顶点的无向完全图有n(n-1)/2条边。
-
有向完全图：在有向图中，如果任意两个顶点之间都存在方向互为相反的两条弧，则称该图为有向完全图。含有n个顶点的有向完全图有n(n-1)条边。
-
稀疏图和稠密图：通常认为边或弧数小于n*logn(n是顶点的个数)的图称为稀疏图，反之称为稠密图。
-
权(Weight)：与图的边或弧相关的数，带权的图通常称为网(Network)。
-
图的顶点与边之间的关系
-
-
-
-
-
-
-
-
-
连通图的生成树定义：一个连通图的生成树是一个极小的连通子图，它含有图中全部的n个顶点，但只有足以构成一棵树的n-1条边。
-
-
图的存储结构
马踏棋盘问题（骑士周游问题）
#include <stdio.h>
#include <time.h>
#define X 8
#define Y 8
int chess[X][Y];
// 找到基于(x,y)位置的下一个可走的位置
int nextxy(int *x, int *y, int count)
{
switch(count)
{
case 0:
if( *x+2<=X-1 && *y-1>=0 && chess[*x+2][*y-1]==0 )
{
*x = *x + 2;
*y = *y - 1;
return 1;
}
break;
case 1:
if( *x+2<=X-1 && *y+1<=Y-1 && chess[*x+2][*y+1]==0 )
{
*x = *x + 2;
*y = *y + 1;
return 1;
}
break;
case 2:
if( *x+1<=X-1 && *y-2>=0 && chess[*x+1][*y-2]==0 )
{
*x = *x + 1;
*y = *y - 2;
return 1;
}
break;
case 3:
if( *x+1<=X-1 && *y+2<=Y-1 && chess[*x+1][*y+2]==0 )
{
*x = *x + 1;
*y = *y + 2;
return 1;
}
break;
case 4:
if( *x-2>=0 && *y-1>=0 && chess[*x-2][*y-1]==0 )
{
*x = *x - 2;
*y = *y - 1;
return 1;
}
break;
case 5:
if( *x-2>=0 && *y+1<=Y-1 && chess[*x-2][*y+1]==0 )
{
*x = *x - 2;
*y = *y + 1;
return 1;
}
break;
case 6:
if( *x-1>=0 && *y-2>=0 && chess[*x-1][*y-2]==0 )
{
*x = *x - 1;
*y = *y - 2;
return 1;
}
break;
case 7:
if( *x-1>=0 && *y+2<=Y-1 && chess[*x-1][*y+2]==0 )
{
*x = *x - 1;
*y = *y + 2;
return 1;
}
break;
default:
break;
}
return 0;
}
void print()
{
int i, j;
for( i=0; i < X; i++ )
{
for( j=0; j < Y; j++ )
{
printf("%2d\t", chess[i][j]);
}
printf("\n");
}
printf("\n");
}
// 深度优先遍历棋盘
// (x,y)为位置坐标
// tag是标记变量，每走一步，tag+1
int TravelChessBoard(int x, int y, int tag)
{
int x1=x, y1=y, flag=0, count=0;
chess[x][y] = tag;
// 如果tag==X*Y，则完成整个棋盘的遍历
if( tag == X*Y )
{
print();
return 1;
}
flag = nextxy(&x1, &y1, count);
while( 0==flag && count < 7 )
{
count++;
flag = nextxy(&x1, &y1, count);
}
while( flag )
{
if( TravelChessBoard(x1, y1, tag+1) )
{
return 1;
}
x1 = x;
y1 = y;
count++;
flag = nextxy(&x1, &y1, count);
while( 0==flag && count < 7 )
{
count++;
flag = nextxy(&x1, &y1, count);
}
}
if( 0 == flag )
{
chess[x][y] = 0;
}
return 0;
}
int main()
{
int i, j;
clock_t start, finish;
start = clock();
for( i=0; i < X; i++ )
{
for( j=0; j < Y; j++ )
{
chess[i][j] = 0;
}
}
if( !TravelChessBoard(2, 0, 1) )
{
printf("抱歉，马踏棋盘失败鸟~\n");
}
finish = clock();
printf("\n本次计算一共耗时: %f秒\n\n", (double)(finish-start)/CLOCKS_PER_SEC);
return 0;
}
广度优先遍历
广度优先遍历(BreadthFirstSearch)，又称广度优先搜索，简称BFS。
//邻接矩阵的广度遍历算法
void BFSTraverse( MGraph G )
{
int i, j;
Queue Q;
for( i=0; i < G.numVertexes;i++ )
{
visited[i] = FALSE;
}
initQueue( &Q );
for( i=0; i<G.numVertexes; i++ )
{
if( !visited[i] )
{
printf("%c ", G.vex[i]);
visited[i] = TRUE;
EnQueue(&Q, i);
while( !QueueEmpty(Q) )
{
DeQueue(&Q, &i);
for( j = 0; j < G.numVertexes; j++ )
{
if( G.art[i][j] == 1 && !visited[j] )
{
printf("%c ", G.vex[j]);
visited[j] = TRUE;
EnQueue(&Q, j);
}
}
}
}
}
}
Prim算法
考虑的出发点：为使生成树上边的权值之和达到最小，则应使生成树中每一条边的权值尽可能的小。
//Prim算法生成最小生成树
void MiniSpanTree_Prim(MGraph G)
{
int min, i, j, k;
int adjvex[MAXVEX]; //保存相关顶点下标
int lowcost[MAXVEX]; //保存相关顶点间边的权值
lowcost[0] = 0; //V0作为最小生成树的根开始遍历，权值为0
adjvex[0] = 0; //V0第一个加入
//初始化操作
for(i = 1; j < G.numVertexes; i++ )
{
lowcost[i] = G.arc[0][i]; //将邻接矩阵第0行所有权值先加入数组
adjvex[i] = 0; //初始化全部先为V0的下标
}
//真正构造最小生成树的过程
for(i=1; i < G.numVertexes; i++ )
{
min = INFINITY; //初始化最小权值为65535等不可能数值
j = 1;
k = 0;
//遍历全部顶点
while( j < G.numVertexes )
{
//找出lowcost数组已存储的最小权值
if( lowcost[j] != 0 && lowcost[j] < min )
{
min = lowcost[j];
k = j; //将发现的最小权值的下标存入k，以待使用
}
j++;
}
//打印当前顶点边中权值最小的边
printf("(%d, %d)", adjvex[k], k);
lowcost[k] = 0; //将当前顶点的权值设置为0，表示此顶点已完成任务，进行下一个顶点的遍历
//邻接矩阵k行逐个遍历全部顶点
for( j=1; j< G.numVertexes; j++ )
{
if( lowcost[j] != 0 && G.arc[k][j] < lowcost[j] )
{
lowcost[j] = G.arc[k][j];
adjvex[j] = k;
}
}
}
}
Kruskal算法生成最小生成树
//Kruskal算法生成最小生成树
int Find( int *parent, int f)
{
while(parent[f] > 0 )
{
f = parent[f];
}
return f;
}
void MiniSpanTree_Kruskal(MGraph G)
{
int i, n, m;
Edge edges[MAGEDGE]; //定义边集数组
int parent[MAXVEX]; //定义parent数组用来判断边与边是否形成环路
for( i=0; i < G.numVertexes; i++ )
{
parent[i] = 0;
}
for( i=0; i < G.numEdges; i++ )
{
n = Find(parent, edges[i].begin);
m = Find(parent, edges[i].end);
if(n != m) //如果n==m, 则形成环路，不满足
{
parent[n] = m; //将此边的结尾顶点放入下标为起点的parent数组中，表示此顶点已经在生成树集合中
printf("(%d, &d) %d ", edges[i].begin, edges[i].end, edges[i].weight);
}
}
}
迪杰斯特拉算法
#define MAXVEX 9
#define INFINITY 65535
typedef int Patharc[MAXVEX]; //用于存储最短路径下标的数组
typedef int ShortPathTable[MAXVEX]; //用于存储到各点最短路径的权值和
void ShortestPath_Dijkstar(MGraph G, int V0, Patharc *P, ShortPathTable *D)
{
int v, w, k, min;
int final[MAXVEX]; //final[w] = 1 表示已经求得顶点V0到Vw的最短路径
//初始化数据
for( v=0; v < G.numVertexes; v++ )
{
final[v] = 0; //全部顶点初始化为未找到最短路径
(*D)[V] = G.arc[V0][v]; //将与v0有连线的顶点加上权值
(*P)[V] = 0; //初始化路径数组P为0
}
(*D)[V0] = 0; //v0至v0的路径为0
final[V0] = 1; //v0至v0不需要求路径
//开始主循环，每次求得V0到某个v顶点的最短路径
for( v=1; v < G.numVertexes; v++ )
{
min = INFINITY;
for( w=0; w < G.numVertexes; w++ )
{
if( !final[w] && (*D)[w] < min )
{
k = w;
min = (*D)[w];
}
}
final[k] = 1; //将目前找到的最近的顶点置1
//修正当前最短路径及距离
for( w=0; w < G.numVextes; w++ )
{
//如果经过v顶点的路径比现在这条路径的长度短的话，更新
if( !final[w] && (min+G.arc[k][w] < (*D)[w]) )
{
(*D)[w] = min +G.arc[k][w]; //修改当前路径长度
(*p)[w] = k; //存放前驱顶点
}
}
}
}
floyd算法
typedef int Pathmatrirx[MAXVEX][MAXVEX];
typedef int ShortPathTable[MAXVEX][MAXVEX];
void ShortestPath_Floyd(MGraph G, Pathmatrirx *P, ShortPathTable *D)
{
int v, w, k;
//初始化D和P
for( v=0; v < G.numVertexes; v++ )
{
for( w=0; w < G.numVertexes; w++ )
{
(*D)[v][w] = G.matrix[v][w];
(*P)[v][w] = w;
}
}
//弗洛伊德算法
for( k=0; k < G.numVertexes; k++ )
{
for( v=0; v < G.numVertexes; v++ )
{
for( w=0; w < G.numVertexes; w++ )
{
if( (*D)[v][w] > (*D)[v][k] + (*D)[k][w] )
{
(*D)[v][w] = (*D)[v][k] + (*D)[k][w];
(*P)[v][w] = (*P)[v][k];
}
}
}
}
}
拓扑排序
-
一个无环的有向图称为无环图（Directed Acyclic Graph)，简称DAG图。
-
在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，这样的有向图为顶点表示活动的网，称为AOV网(Active On Vertex Network)。
-
// 边表结点声明 typedef struct EdgeNode { int adjvex; struct EdgeNode *next; }EdgeNode; // 顶点表结点声明 typedef struct VertexNode { int in; // 顶点入度 int data; EdgeNode *firstedge; }VertexNode, AdjList[MAXVEX]; typedef struct { AdjList adjList; int numVertexes, numEdges; }graphAdjList, *GraphAdjList; // 拓扑排序算法 // 若GL无回路，则输出拓扑排序序列并返回OK，否则返回ERROR Status TopologicalSort(GraphAdjList GL) { EdgeNode *e; int i, k, gettop; int top = 0; // 用于栈指针下标索引 int count = 0; // 用于统计输出顶点的个数 int *stack; // 用于存储入度为0的顶点 stack = (int *)malloc(GL->numVertexes * sizeof(int)); for( i=0; i < GL->numVertexes; i++ ) { if( 0 == GL->adjList[i].in ) { stack[++top] = i; // 将度为0的顶点下标入栈 } } while( 0 != top ) { gettop = stack[top--]; // 出栈 printf("%d -> ", GL->adjList[gettop].data); count++; for( e=GL->adjList[gettop].firstedge; e; e=e->next ) { k = e->adjvex; // 注意：下边这个if条件是分析整个程序的要点！ // 将k号顶点邻接点的入度-1，因为他的前驱已经消除 // 接着判断-1后入度是否为0，如果为0则也入栈 if( !(--GL->adjList[k].in) ) { stack[++top] = k; } } } if( count < GL->numVertexes ) // 如果count小于顶点数，说明存在环 { return ERROR; } else { return OK; } }
关键路径
// 边表结点声明
typedef struct EdgeNode
{
int adjvex;
struct EdgeNode *next;
}EdgeNode;
// 顶点表结点声明
typedef struct VertexNode
{
int in; // 顶点入度
int data;
EdgeNode *firstedge;
}VertexNode, AdjList[MAXVEX];
typedef struct
{
AdjList adjList;
int numVertexes, numEdges;
}graphAdjList, *GraphAdjList;
int *etv, *ltv;
int *stack2; // 用于存储拓扑序列的栈
int top2; // 用于stack2的栈顶指针
// 拓扑排序算法
// 若GL无回路，则输出拓扑排序序列并返回OK，否则返回ERROR
Status TopologicalSort(GraphAdjList GL)
{
EdgeNode *e;
int i, k, gettop;
int top = 0; // 用于栈指针下标索引
int count = 0; // 用于统计输出顶点的个数
int *stack; // 用于存储入度为0的顶点
stack = (int *)malloc(GL->numVertexes * sizeof(int));
for( i=0; i < GL->numVertexes; i++ )
{
if( 0 == GL->adjList[i].in )
{
stack[++top] = i; // 将度为0的顶点下标入栈
}
}
// 初始化etv都为0
top2 = 0;
etv = (int *)malloc(GL->numVertexes*sizeof(int));
for( i=0; i < GL->numVertexes; i++ )
{
etv[i] = 0;
}
stack2 = (int *)malloc(GL->numVertexes*sizeof(int));
while( 0 != top )
{
gettop = stack[top--]; // 出栈
// printf("%d -> ", GL->adjList[gettop].data);
stack2[++top2] = gettop; // 保存拓扑序列顺序 C1 C2 C3 C4 .... C9
count++;
for( e=GL->adjList[gettop].firstedge; e; e=e->next )
{
k = e->adjvex;
// 注意：下边这个if条件是分析整个程序的要点！
// 将k号顶点邻接点的入度-1，因为他的前驱已经消除
// 接着判断-1后入度是否为0，如果为0则也入栈
if( !(--GL->adjList[k].in) )
{
stack[++top] = k;
}
if( (etv[gettop]+e->weight) > etv[k] )
{
etv[k] = etv[gettop] + e->weight;
}
}
}
if( count < GL->numVertexes ) // 如果count小于顶点数，说明存在环
{
return ERROR;
}
else
{
return OK;
}
}
// 求关键路径，GL为有向图，输出GL的各项关键活动
void CriticalPath(GraphAdjList GL)
{
EdgeNode *e;
int i, gettop, k, j;
int ete, lte;
// 调用改进后的拓扑排序，求出etv和stack2的值
TopologicalSort(GL);
// 初始化ltv都为汇点的时间
ltv = (int *)malloc(GL->numVertexes*sizeof(int));
for( i=0; i < GL->numVertexes; i++ )
{
ltv[i] = etv[GL->numVertexes-1];
}
// 从汇点倒过来逐个计算ltv
while( 0 != top2 )
{
gettop = stack2[top2--]; // 注意，第一个出栈是汇点
for( e=GL->adjList[gettop].firstedge; e; e=e->next )
{
k = e->adjvex;
if( (ltv[k] - e->weight) < ltv[gettop] )
{
ltv[gettop] = ltv[k] - e->weight;
}
}
}
// 通过etv和ltv求ete和lte
for( j=0; j < GL->numVertexes; j++ )
{
for( e=GL->adjList[j].firstedge; e; e=e->next )
{
k = e->adjvex;
ete = etv[j];
lte = ltv[k] - e->weight;
if( ete == lte )
{
printf("<v%d,v%d> length: %d , ", GL->adjList[j].data, GL->adjList[k].data, e->weight );
}
}
}
}
插值查找(按比例查找)
要求：待查序列按关键码有序。基本思想：先确定待查记录所在的区间，然后逐步缩小范围直到找到或找不到该记录为止。折半查找要求线性表用顺序表作为存储结构。
int Search_Bin(int a[], int n, int target)//a[0]不用，a[1]~a[n]存储数据
{
int low = 1;
int high = n;
while(low <= high)
{
int mid = low + (high - low) / 2;
if(a[mid] == target) return mid;
else if(a[mid] > target) high = mid - 1;
else low = mid + 1;
}
return 0;
}
斐波那契查找(黄金分割法查找)
public static int MaxSize=20; //先为斐波那契数列设置长度
//构建你波拉契数列
public static int[] fib(){
int[] f=new int[MaxSize];
f[0]=1;
f[1]=1;
for (int i=2;i<MaxSize;i++){
f[i]=f[i-1]+f[i-2];
}
return f;
}
public static int fibSearch(int[] arr,int key){
int left=0; //初始指向最数组最左边
int right=arr.length-1; //初始指向最数组最右边
int k=0; //指示斐波那契数列的下标，初始为0是为了根据数组长度确定数组需要扩展的长度
int mid=0;
int[] f=fib(); //获取斐波那契数列
while (arr.length>f[k]-1){ //这里的f[k]是arr距离斐波那契数列最近的数值，为什么-1，为了符合数组特性(数组最大元素下标是数组长度-1)
k++;
}
int[] temp=Arrays.copyOf(arr,f[k]); //为什么构建一个新数组，因为下面需要对数组进行扩展，查找最后还要用到原始数组，所以不能用原始数组
//扩展数组
for (int i=right+1;i<temp.length;i++){ //这里为什么用temp.length?因为上面Arrays.copyOf(arr,f[k])已经对数组扩展了，这里我们进行的是把扩展的值都改为原始数组的最大值
temp[i]=arr[right];
}
while (left<=right){
mid=left+f[k-1]-1; //这里就是为mid确定位置，位置确定请看上面的图
if (key<temp[mid]){ //如果当前mid值大于key，说明key在mid左边部分，继续对左边的F[k-1]-1部分进行分割
right=mid-1;
k--;
}else if (key>temp[mid]){
left=mid+1;
k-=2;
}else {
if (mid<arr.length){ //查找值的下标在arr数组额范围内，直接返回
return mid;
}else { //不在就返回right,为什么？因为后面几位的值和right的值是一样的，说明查找的值就是right
return right;
}
}
}
//都找不到返回-1
return -1;
}
public static void main(String[] args) {
int[] a={0,16,24,35,47,59,62,73,88,99};
int key=99;
System.out.println(fibSearch(a,key));
}
线性索引查找
二叉排序树
//二叉树的查找
//二叉树的二叉链表结点结构定义
typedef struct BiTNode
{
int data;
struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
//递归查找二叉排序树T中是否存在key
//指针f指向T的双亲，其初始值调用值为NULL
//若查找成功，则指针p指向该数据元素结点，并返回TRUE
//否则指针p指向查找路径上访问的最后一个结点，并返回FALSE
Status SearchBST(BiTree T, int key, BiTree f, BiTree *p)
{
if(!T) //查找不成功
{
*p = f;
return FALSE;
}
else if( key == T->data) //查找成功
{
*p = T;
return TRUE;
}
else if( key < T->data)
{
return SearchBST( T->lchild, key, T, p ); //在左子树继续查找
}
else
{
return SearchBST( T->rchild, key, T, p ); //在右子树继续查找
}
}
//二叉树的插入
//当二叉排序树T中不存在关键字等于key的数据元素时，
//插入key并返回TRUE，否则返回FALSE
Status InsertBST(BiTree *T, int key)
{
BiTree p, s;
if( !SearchBST(*T, key, NULL, &p))
{
s = (BiTree)malloc(sizeof(BiTNode));
s->data = key;
s->lchild = s->rchild = NULL;
if( !p ) //查找不到key
{
*T = s; //插入s为新的根结点
}
else if( key < p->data )
{
p->lchild = s; //插入s为左孩子
}
else
{
p->rchild = s; //插入s为右孩子
}
return TRUE;
}
else
{
return FALSE; //树中已有关键字相同的结点，不再插入
}
}
//删除二叉树
Status DeleteBST(BiTree *T, int key)
{
if( !*T )
{
return FALSE;
}
else
{
if( key == (*T)->data )
{
return Delete(T);
}
else if( key < (*T)->data )
{
return DeleteBST(&(*T)->lchild, key);
}
else
{
return DeleteBST(&(*T)->rchild, key);
}
}
}
Status Delete(BiTree *p)
{
BiTree q, s;
if( (*p)->rchild == NULL )
{
q = *p;
*p = (*p)->lchild;
free(q);
}
else if((*p) ->lchild == NULL )
{
q = *p;
*p = (*p)->rchild;
free(q);
}
else
{
q = *p;
s = (*p)->lchild;
while( s->rchild )
{
q = s;
s = s->rchild;
}
(*p)->data = s->data;
if( q != *p)
{
q->rchild = s->lchild;
}
else
{
q->lchild = s->lchild;
}
free(s);
}
return TRUE;
}
平衡二叉树
//AVL
#define LH 1
#define EH 0
#define RH -1
typedef struct BiTNode
{
int data;
int bf;
struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;
void R_Rotate(BiTree *p)
{
BiTree L;
L = (*p)->lchild;
(*p)->lchild = L->rchild;
L->rchild = (*p);
*p = L;
}
void LeftBalance(BiTree *T)
{
BiTree L, Lr;
L = (*T)->lchild;
switch(L->bf)
{
case LH:
(*T)->bf = L->bf = EH;
R_Rotate(T);
break;
case RH:
Lr = L->rchild;
switch(Lr->bf)
{
case LH:
(*T)->bf = RH;
L->bf = EH;
break;
case EH:
(*T)->bf = L->bf = EH;
break;
case RH:
(*T)->bf = EH;
L->bf = LH;
break;
}
Lr->bf = EH;
L_Rotate(&(*T)->lchild);
R_Rotate(T);
break;
}
}
int InsertAVL(BiTree *T, int e, int *taller)
{
if( !*T )
{
*T = (BiTree)malloc(sizeof(BiTNode));
(*T)->data = e;
(*T)->lchild = (*T)->rchild = NULL;
(*T)->bf = EH;
*taller = TRUE;
}
else
{
if(e == (*T)->data)
{
*taller = FALSE;
return FALSE;
}
if(e < (*T)->data)
{
if(!InsertAVL(&(*T)->lchild, e, taller))
{
return FALSE;
}
if(*taller)
{
switch((*T)->bf)
{
case LH:
LeftBalance(T);
*taller = FALSE;
break;
case EH:
(*T)->bf = LH;
*taller = FALSE;
break;
case RH:
(*T)->bf = EH;
*taller = FALSE;
break;
}
}
}
else
{
if(!InsertAVL(&(*T)->rchild, e, taller))
{
return FALSE;
}
if(*taller)
{
switch((*T)->bf)
{
case LH:
(*T)->bf = EH;
*taller = FALSE;
break;
case EH:
(*T)->bf = RH;
*taller = TRUE;
break;
case RH:
RightBalance(T);
*taller = FALSE;
break;
}
}
}
}
散列表(哈希表)查找
- 散列表的查找步骤：
- 当存储记录时，通过散列函数计算出记录的散列地址。
- 当查找记录时，我们通过同样的是散列函数计算记录的散列地址，并按此散列地址访问该记录。
