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];
}
}
}
大意为计算每对点,经过任意一个点为中介时,可得的距离最小值
相当于把邻接矩阵平方