C 之鏈式前向星

(若果有一定了解，可以跳過第一部分，直接看第二部分)

我們首先來看一下什麼是前向星.

前向星是一種特殊的邊集陣列,我們把邊集陣列中的每一條邊按照起點從小到大排序,如果起點相同就按照終點從小到大排序,

並記錄下以某個點為起點的所有邊在陣列中的起始位置和儲存長度,那麼前向星就構造好了.

用**len[i]來記錄所有以i為起點的邊在陣列中的儲存長度.

用head[i]**記錄以i為邊集在陣列中的第乙個儲存位置.

那麼對於下圖:

我們輸入邊的順序為:

1 22 3

3 41 3

4 11 5

4 5那麼排完序後就得到:

編號: 1 2 3 4 5 6 7

起點u: 1 1 1 2 3 4 4

終點v: 2 3 5 3 4 1 5

得到:head[1] = 1 len[1] = 3

head[2] = 4 len[2] = 1

head[3] = 5 len[3] = 1

head[4] = 6 len[4] = 2

但是利用前向星會有排序操作,如果用快排時間至少為o(nlog(n))

如果用**鏈式前向星,**就可以避免排序.

我們建立邊結構體為:

struct edge
;

其中edge[i].to表示第i條邊的終點,edge[i].next表示與第i條邊同起點的下一條邊的儲存位置,edge[i].w為邊權值.

另外還有乙個陣列head,它是用來表示以i為起點的第一條邊儲存的位置,實際上你會發現這裡的第一條邊儲存的位置其實

在以i為起點的所有邊的最後輸入的那個編號.

head陣列一般初始化為-1,對於加邊的add函式是這樣的:

void add(int u,int v,int w)

初始化cnt = 0,這樣,現在我們還是按照上面的圖和輸入來模擬一下:

edge[0].to = 2; edge[0].next = -1; head[1] = 0;

edge[1].to = 3; edge[1].next = -1; head[2] = 1;

edge[2].to = 4; edge[2],next = -1; head[3] = 2;

edge[3].to = 3; edge[3].next = 0; head[1] = 3;

edge[4].to = 1; edge[4].next = -1; head[4] = 4;

edge[5].to = 5; edge[5].next = 3; head[1] = 5;

edge[6].to = 5; edge[6].next = 4; head[4] = 6;

很明顯,head[i]儲存的是以i為起點的所有邊中編號最大的那個,而把這個當作頂點i的第一條起始邊的位置.

這樣在遍歷時是倒著遍歷的,也就是說與輸入順序是相反的,不過這樣不影響結果的正確性.

比如以上圖為例,以節點1為起點的邊有3條,它們的編號分別是0,3,5 而head[1] = 5

我們在遍歷以u節點為起始位置的所有邊的時候是這樣的:

for(int i=head[u];~i;i=edge[i].next)

那麼就是說先遍歷編號為5的邊,也就是head[1],然後就是edge[5].next,也就是編號3的邊,然後繼續edge[3].next,也

就是編號0的邊,可以看出是逆序的.

模板**1:

1 #include 2 #include 3 #include 4 #include 5 using namespace std;
6 const int inf = 0x3f3f3f3f;
7 const int m = 4444;
8 int d[m],head[m],vis[m];
9 struct nodeg[m];
12 typedef pairp;
13 int cnt=0;
14 inline void add(int u,int v,int w)
20 void dijkstra(int s)rng[max_e];
19 void add(int u,int v,int cost)
25 struct rule
29 };
30 inline int read()
31 34     while(ch>='0' && ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
35     return x*w;
36 }
37 void dijkstra(int a_)
50         }
51     }
52 }
53 int main(void)
62     dijkstra(1);
63     if(dis[v] == inf)
66     else
67         printf("%d\n",dis[v]);
68     return 0;
69 }

圖的深度優先遍歷，基本思想是訪問頂點，然後訪問v0鄰接到的未被訪問的點頂點v1，在從v1出發遞迴地按照深度優先的方式遍歷。當遇到乙個所有鄰接於它的頂點都被訪問了的頂點u時，則回到已訪問頂點的序列中最後乙個擁有未被訪問的相鄰頂點的頂點w，從w出發繼續訪問。最終當任何已被訪問的頂點都沒有未被訪問的相鄰頂點時，遍歷結束。也就是說深度優先遍歷是沿著圖的某一條分支遍歷，直到末端，然後回溯，沿著另一條分支進行同樣的遍歷，直到所有的分支都被遍歷過為止。

基於鏈式前向星的**：

bool s[maxn]=;//初始化
void dfs(int x)
}

#include #include #include #include #include #include #include #include #include #include #define i scanf
#define ol puts
#define o printf
#define f(a,b,c) for(a=b;a=0;a--)
#define len 1000000
#define max 1<<30
#define v vectorusing namespace std;
int head[len];    //記錄源點u在mp中第乙個位址i=head[u] 呼叫完之後就可以用mp[i]訪問邊表mp 
int cnt=0;        //邊表下標，隨著資料的錄入而擴張 
struct edge;
edge mp[len];    //邊表 
void add(int u,int v,int w)
int vis[len];
int bk;
void dfs(int s)
}int main()
while(k--)
o("%d\n",ans-1);
}return 0;
}

圖的寬度優先遍歷與深度優先遍歷不同之處在於：寬度優先遍歷訪問頂點v0然後訪問v0鄰接的未被訪問的所有頂點，v1,v2,····vn，在依次訪問v1,v2，···vn連線到的未被訪問的所有頂點，如此下去，直到所有點都被訪問。

**：

bool s[maxn];
void bfs(int x)
;edge mp[len];
void add(int u,int v,int w)
int main()
}i("%d",&k);
while(k--)}}
lev++;
if(lev>=l) break;
}o("%d\n",cnt);
}return 0;
}

**：

C 之鏈式前向星

前向星和鏈式前向星

前向星和鏈式前向星

前向星和鏈式前向星

C 之鏈式前向星

前向星和鏈式前向星

前向星和鏈式前向星

前向星和鏈式前向星

相關推薦