溫馨提示×
您好，登錄后才能下訂單哦！
點(diǎn)擊 登錄注冊(cè) 即表示同意《億速云用戶服務(wù)條款》
您好，登錄后才能下訂單哦！
小編今天帶大家了解Java數(shù)據(jù)結(jié)構(gòu)中圖的原理與實(shí)現(xiàn)是怎樣的，文中知識(shí)點(diǎn)介紹的非常詳細(xì)。覺得有幫助的朋友可以跟著小編一起瀏覽文章的內(nèi)容，希望能夠幫助更多想解決這個(gè)問題的朋友找到問題的答案，下面跟著小編一起深入學(xué)習(xí)“Java數(shù)據(jù)結(jié)構(gòu)中圖的原理與實(shí)現(xiàn)是怎樣的”的知識(shí)吧。
定義：圖（Graph）是由頂點(diǎn)的有窮非空集合和頂點(diǎn)之間邊的集合組成，通常表示為：G(V,E)，其中，G表示一個(gè)圖，V是圖G中頂點(diǎn)的集合，E是圖G中邊的集合。圖在數(shù)據(jù)結(jié)構(gòu)中是中多對(duì)多的關(guān)系，而樹則是1對(duì)多的關(guān)系，樹就是一種特別的沒有閉環(huán)的圖。
頂點(diǎn)：圖中的頂點(diǎn)就是節(jié)點(diǎn)的意思，不過圖中任意的節(jié)點(diǎn)都算作頂點(diǎn)。將頂點(diǎn)集合為空的圖稱為空?qǐng)D。圖中任意兩個(gè)頂點(diǎn)之間都可能存在關(guān)系，頂點(diǎn)之間的邏輯關(guān)系用邊來表示，邊集可以是空的。
無向圖：若頂點(diǎn)vi到vj之間的邊沒有方向，則稱這條邊為無向邊（Edge），用無序偶對(duì)(vi,vj)來表示。如果圖中任意兩個(gè)頂點(diǎn)之間的邊都是無向邊，則稱該圖為無向圖（Undirected graphs）。
有向圖：若從頂點(diǎn)vi到vj的邊有方向，則稱這條邊為有向邊，也稱為?。ˋrc）。如果圖中任意兩個(gè)頂點(diǎn)之間的邊都是有向邊，則稱該圖為有向圖（Directed graphs）。
完全圖、稠密圖、稀疏圖：具有n個(gè)頂點(diǎn)，n(n-1)/2條邊的圖，稱為完全無向圖；具有n個(gè)頂點(diǎn)，n(n-1) 條弧的有向圖,稱為完全有向圖。完全無向圖和完全有向圖都稱為完全圖。當(dāng)一個(gè)圖接近完全圖時(shí)，則稱它為稠密圖，當(dāng)一個(gè)圖中含有較少的邊或弧時(shí)，則稱它為稀疏圖。
權(quán)、網(wǎng)：有些圖的邊或弧具有與它相關(guān)的數(shù)字，這種與圖的邊或弧相關(guān)的數(shù)叫做權(quán)（Weight）。這些權(quán)可以表示從一個(gè)頂點(diǎn)到另一個(gè)頂點(diǎn)的距離或耗費(fèi)。這種帶權(quán)的圖通常稱為網(wǎng)（Network）。
子圖：若有兩個(gè)圖G=(V1,E1)， G2=(V2,E2)， 滿足如下條件：V2⊆V1 ，E2⊆ E1，即V2為V1的子集，E2為E1的子集，則 稱圖G2為圖G1的子圖。
下圖中帶底紋的圖均為左側(cè)無向圖與有向圖的子圖。
鄰接點(diǎn)、度：相鄰且有邊直接連接的兩個(gè)頂點(diǎn)稱為鄰接點(diǎn)。頂點(diǎn)所連邊的數(shù)目稱為度，在有向圖中，由于邊有方向，則頂點(diǎn)的度分為入度和出度。
簡(jiǎn)單路徑、連通圖：圖中頂點(diǎn)間存在路徑，兩頂點(diǎn)存在路徑則說明是連通的，如果路徑最終回到起始點(diǎn)則稱為環(huán)，當(dāng)中不重復(fù)叫簡(jiǎn)單路徑。若任意兩頂點(diǎn)都是連通的，則圖就是連通圖，有向則稱強(qiáng)連通圖。圖中有子圖，若子圖極大連通則就是連通分量，有向的則稱強(qiáng)連通分量。
生成樹：無向圖中連通且n個(gè)頂點(diǎn)n-1條邊叫生成樹。有向圖中一頂點(diǎn)入度為0其余頂點(diǎn)入度為1的叫有向樹。一個(gè)有向圖由若干棵有向樹構(gòu)成生成森林。
由于圖的結(jié)構(gòu)比較復(fù)雜，任意兩個(gè)頂點(diǎn)之間都可能存在聯(lián)系，因此無法以單一的結(jié)構(gòu)來表示。圖最常見的表示形式為鄰接鏈表和鄰接矩陣，它們都是采用復(fù)合的結(jié)構(gòu)來表示圖。
鄰接矩陣（Adjacency Matrix）：采用兩個(gè)數(shù)組來存儲(chǔ)圖，一個(gè)一維數(shù)組存儲(chǔ)圖頂點(diǎn)信息，一個(gè)二維數(shù)組存儲(chǔ)圖邊或弧的信息，二維數(shù)組可以看作矩陣，這也是“鄰接矩陣”名字的由來。這是最簡(jiǎn)單的圖的存儲(chǔ)方式，但是存在空間浪費(fèi)的情況。
設(shè)圖G有n個(gè)頂點(diǎn)，則鄰接矩陣是一個(gè)n×n的方陣，定義為：
矩陣的對(duì)角線始終為0，因?yàn)轫旤c(diǎn)不能和自己連接。無向圖的數(shù)據(jù)是對(duì)稱的，有向圖就不一定了。
下圖就是采用鄰接矩陣表示的無向圖。
下圖就是采用鄰接矩陣表示的有向圖。
有向圖講究入度與出度，頂點(diǎn)0的入度為3，正好是第1列各數(shù)之和。頂點(diǎn)0的出度為3，即第1行的各數(shù)之和。一個(gè)點(diǎn)的入度是點(diǎn)所表示的列的各數(shù)的和，出度就是個(gè)點(diǎn)所表示的行的各數(shù)的和。
下圖就是采用鄰接矩陣表示的帶權(quán)有向圖。
注意，邊二維數(shù)組中的數(shù)字表示權(quán)，沒有關(guān)系的頂點(diǎn)（沒有權(quán))使用”/”表示。
鄰接表（Adjacency List）：采用數(shù)組和鏈表存儲(chǔ)，一個(gè)數(shù)組存儲(chǔ)頂點(diǎn)，同時(shí)頂點(diǎn)想外拉出鏈表表示邊或者弧，鏈表稱為邊表，如度的邊表稱為入邊表，出度的邊表稱為出邊表。鄰接表的實(shí)現(xiàn)只關(guān)心存在的邊，不關(guān)心不存在的邊，因此沒有空間浪費(fèi)。
下圖就是采用鄰接表表示的無向圖。
下圖就是采用鄰接表表示的有向圖。
下圖就是采用鄰接矩陣表示的帶權(quán)有向圖。
鄰接表在表示稀疏圖時(shí)非常緊湊而成為了通常的選擇，相比之下，如果在稀疏圖表示時(shí)使用鄰接矩陣，會(huì)浪費(fèi)很多內(nèi)存空間，遍歷的時(shí)候也會(huì)增加開銷。如果圖是稠密圖，鄰接表的優(yōu)勢(shì)就不明顯了，那么就可以選擇更加方便的鄰接矩陣。
深度優(yōu)先遍歷（Depth First Search），也有稱為深度優(yōu)先搜索，簡(jiǎn)稱為DFS。類似于樹的先序遍歷。基本思想是“一條路走到黑”，然后往回退，回退過程中如果遇到?jīng)]探索過的支路，就進(jìn)入該支路繼續(xù)深入，直到所有頂點(diǎn)都被訪問到。
假設(shè)初始狀態(tài)是圖中所有頂點(diǎn)均未被訪問，則從某個(gè)頂點(diǎn)v出發(fā)，首先訪問該頂點(diǎn)，然后依次從它的各個(gè)未被訪問的鄰接點(diǎn)出發(fā)深度優(yōu)先搜索遍歷圖，直至圖中所有和v有路徑相通的頂點(diǎn)都被訪問到。但此時(shí)還有可能有其他分支我們沒有訪問到，若此時(shí)尚有其他頂點(diǎn)未被訪問到，需要回溯，另選一個(gè)未被訪問的頂點(diǎn)作起始點(diǎn)，重復(fù)上述過程，直至圖中所有頂點(diǎn)都被訪問到為止。顯然，深度優(yōu)先搜索是一個(gè)遞歸的過程。
對(duì)如下左邊無向圖從0頂點(diǎn)開始進(jìn)行深度優(yōu)先遍歷之后一種結(jié)果為：0、1、4、5、3、2，如右圖。
從起始點(diǎn)0開始遍歷，在訪問了0后，選擇其鄰接點(diǎn)1。因?yàn)?未曾訪問過，則從1出發(fā)進(jìn)行深度優(yōu)先遍歷。依次類推，接著從4、5、3出發(fā)進(jìn)行遍歷。在訪問了3后，由于3的鄰接點(diǎn)都已被訪問，則遍歷回退到5。此時(shí)5的另一個(gè)鄰接點(diǎn)2未被訪問，則遍歷又從5到2,再繼續(xù)進(jìn)行下去，于是得到節(jié)點(diǎn)的線性順序?yàn)椋?、1、4、5、3、2，如右圖中紅色箭頭線為其深度優(yōu)先遍歷順序。
對(duì)如下左邊有向圖從0頂點(diǎn)開始進(jìn)行深度優(yōu)先遍歷之后一種結(jié)果為：0、1、4、2、5、3，如右圖。
有向圖的深度優(yōu)先遍歷頂點(diǎn)的領(lǐng)邊需要考慮頂點(diǎn)的出度對(duì)應(yīng)的頂點(diǎn)。該頂點(diǎn)的出度對(duì)應(yīng)的頂點(diǎn)算作鄰接點(diǎn)。
從起始點(diǎn)0開始遍歷，在訪問了0后，選擇其出度鄰接點(diǎn)1、2。這里選擇1進(jìn)行訪問，從1出發(fā)進(jìn)行有向圖深度優(yōu)先遍歷。依次類推，在訪問了4后，由于4的出度鄰接點(diǎn)0、1都已被訪問，則遍歷回退直到0。此時(shí)0的另一個(gè)鄰接點(diǎn)2未被訪問，則遍歷又從0到2,再繼續(xù)進(jìn)行下去，于是得到節(jié)點(diǎn)的線性順序?yàn)椋?、1、4、2、5、4，如右圖中紅色箭頭線為有向圖深度優(yōu)先遍歷順序。
廣度優(yōu)先遍歷(Depth First Search) ，也有稱為廣度優(yōu)先搜索，簡(jiǎn)稱BFS，類似于樹的層序遍歷?；舅枷胧潜M最大程度輻射能夠覆蓋的節(jié)點(diǎn)，并對(duì)其進(jìn)行訪問。
從圖中某頂點(diǎn)v出發(fā)，在訪問了v之后依次訪問v的各個(gè)未曾訪問過的鄰接點(diǎn)，然后分別從這些鄰接點(diǎn)出發(fā)依次訪問它們的鄰接點(diǎn)，并使得“先被訪問的頂點(diǎn)的鄰接點(diǎn)先于后被訪問的頂點(diǎn)的鄰接點(diǎn)被訪問，直至圖中所有已被訪問的頂點(diǎn)的鄰接點(diǎn)都被訪問到。如果此時(shí)圖中尚有頂點(diǎn)未被訪問，則需要另選一個(gè)未曾被訪問過的頂點(diǎn)作為新的起始點(diǎn)，重復(fù)上述過程，直至圖中所有頂點(diǎn)都被訪問到為止。換句話說，廣度優(yōu)先搜索遍歷圖的過程是以v為起點(diǎn)，由近至遠(yuǎn)。
對(duì)如下左邊無向圖從0頂點(diǎn)開始進(jìn)行深度優(yōu)先遍歷之后一種結(jié)果為：0、1、2、3、4、5，如右圖。
從起始點(diǎn)0開始遍歷，在訪問了0后，尋找鄰接點(diǎn)，找到了1、2、3，一次遍歷，訪問完1、2、3之后，再依次訪問它們的鄰接點(diǎn)。首先訪問1的鄰接點(diǎn)4，再訪問2的鄰接點(diǎn)5。因此訪問順序是：0、1、2、3、4、5。
對(duì)如下左邊有向圖從0頂點(diǎn)開始進(jìn)行廣度優(yōu)先遍歷之后一種結(jié)果為：0、1、2、4、5、3，如右圖。
有向圖的廣度優(yōu)先遍歷頂點(diǎn)的領(lǐng)邊同樣需要考慮頂點(diǎn)的出度對(duì)應(yīng)的頂點(diǎn)。該頂點(diǎn)的出度對(duì)應(yīng)的頂點(diǎn)算作鄰接點(diǎn)。
從起始點(diǎn)0開始遍歷，在訪問了0后，選擇其出度鄰接點(diǎn)1、2，然后訪問1、2；訪問完1,2之后，再依次訪問它們的鄰接點(diǎn)。首先訪問1的鄰接點(diǎn)4依次類推，再訪問2的鄰接點(diǎn)5。訪問完5之后，再依次訪問它們的鄰接點(diǎn)，最后訪問5的鄰接點(diǎn)3。此時(shí)所有頂點(diǎn)訪問完畢。因此訪問順序是：0、1、2、4、5、3。
關(guān)于圖的實(shí)現(xiàn)，Guava中的com.google.common.graph模塊已經(jīng)提供了圖的各種實(shí)現(xiàn)，而且都非常完美，這里只提供四個(gè)簡(jiǎn)單實(shí)現(xiàn)。帶權(quán)重的圖的實(shí)現(xiàn)，將在后面的最小生成樹和最短路徑部分提供實(shí)現(xiàn)。
/**
* 無向圖鄰接鏈表簡(jiǎn)單實(shí)現(xiàn)
* {@link UndirectedAdjacencyList#UndirectedAdjacencyList(E[], E[][])} 構(gòu)建無向圖
* {@link UndirectedAdjacencyList#DFS()} 深度優(yōu)先遍歷無向圖
* {@link UndirectedAdjacencyList#BFS()} 廣度優(yōu)先遍歷無向圖
* {@link UndirectedAdjacencyList#toString()} ()} 輸出無向圖
*
* @author lx
*/
public class UndirectedAdjacencyList<E> {
/**
* 頂點(diǎn)類
*
* @param <E>
*/
private class Node<E> {
/**
* 頂點(diǎn)信息
*/
E data;
/**
* 指向第一條依附該頂點(diǎn)的邊
*/
LNode firstEdge;
public Node(E data, LNode firstEdge) {
this.data = data;
this.firstEdge = firstEdge;
}
}
/**
* 邊表節(jié)點(diǎn)類
*/
private class LNode {
/**
* 該邊所指向的頂點(diǎn)的索引位置
*/
int vertex;
/**
* 指向下一條邊的指針
*/
LNode nextEdge;
}
/**
* 頂點(diǎn)數(shù)組
*/
private Node<E>[] vertexs;
/**
* 創(chuàng)建圖
*
* @param vexs 頂點(diǎn)數(shù)組
* @param edges 邊二維數(shù)組
*/
public UndirectedAdjacencyList(E[] vexs, E[][] edges) {
/*初始化頂點(diǎn)數(shù)組,并添加頂點(diǎn)*/
vertexs = new Node[vexs.length];
for (int i = 0; i < vertexs.length; i++) {
vertexs[i] = new Node<>(vexs[i], null);
}
/*初始化邊表,并添加邊節(jié)點(diǎn)到邊表尾部,即采用尾插法*/
for (E[] edge : edges) {
// 讀取一條邊的起始頂點(diǎn)和結(jié)束頂點(diǎn)索引值
int p1 = getPosition(edge[0]);
int p2 = getPosition(edge[1]);
/*這里需要相互添加邊節(jié)點(diǎn),無向圖可以看作相互可達(dá)的有向圖*/
// 初始化lnode1邊節(jié)點(diǎn)
LNode lnode1 = new LNode();
lnode1.vertex = p2;
// 將LNode鏈接到"p1所在鏈表的末尾"
if (vertexs[p1].firstEdge == null) {
vertexs[p1].firstEdge = lnode1;
} else {
linkLast(vertexs[p1].firstEdge, lnode1);
}
// 初始化lnode2邊節(jié)點(diǎn)
LNode lnode2 = new LNode();
lnode2.vertex = p1;
// 將lnode2鏈接到"p2所在鏈表的末尾"
if (vertexs[p2].firstEdge == null) {
vertexs[p2].firstEdge = lnode2;
} else {
linkLast(vertexs[p2].firstEdge, lnode2);
}
}
}
/**
* 獲取某條邊的某個(gè)頂點(diǎn)所在頂點(diǎn)數(shù)組的索引位置
*
* @param e 頂點(diǎn)的值
* @return 所在頂點(diǎn)數(shù)組的索引位置, 或者-1 - 表示不存在
*/
private int getPosition(E e) {
for (int i = 0; i < vertexs.length; i++) {
if (vertexs[i].data == e) {
return i;
}
}
return -1;
}
/**
* 將lnode節(jié)點(diǎn)鏈接到邊表的最后,采用尾插法
*
* @param first 邊表頭結(jié)點(diǎn)
* @param node 將要添加的節(jié)點(diǎn)
*/
private void linkLast(LNode first, LNode node) {
while (true) {
if (first.vertex == node.vertex) {
return;
}
if (first.nextEdge == null) {
break;
}
first = first.nextEdge;
}
first.nextEdge = node;
}
/**
* 深度優(yōu)先搜索遍歷圖的遞歸實(shí)現(xiàn),類似于樹的先序遍歷
* 因此模仿樹的先序遍歷,同樣借用棧結(jié)構(gòu),這里使用的是方法的遞歸,隱式的借用棧
*
* @param i 頂點(diǎn)索引
* @param visited 訪問標(biāo)志數(shù)組
*/
private void DFS(int i, boolean[] visited) {
//索引索引標(biāo)記為true ,表示已經(jīng)訪問了
visited[i] = true;
System.out.print(vertexs[i].data + " ");
//獲取該頂點(diǎn)的邊表頭結(jié)點(diǎn)
LNode node = vertexs[i].firstEdge;
//循環(huán)遍歷該頂點(diǎn)的鄰接點(diǎn),采用同樣的方式遞歸搜索
while (node != null) {
if (!visited[node.vertex]) {
DFS(node.vertex, visited);
}
node = node.nextEdge;
}
}
/**
* 深度優(yōu)先搜索遍歷圖,類似于樹的前序遍歷,
*/
public void DFS() {
//新建頂點(diǎn)訪問標(biāo)記數(shù)組,對(duì)應(yīng)每個(gè)索引對(duì)應(yīng)相同索引的頂點(diǎn)數(shù)組中的頂點(diǎn)
boolean[] visited = new boolean[vertexs.length];
//初始化所有頂點(diǎn)都沒有被訪問
for (int i = 0; i < vertexs.length; i++) {
visited[i] = false;
}
System.out.println("DFS: ");
/*循環(huán)搜索*/
for (int i = 0; i < vertexs.length; i++) {
//如果對(duì)應(yīng)索引的頂點(diǎn)的訪問標(biāo)記為false,則搜索該頂點(diǎn)
if (!visited[i]) {
DFS(i, visited);
}
}
/*走到這一步,說明頂點(diǎn)訪問標(biāo)記數(shù)組全部為true,說明全部都訪問到了,深度搜索結(jié)束*/
System.out.println();
}
/**
* 廣度優(yōu)先搜索圖,類似于樹的層序遍歷
* 因此模仿樹的層序遍歷,同樣借用隊(duì)列結(jié)構(gòu)
*/
public void BFS() {
// 輔組隊(duì)列
Queue<Integer> indexLinkedList = new LinkedList<>();
//新建頂點(diǎn)訪問標(biāo)記數(shù)組,對(duì)應(yīng)每個(gè)索引對(duì)應(yīng)相同索引的頂點(diǎn)數(shù)組中的頂點(diǎn)
boolean[] visited = new boolean[vertexs.length];
//初始化所有頂點(diǎn)都沒有被訪問
for (int i = 0; i < vertexs.length; i++) {
visited[i] = false;
}
System.out.println("BFS: ");
for (int i = 0; i < vertexs.length; i++) {
//如果訪問方劑為false,則設(shè)置為true,表示已經(jīng)訪問,然后開始訪問
if (!visited[i]) {
visited[i] = true;
System.out.print(vertexs[i].data + " ");
indexLinkedList.add(i);
}
//判斷隊(duì)列是否有值,有就開始遍歷
if (!indexLinkedList.isEmpty()) {
//出隊(duì)列
Integer j = indexLinkedList.poll();
LNode node = vertexs[j].firstEdge;
while (node != null) {
int k = node.vertex;
if (!visited[k]) {
visited[k] = true;
System.out.print(vertexs[k].data + " ");
//繼續(xù)入隊(duì)列
indexLinkedList.add(k);
}
node = node.nextEdge;
}
}
}
System.out.print("\n");
}
@Override
public String toString() {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < vertexs.length; i++) {
stringBuilder.append(i).append("(").append(vertexs[i].data).append("): ");
LNode node = vertexs[i].firstEdge;
while (node != null) {
stringBuilder.append(node.vertex).append("(").append(vertexs[node.vertex].data).append(")");
node = node.nextEdge;
if (node != null) {
stringBuilder.append("->");
} else {
break;
}
}
stringBuilder.append("\n");
}
return stringBuilder.toString();
}
public static void main(String[] args) {
//頂點(diǎn)數(shù)組 添加的先后順序?qū)τ诒闅v結(jié)果有影響
Character[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
//邊二維數(shù)組 添加的先后順序?qū)τ诒闅v結(jié)果有影響
Character[][] edges = {
{'A', 'C'},
//對(duì)于無向圖來說是多余的邊關(guān)系,在linkLast方法中做了判斷,并不會(huì)重復(fù)添加
{'A', 'D'},
{'A', 'D'},
{'D', 'A'},
{'A', 'F'},
{'B', 'C'},
{'C', 'D'},
{'E', 'G'},
{'E', 'B'},
{'D', 'B'},
{'F', 'G'}};
//構(gòu)建圖
UndirectedAdjacencyList<Character> undirectedAdjacencyList = new UndirectedAdjacencyList<>(vexs, edges);
//輸出圖
System.out.println(undirectedAdjacencyList);
//深度優(yōu)先遍歷
undirectedAdjacencyList.DFS();
//廣度優(yōu)先遍歷
undirectedAdjacencyList.BFS();
}
}測(cè)試無向圖對(duì)應(yīng)的邏輯結(jié)構(gòu)如下：
測(cè)試圖的遍歷結(jié)果如下：
/**
* 有向圖鄰接鏈表簡(jiǎn)單實(shí)現(xiàn)
* {@link AdjacencyList#AdjacencyList(E[], E[][])} 構(gòu)建有向圖
* {@link AdjacencyList#DFS()} 深度優(yōu)先遍歷有向圖
* {@link AdjacencyList#BFS()} 廣度優(yōu)先遍歷有向圖
* {@link AdjacencyList#toString()} ()} 輸出有向圖
*
* @author lx
*/
public class AdjacencyList<E> {
/**
* 頂點(diǎn)類
*
* @param <E>
*/
private class Node<E> {
/**
* 頂點(diǎn)信息
*/
E data;
/**
* 指向第一條依附該頂點(diǎn)的邊
*/
LNode firstEdge;
public Node(E data, LNode firstEdge) {
this.data = data;
this.firstEdge = firstEdge;
}
}
/**
* 邊表節(jié)點(diǎn)類
*/
private class LNode {
/**
* 該邊所指向的頂點(diǎn)的索引位置
*/
int vertex;
/**
* 指向下一條弧的指針
*/
LNode nextEdge;
}
/**
* 頂點(diǎn)數(shù)組
*/
private Node<E>[] vertexs;
/**
* 創(chuàng)建圖
*
* @param vexs 頂點(diǎn)數(shù)組
* @param edges 邊二維數(shù)組
*/
public AdjacencyList(E[] vexs, E[][] edges) {
/*初始化頂點(diǎn)數(shù)組,并添加頂點(diǎn)*/
vertexs = new Node[vexs.length];
for (int i = 0; i < vertexs.length; i++) {
vertexs[i] = new Node<>(vexs[i], null);
}
/*初始化邊表,并添加邊節(jié)點(diǎn)到邊表尾部,即采用尾插法*/
for (E[] edge : edges) {
// 讀取一條邊的起始頂點(diǎn)和結(jié)束頂點(diǎn)索引值
int p1 = getPosition(edge[0]);
int p2 = getPosition(edge[1]);
// 初始化lnode1邊節(jié)點(diǎn) 即表示p1指向p2的邊
LNode lnode1 = new LNode();
lnode1.vertex = p2;
// 將LNode鏈接到"p1所在鏈表的末尾"
if (vertexs[p1].firstEdge == null) {
vertexs[p1].firstEdge = lnode1;
} else {
linkLast(vertexs[p1].firstEdge, lnode1);
}
}
}
/**
* 獲取某條邊的某個(gè)頂點(diǎn)所在頂點(diǎn)數(shù)組的索引位置
*
* @param e 頂點(diǎn)的值
* @return 所在頂點(diǎn)數(shù)組的索引位置, 或者-1 - 表示不存在
*/
private int getPosition(E e) {
for (int i = 0; i < vertexs.length; i++) {
if (vertexs[i].data == e) {
return i;
}
}
return -1;
}
/**
* 將lnode節(jié)點(diǎn)鏈接到邊表的最后,采用尾插法
*
* @param first 邊表頭結(jié)點(diǎn)
* @param node 將要添加的節(jié)點(diǎn)
*/
private void linkLast(LNode first, LNode node) {
while (true) {
if (first.vertex == node.vertex) {
return;
}
if (first.nextEdge == null) {
break;
}
first = first.nextEdge;
}
first.nextEdge = node;
}
/**
* 深度優(yōu)先搜索遍歷圖的遞歸實(shí)現(xiàn),類似于樹的先序遍歷
* 因此模仿樹的先序遍歷,同樣借用棧結(jié)構(gòu),這里使用的是方法的遞歸,隱式的借用棧
*
* @param i 頂點(diǎn)索引
* @param visited 訪問標(biāo)志數(shù)組
*/
private void DFS(int i, boolean[] visited) {
//索引索引標(biāo)記為true ,表示已經(jīng)訪問了
visited[i] = true;
System.out.print(vertexs[i].data + " ");
//獲取該頂點(diǎn)的邊表頭結(jié)點(diǎn)
LNode node = vertexs[i].firstEdge;
//循環(huán)遍歷該頂點(diǎn)的鄰接點(diǎn),采用同樣的方式遞歸搜索
while (node != null) {
if (!visited[node.vertex]) {
DFS(node.vertex, visited);
}
node = node.nextEdge;
}
}
/**
* 深度優(yōu)先搜索遍歷圖,類似于樹的前序遍歷,
*/
public void DFS() {
//新建頂點(diǎn)訪問標(biāo)記數(shù)組,對(duì)應(yīng)每個(gè)索引對(duì)應(yīng)相同索引的頂點(diǎn)數(shù)組中的頂點(diǎn)
boolean[] visited = new boolean[vertexs.length];
//初始化所有頂點(diǎn)都沒有被訪問
for (int i = 0; i < vertexs.length; i++) {
visited[i] = false;
}
System.out.println("DFS: ");
/*循環(huán)搜索*/
for (int i = 0; i < vertexs.length; i++) {
//如果對(duì)應(yīng)索引的頂點(diǎn)的訪問標(biāo)記為false,則搜索該頂點(diǎn)
if (!visited[i]) {
DFS(i, visited);
}
}
/*走到這一步,說明頂點(diǎn)訪問標(biāo)記數(shù)組全部為true,說明全部都訪問到了,深度搜索結(jié)束*/
System.out.println();
}
/**
* 廣度優(yōu)先搜索圖,類似于樹的層序遍歷
* 因此模仿樹的層序遍歷,同樣借用隊(duì)列結(jié)構(gòu)
*/
public void BFS() {
// 輔組隊(duì)列
Queue<Integer> indexLinkedList = new LinkedList<>();
//新建頂點(diǎn)訪問標(biāo)記數(shù)組,對(duì)應(yīng)每個(gè)索引對(duì)應(yīng)相同索引的頂點(diǎn)數(shù)組中的頂點(diǎn)
boolean[] visited = new boolean[vertexs.length];
//初始化所有頂點(diǎn)都沒有被訪問
for (int i = 0; i < vertexs.length; i++) {
visited[i] = false;
}
System.out.println("BFS: ");
for (int i = 0; i < vertexs.length; i++) {
//如果訪問方劑為false,則設(shè)置為true,表示已經(jīng)訪問,然后開始訪問
if (!visited[i]) {
visited[i] = true;
System.out.print(vertexs[i].data + " ");
indexLinkedList.add(i);
}
//判斷隊(duì)列是否有值,有就開始遍歷
if (!indexLinkedList.isEmpty()) {
//出隊(duì)列
Integer j = indexLinkedList.poll();
LNode node = vertexs[j].firstEdge;
while (node != null) {
int k = node.vertex;
if (!visited[k]) {
visited[k] = true;
System.out.print(vertexs[k].data + " ");
//繼續(xù)入隊(duì)列
indexLinkedList.add(k);
}
node = node.nextEdge;
}
}
}
System.out.println("\n");
}
@Override
public String toString() {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < vertexs.length; i++) {
stringBuilder.append(i).append("(").append(vertexs[i].data).append("): ");
LNode node = vertexs[i].firstEdge;
while (node != null) {
stringBuilder.append(node.vertex).append("(").append(vertexs[node.vertex].data).append(")");
node = node.nextEdge;
if (node != null) {
stringBuilder.append("->");
} else {
break;
}
}
stringBuilder.append("\n");
}
return stringBuilder.toString();
}
public static void main(String[] args) {
//頂點(diǎn)數(shù)組 添加的先后順序?qū)τ诒闅v結(jié)果有影響
Character[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
//邊二維數(shù)組 {'a', 'b'}表示頂點(diǎn)a->b的邊 添加的先后順序?qū)τ诒闅v結(jié)果有影響
Character[][] edges = {
{'A', 'C'},
{'A', 'D'},
//對(duì)于有向圖來說是多余的邊關(guān)系,在linkLast方法中做了判斷,并不會(huì)重復(fù)添加
{'A', 'D'},
//對(duì)于有向圖來說不是多余的邊關(guān)系
{'D', 'A'},
{'A', 'F'},
{'B', 'C'},
{'C', 'D'},
{'E', 'G'},
{'E', 'B'},
{'D', 'B'},
{'F', 'G'}};
// 構(gòu)建圖有向圖
AdjacencyList<Character> adjacencyList = new AdjacencyList<>(vexs, edges);
//輸出圖
System.out.println(adjacencyList);
//深度優(yōu)先遍歷
adjacencyList.DFS();
//廣度優(yōu)先遍歷
adjacencyList.BFS();
}
}測(cè)試有向圖對(duì)應(yīng)的邏輯結(jié)構(gòu)如下：
測(cè)試圖的遍歷結(jié)果如下：
/**
* 無向圖鄰接矩陣簡(jiǎn)單實(shí)現(xiàn)
* {@link UndirectedAdjacencyMatrix#UndirectedAdjacencyMatrix(E[], E[][])} 構(gòu)建無向圖
* {@link UndirectedAdjacencyMatrix#DFS()} 深度優(yōu)先遍歷無向圖
* {@link UndirectedAdjacencyMatrix#BFS()} 廣度優(yōu)先遍歷無向圖
* {@link UndirectedAdjacencyMatrix#toString()} ()} 輸出無向圖
*
* @author lx
*/
public class UndirectedAdjacencyMatrix<E> {
/**
* 頂點(diǎn)數(shù)組
*/
private Object[] vertexs;
/**
* 鄰接矩陣
*/
private int[][] matrix;
/*
* 創(chuàng)建圖
*
* 參數(shù)說明：
* vexs -- 頂點(diǎn)數(shù)組
* edges -- 邊數(shù)組
*/
/**
* 創(chuàng)建無向圖
*
* @param vexs 頂點(diǎn)數(shù)組
* @param edges 邊二維數(shù)組
*/
public UndirectedAdjacencyMatrix(E[] vexs, E[][] edges) {
// 初始化頂點(diǎn)數(shù)組,并添加頂點(diǎn)
vertexs = Arrays.copyOf(vexs, vexs.length);
// 初始化邊矩陣,并填充邊信息
matrix = new int[vexs.length][vexs.length];
for (E[] edge : edges) {
// 讀取一條邊的起始頂點(diǎn)和結(jié)束頂點(diǎn)索引值
int p1 = getPosition(edge[0]);
int p2 = getPosition(edge[1]);
//對(duì)稱的兩個(gè)點(diǎn)位都置為1,無向圖可以看作相互可達(dá)的有向圖
matrix[p1][p2] = 1;
matrix[p2][p1] = 1;
}
}
/**
* 獲取某條邊的某個(gè)頂點(diǎn)所在頂點(diǎn)數(shù)組的索引位置
*
* @param e 頂點(diǎn)的值
* @return 所在頂點(diǎn)數(shù)組的索引位置, 或者-1 - 表示不存在
*/
private int getPosition(E e) {
for (int i = 0; i < vertexs.length; i++) {
if (vertexs[i] == e) {
return i;
}
}
return -1;
}
/**
* 深度優(yōu)先搜索遍歷圖,類似于樹的前序遍歷,
*/
public void DFS() {
//新建頂點(diǎn)訪問標(biāo)記數(shù)組,對(duì)應(yīng)每個(gè)索引對(duì)應(yīng)相同索引的頂點(diǎn)數(shù)組中的頂點(diǎn)
boolean[] visited = new boolean[vertexs.length];
//初始化所有頂點(diǎn)都沒有被訪問
for (int i = 0; i < vertexs.length; i++) {
visited[i] = false;
}
System.out.println("DFS: ");
for (int i = 0; i < vertexs.length; i++) {
if (!visited[i]) {
DFS(i, visited);
}
}
System.out.println();
}
/**
* 深度優(yōu)先搜索遍歷圖的遞歸實(shí)現(xiàn),類似于樹的先序遍歷
* 因此模仿樹的先序遍歷,同樣借用棧結(jié)構(gòu),這里使用的是方法的遞歸,隱式的借用棧
*
* @param i 頂點(diǎn)索引
* @param visited 訪問標(biāo)志數(shù)組
*/
private void DFS(int i, boolean[] visited) {
visited[i] = true;
System.out.print(vertexs[i] + " ");
// 遍歷該頂點(diǎn)的所有鄰接點(diǎn)。若該鄰接點(diǎn)是沒有訪問過，那么繼續(xù)遞歸遍歷領(lǐng)接點(diǎn)
for (int w = firstVertex(i); w >= 0; w = nextVertex(i, w)) {
if (!visited[w]) {
DFS(w, visited);
}
}
}
/**
* 返回頂點(diǎn)v的第一個(gè)鄰接頂點(diǎn)的索引，失敗則返回-1
*
* @param v 頂點(diǎn)v在數(shù)組中的索引
* @return 返回頂點(diǎn)v的第一個(gè)鄰接頂點(diǎn)的索引，失敗則返回-1
*/
private int firstVertex(int v) {
//如果索引超出范圍,則返回-1
if (v < 0 || v > (vertexs.length - 1)) {
return -1;
}
/*根據(jù)鄰接矩陣的規(guī)律:頂點(diǎn)索引v對(duì)應(yīng)著邊二維矩陣的matrix[v][i]一行記錄
* 從i=0開始*/
for (int i = 0; i < vertexs.length; i++) {
if (matrix[v][i] == 1) {
return i;
}
}
return -1;
}
/**
* 返回頂點(diǎn)v相對(duì)于w的下一個(gè)鄰接頂點(diǎn)的索引，失敗則返回-1
*
* @param v 頂點(diǎn)索引
* @param w 第一個(gè)鄰接點(diǎn)索引
* @return 返回頂點(diǎn)v相對(duì)于w的下一個(gè)鄰接頂點(diǎn)的索引，失敗則返回-1
*/
private int nextVertex(int v, int w) {
//如果索引超出范圍,則返回-1
if (v < 0 || v > (vertexs.length - 1) || w < 0 || w > (vertexs.length - 1)) {
return -1;
}
/*根據(jù)鄰接矩陣的規(guī)律:頂點(diǎn)索引v對(duì)應(yīng)著邊二維矩陣的matrix[v][i]一行記錄
* 由于鄰接點(diǎn)w的索引已經(jīng)獲取了,所以從i=w+1開始尋找*/
for (int i = w + 1; i < vertexs.length; i++) {
if (matrix[v][i] == 1) {
return i;
}
}
return -1;
}
/*
* 廣度優(yōu)先搜索（類似于樹的層次遍歷）
*/
public void BFS() {
// 輔組隊(duì)列
Queue<Integer> indexLinkedList = new LinkedList<>();
//新建頂點(diǎn)訪問標(biāo)記數(shù)組,對(duì)應(yīng)每個(gè)索引對(duì)應(yīng)相同索引的頂點(diǎn)數(shù)組中的頂點(diǎn)
boolean[] visited = new boolean[vertexs.length];
for (int i = 0; i < vertexs.length; i++) {
visited[i] = false;
}
System.out.println("BFS: ");
for (int i = 0; i < vertexs.length; i++) {
if (!visited[i]) {
visited[i] = true;
System.out.print(vertexs[i] + " ");
indexLinkedList.add(i);
}
if (!indexLinkedList.isEmpty()) {
//j索引出隊(duì)列
Integer j = indexLinkedList.poll();
//繼續(xù)訪問j的鄰接點(diǎn)
for (int k = firstVertex(j); k >= 0; k = nextVertex(j, k)) {
if (!visited[k]) {
visited[k] = true;
System.out.print(vertexs[k] + " ");
//繼續(xù)入隊(duì)列
indexLinkedList.add(k);
}
}
}
}
System.out.println();
}
@Override
public String toString() {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < vertexs.length; i++) {
for (int j = 0; j < vertexs.length; j++) {
stringBuilder.append(matrix[i][j]).append(" ");
}
stringBuilder.append("\n");
}
return stringBuilder.toString();
}
public static void main(String[] args) {
Character[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
Character[][] edges = {
{'A', 'C'},
//對(duì)于無向圖來說是多余的邊關(guān)系,在linkLast方法中做了判斷,并不會(huì)重復(fù)添加
{'A', 'D'},
{'A', 'D'},
{'D', 'A'},
{'A', 'F'},
{'B', 'C'},
{'C', 'D'},
{'E', 'G'},
{'E', 'B'},
{'D', 'B'},
{'F', 'G'}};
//構(gòu)建圖
UndirectedAdjacencyMatrix<Character> undirectedAdjacencyMatrix = new UndirectedAdjacencyMatrix<>(vexs, edges);
//輸出圖
System.out.println(undirectedAdjacencyMatrix);
//深度優(yōu)先遍歷
undirectedAdjacencyMatrix.DFS();
//廣度優(yōu)先遍歷
undirectedAdjacencyMatrix.BFS();
}
}測(cè)試無向圖對(duì)應(yīng)的邏輯結(jié)構(gòu)如下：
測(cè)試圖的遍歷結(jié)果如下：
可以看到，深度優(yōu)先遍歷出來的順序不一致，實(shí)際上這是內(nèi)部節(jié)點(diǎn)的實(shí)際存儲(chǔ)順序和結(jié)構(gòu)的問題導(dǎo)致的，但是我們的思想并沒有變，因此該遍歷也是正確的，實(shí)際上如果圖的實(shí)現(xiàn)不唯一，那么遍歷順序也不一定是唯一的。
/**
* 有向圖鄰接矩陣簡(jiǎn)單實(shí)現(xiàn)
* {@link AdjacencyMatrix#AdjacencyMatrix(E[], E[][])} 構(gòu)建有向圖
* {@link AdjacencyMatrix#DFS()} 深度優(yōu)先遍歷無向圖
* {@link AdjacencyMatrix#BFS()} 廣度優(yōu)先遍歷無向圖
* {@link AdjacencyMatrix#toString()} ()} 輸出無向圖
*
* @author lx
*/
public class AdjacencyMatrix<E> {
/**
* 頂點(diǎn)數(shù)組
*/
private Object[] vertexs;
/**
* 鄰接矩陣
*/
private int[][] matrix;
/**
* 創(chuàng)建有向圖
*
* @param vexs 頂點(diǎn)數(shù)組
* @param edges 邊二維數(shù)組
*/
public AdjacencyMatrix(E[] vexs, E[][] edges) {
// 初始化頂點(diǎn)數(shù)組,并添加頂點(diǎn)
vertexs = Arrays.copyOf(vexs, vexs.length);
// 初始化邊矩陣,并填充邊信息
matrix = new int[vexs.length][vexs.length];
for (E[] edge : edges) {
// 讀取一條邊的起始頂點(diǎn)和結(jié)束頂點(diǎn)索引值 p1,p2表示邊方向p1->p2
int p1 = getPosition(edge[0]);
int p2 = getPosition(edge[1]);
//p1 出度的位置 置為1
matrix[p1][p2] = 1;
//無向圖和有向圖的鄰接矩陣實(shí)現(xiàn)的區(qū)別就在于下面這一行代碼
//matrix[p2][p1] = 1;
}
}
/**
* 獲取某條邊的某個(gè)頂點(diǎn)所在頂點(diǎn)數(shù)組的索引位置
*
* @param e 頂點(diǎn)的值
* @return 所在頂點(diǎn)數(shù)組的索引位置, 或者-1 - 表示不存在
*/
private int getPosition(E e) {
for (int i = 0; i < vertexs.length; i++) {
if (vertexs[i] == e) {
return i;
}
}
return -1;
}
/**
* 深度優(yōu)先搜索遍歷圖,類似于樹的前序遍歷,
*/
public void DFS() {
//新建頂點(diǎn)訪問標(biāo)記數(shù)組,對(duì)應(yīng)每個(gè)索引對(duì)應(yīng)相同索引的頂點(diǎn)數(shù)組中的頂點(diǎn)
boolean[] visited = new boolean[vertexs.length];
//初始化所有頂點(diǎn)都沒有被訪問
for (int i = 0; i < vertexs.length; i++) {
visited[i] = false;
}
System.out.println("DFS: ");
for (int i = 0; i < vertexs.length; i++) {
if (!visited[i]) {
DFS(i, visited);
}
}
System.out.println();
}
/**
* 深度優(yōu)先搜索遍歷圖的遞歸實(shí)現(xiàn),類似于樹的先序遍歷
* 因此模仿樹的先序遍歷,同樣借用棧結(jié)構(gòu),這里使用的是方法的遞歸,隱式的借用棧
*
* @param i 頂點(diǎn)索引
* @param visited 訪問標(biāo)志數(shù)組
*/
private void DFS(int i, boolean[] visited) {
visited[i] = true;
System.out.print(vertexs[i] + " ");
// 遍歷該頂點(diǎn)的所有鄰接點(diǎn)。若該鄰接點(diǎn)是沒有訪問過，那么繼續(xù)遞歸遍歷領(lǐng)接點(diǎn)
for (int w = firstVertex(i); w >= 0; w = nextVertex(i, w)) {
if (!visited[w]) {
DFS(w, visited);
}
}
}
/**
* 返回頂點(diǎn)v的第一個(gè)鄰接頂點(diǎn)的索引，失敗則返回-1
*
* @param v 頂點(diǎn)v在數(shù)組中的索引
* @return 返回頂點(diǎn)v的第一個(gè)鄰接頂點(diǎn)的索引，失敗則返回-1
*/
private int firstVertex(int v) {
//如果索引超出范圍,則返回-1
if (v < 0 || v > (vertexs.length - 1)) {
return -1;
}
/*根據(jù)鄰接矩陣的規(guī)律:頂點(diǎn)索引v對(duì)應(yīng)著邊二維矩陣的matrix[v][i]一行記錄
* 從i=0開始*/
for (int i = 0; i < vertexs.length; i++) {
if (matrix[v][i] == 1) {
return i;
}
}
return -1;
}
/**
* 返回頂點(diǎn)v相對(duì)于w的下一個(gè)鄰接頂點(diǎn)的索引，失敗則返回-1
*
* @param v 頂點(diǎn)索引
* @param w 第一個(gè)鄰接點(diǎn)索引
* @return 返回頂點(diǎn)v相對(duì)于w的下一個(gè)鄰接頂點(diǎn)的索引，失敗則返回-1
*/
private int nextVertex(int v, int w) {
//如果索引超出范圍,則返回-1
if (v < 0 || v > (vertexs.length - 1) || w < 0 || w > (vertexs.length - 1)) {
return -1;
}
/*根據(jù)鄰接矩陣的規(guī)律:頂點(diǎn)索引v對(duì)應(yīng)著邊二維矩陣的matrix[v][i]一行記錄
* 由于鄰接點(diǎn)w的索引已經(jīng)獲取了,所以從i=w+1開始尋找*/
for (int i = w + 1; i < vertexs.length; i++) {
if (matrix[v][i] == 1) {
return i;
}
}
return -1;
}
/*
* 廣度優(yōu)先搜索（類似于樹的層次遍歷）
*/
public void BFS() {
// 輔組隊(duì)列
Queue<Integer> indexLinkedList = new LinkedList<>();
//新建頂點(diǎn)訪問標(biāo)記數(shù)組,對(duì)應(yīng)每個(gè)索引對(duì)應(yīng)相同索引的頂點(diǎn)數(shù)組中的頂點(diǎn)
boolean[] visited = new boolean[vertexs.length];
for (int i = 0; i < vertexs.length; i++) {
visited[i] = false;
}
System.out.println("BFS: ");
for (int i = 0; i < vertexs.length; i++) {
if (!visited[i]) {
visited[i] = true;
System.out.print(vertexs[i] + " ");
indexLinkedList.add(i);
}
if (!indexLinkedList.isEmpty()) {
//j索引出隊(duì)列
Integer j = indexLinkedList.poll();
//繼續(xù)訪問j的鄰接點(diǎn)
for (int k = firstVertex(j); k >= 0; k = nextVertex(j, k)) {
if (!visited[k]) {
visited[k] = true;
System.out.print(vertexs[k] + " ");
//繼續(xù)入隊(duì)列
indexLinkedList.add(k);
}
}
}
}
System.out.println();
}
@Override
public String toString() {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < vertexs.length; i++) {
for (int j = 0; j < vertexs.length; j++) {
stringBuilder.append(matrix[i][j]).append(" ");
}
stringBuilder.append("\n");
}
return stringBuilder.toString();
}
public static void main(String[] args) {
Character[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
Character[][] edges = {
{'A', 'C'},
//對(duì)于無向圖來說是多余的邊關(guān)系,在linkLast方法中做了判斷,并不會(huì)重復(fù)添加
{'A', 'D'},
{'A', 'D'},
{'D', 'A'},
{'A', 'F'},
{'B', 'C'},
{'C', 'D'},
{'E', 'G'},
{'E', 'B'},
{'D', 'B'},
{'F', 'G'}};
//構(gòu)建圖
AdjacencyMatrix<Character> undirectedAdjacencyMatrix = new AdjacencyMatrix<>(vexs, edges);
//輸出圖
System.out.println(undirectedAdjacencyMatrix);
//深度優(yōu)先遍歷
undirectedAdjacencyMatrix.DFS();
//廣度優(yōu)先遍歷
undirectedAdjacencyMatrix.BFS();
}
}測(cè)試有向圖對(duì)應(yīng)的邏輯結(jié)構(gòu)以及遍歷結(jié)果和有向圖的鄰接表實(shí)現(xiàn)的結(jié)果是一致的。
首先介紹了圖的入門概念，然后介紹了圖的鄰接矩陣和鄰接表兩種存儲(chǔ)結(jié)構(gòu)、以及深度優(yōu)先遍歷和廣度優(yōu)先遍歷的兩種遍歷方式，最后提供了Java代碼的實(shí)現(xiàn)。
關(guān)于圖的實(shí)現(xiàn)，Guava中的com.google.common.graph模塊已經(jīng)提供了圖的各種實(shí)現(xiàn)，而且都非常完美，這里只提供四個(gè)簡(jiǎn)單實(shí)現(xiàn)。
Java是一門面向?qū)ο缶幊陶Z言，可以編寫桌面應(yīng)用程序、Web應(yīng)用程序、分布式系統(tǒng)和嵌入式系統(tǒng)應(yīng)用程序。
感謝大家的閱讀，以上就是“Java數(shù)據(jù)結(jié)構(gòu)中圖的原理與實(shí)現(xiàn)是怎樣的”的全部?jī)?nèi)容了，學(xué)會(huì)的朋友趕緊操作起來吧。相信億速云小編一定會(huì)給大家?guī)砀鼉?yōu)質(zhì)的文章。謝謝大家對(duì)億速云網(wǎng)站的支持！
免責(zé)聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如果涉及侵權(quán)請(qǐng)聯(lián)系站長(zhǎng)郵箱：is@yisu.com進(jìn)行舉報(bào)，并提供相關(guān)證據(jù)，一經(jīng)查實(shí)，將立刻刪除涉嫌侵權(quán)內(nèi)容。
億速云公眾號(hào)
手機(jī)網(wǎng)站二維碼