17-11-08纠错

1.不适合用链式存储结构的检索方法：二分查找（只能在顺序结构上进行并且要求元素有序）
（注：哈希查找中的开散列方法，同时有顺序结构与链式结构）

2.prim算法的使用方法为基于连通分量找最小边。
代码如下：

int prim() {
	int i,j,pos,min,sum;
	for(i=1;i<=N;i++) 
		dist[i]=map[1][i];
	visited[1]=1;
	for(i=1;i<N;i++) { 
		min=INF;
		for(i=1;i<N;i++) {
		if(!visited[j]&&dist[j]<min) {
			min=dist;
			pos=j;
		}
	} 
	visited[pos]=1;
	for(j=1;j<=N;j++) {
		if(!visited[j]&&map[pos][j]<dist[j]) {
			dist[j]=map[pos][j];
		}
	} 
}
	sum=0;
	for(i=1;j<=N;i++) {
		sum+=dist[i];
		if(dist[i]==INF) return -1;
	}
	return sum;
}

顺便回忆一下kruskal算法。kruskal算法基于最小边观察是否加入当前树中。即基于最小找连通。算法不好写，大概率不考代码，掠过。

3.采用线性探查的方法查哈希表
不保真，自己写的

bool hash_serch(int a[],int x,int n) { //老师说可以用数组为例，不用hash表ADT
//以数组为例，令INF表示该地址没有元素
//传入数组，目标元素，数组大小
int base=h(x);
if(a[base]==x) return 1;
int i=1;
int ad=(base+i)%n;  //探查下一地址
while(ad!=base) {  
	if(a[ad]==x) return 1;
	if(a[ad]==INF) return 0;
	i++;
	ad=(base+i)%n;
	}
	rerurn 0;
}

4.整理一下可能会考的图算法

    void DFS(int v, void (*PreVisit)(int v), void (*PostVisit)(int v), void (*Visiting)(int v))   // Depth first search
    {
		PreVisit(v);
		Visiting(v);
		G->setMark(v,VISITED);
		for(int w=G->first(v);w<G->n();w=G->next(v,w))
		{
			if(G->getMark(w)==UNVISITED)
			DFS(w,(*PreVisit),(*PostVisit),(*Visiting));
		}
		PostVisit(v);
    }
    
    void m_DFS(int v, void (*PreVisit)(int v), void (*PostVisit)(int v), void (*Visiting)(int v)) 
    {
    	int visited[G->n()];
    	for(int i=0;i<G->n();i++) visited[i]=0;  //数组置空
		stack<int> s;
		s.push(v);
		visited[v]=1;  //源结点入栈，标为已访问
		
		PreVisit(v);
		
		while(!s.empty()) {
			int k=s.top();
			s.pop();
			//Visiting(k);
			for(int w=G->first(k);w<G->n();w=G->next(k,w)) {
				if(!visited[w]) {
				PreVisit(w);
				visited[w]=1;
				s.push(w); }
			}
			//PostVisit(k);
		} 
	}

    void BFS(int start, void (*PreVisit)(int v), void (*PostVisit)(int v), void (*Visiting)(int v))
    {
		int v=0,w=0;
		queue<int> q;
		q.push(start);
		G->setMark(start,VISITED);
		while(q.size()!=0) {
			v=q.front();
			q.pop();
			if(v==start) PreVisit(v);
			Visiting(v);
			for(w=G->first(v);w<G->n();w=G->next(v,w))
				if(G->getMark(w)==UNVISITED) 
				{
					PreVisit(w);
					G->setMark(w,VISITED);
					q.push(w);
				}
				PostVisit(v);
		} 
    }

    void Dijkstra1(int* D, int s)
    {
		int v,w,i;
		//for(int i=0;i<G->n();i++) D[i]=G->weight(s,i);//初始化最近数组
		for(i=0;i<G->n();i++) {//遍历n次 
			v=minVertex(D);//找dist最小值对应的点 
			if(D[v]==INFINITY) return;//图不连通，返回 
			G->setMark(v,VISITED);//访问 
			for(w=G->first(v);w<G->n();w=G->next(v,w)) //w是该点的第一条邻边 
			if(D[w]>(D[v]+G->weight(v,w)))
				D[w]=D[v]+G->weight(v,w);
		}

    }

    int minVertex(int* D)   // Find min cost vertex
    {
        int i, v = -1;
        // Initialize v to some unvisited vertex
        for (i = 0; i < G->n(); i++)
            if (G->getMark(i) == UNVISITED)//在最小值的函数里已经定义过要求未访问 
            {
                v = i;
                break;
            }
        for (i++; i < G->n(); i++) // Now find smallest D value
            if ((G->getMark(i) == UNVISITED) && (D[i] < D[v]))
                v = i;
        return v;
    }

    void AddEdgetoMST(int v1, int v2)
    {
        cout << "Add edge " << v1 << " to " << v2 << "\n";
    }
    void Prim(int* D, int s)   // Prim's MST algorithm
    {
    	int V[G->n()];
		int v,w,i;
		//for(int i=1;i<G->n();i++) D[i]=G->weight(s,i);//初始化最近数组
//		for(int j=G->first(0);j<G->n();j=G->next(0,j)) cout<<G->weight(0,j)<<" ";
//		cout<<endl;
		//测试代码  
		/*
		这里有个坑是什么呢，不用初始化D数组，因为D数组在main里面初始化过了。weight的默认值是0，
		要是再初始化一次的话，会被0覆盖掉该有的无穷 
		*/
		for(i=0;i<G->n();i++) {
			v=minVertex(D);
			if(v==INFINITY) return;//不连通
			G->setMark(v,VISITED);
			if(v!=s)
			AddEdgetoMST(V[v],v);//注意这里有了点变化，为了输出对应边，加上了V数组用于记录 
			for(w=G->first(v);w<G->n();w=G->next(v,w)) {
				if(D[w]>G->weight(v,w)) {
				D[w]=G->weight(v,w);
				V[w]=v;
				}
			}     
		}
    }
};

以及floyed算法
这里列出核心代码

for(int i=0;i<N;i++) {
	for(int k=0;k<N;k++) {
		for(int j=0;j<N;j++) {
		if(map[i][j]>map[i][k]+map[k][j])
			map[i][j]=map[i][k]+amp[k][j]; 
		}
	}
}

大意为计算每对点，经过任意一个点为中介时，可得的距离最小值
相当于把邻接矩阵平方