基於C中一個行壓縮圖的簡單實現代碼

首先簡單說一下什麼是行壓縮圖，其實嚴格意義上應該是行壓縮矩陣。正常情況下，矩陣是用二維數組簡單儲存的，但是如果是疏鬆陣列，也就是零很多的時候，這樣比較浪費空間。所以就有各種節省空間的儲存方式，三元組儲存就是其中一種。

什麼是三元組呢？一個三元組就是(row,col,value)，這樣把所有不為零的值組成一個向量。這種儲存方式比二維數組節省了不少空間，當然還可以進一步節省，因為三元組裡面row或者col重複儲存了，一行或者一列存一次就行了，按這種思路走下去就是行壓縮儲存了。

那具體什麼是行壓縮儲存呢？行壓縮儲存的思想就是，把所有不為零的值按行訪問的順序組成一個向量，然後再把每一行值不為0的列的下標存下來，這個兩個向量的大小和疏鬆陣列中不為0的值得個數相同，當然要實現對行壓縮矩陣的訪問，還要把每一行的不為0的列的下標在第二個向量中開始的位置存下來，有人把這個叫做指標。有了這三個向量就可以實現對矩陣實現高效的按行訪問了。行壓縮儲存比三元組優秀的不僅是空間的壓縮，還有就是行訪問時的高效。三元組如果是有序的，可以二分尋找來訪問一行，但是行壓縮儲存按行訪問時的時間複雜度是常數級的。 大家可以參考下面這個行壓縮矩陣：

可能你會有疑問，你明明實現的行壓縮圖，怎麼扯了這麼多行壓縮矩陣呢？其實圖和矩陣是等價的，矩陣的一行可以看做是圖一個節點的出邊，矩陣的一列可以看做圖一個節點的入邊。當然這裡需要滿足兩個條件：第一個就是圖節點編號必須是從0或者1開始的連續數值（這個可以通過對圖的節點做一次映射解決），第二個就是圖必須至少是弱連通的（非連通圖可以拆成連圖片）。實現了疏鬆陣列的高效儲存訪問，也就實現了圖的高效儲存訪問。

下面來說一下，我的實現。我的實現跟經典的行壓縮矩陣有兩個不同：第一個就是經典的行壓縮矩陣沒有考慮一行全為0的情況，我對這種情況做了處理（之所以處理當然不是因為我無聊，而是因為有這個需求）。第二個就是經典的行壓縮圖對按列訪問比較慢（當然是相對於按行訪問的速度而言），對行壓縮圖按列訪問時，時間複雜度是線性。我也對這種情況做了處理。

這裡簡單說一下我的思路：

第一個問題，我是通過將所有指標預設設為-1，即表示該行可能全為0，只有當有非零值時才設定為其正確的指標。當然訪問時也要做相應的處理。

第二個問題，我是這樣解決的。我按列壓縮儲存的方式，存了一份每一列不為0的行下標，以及每一列不為0的行下標開始的位置。這樣我的實現中就多了兩個向量，浪費了儲存空間，但是提高了按列訪問時的效率。

好了，talk is cheap，show me the code。下面是My Code（可能有錯，我只做了簡單的測試）

利用邊向量構造壓縮圖

複製代碼 代碼如下:/*
* buildGraph 利用邊向量 構造壓縮圖
* 對邊分別按第一個頂點、第二個頂點排序
* 然後分別按行壓縮圖和列壓縮圖構造行、列索引和指標
* 全零行和全零列,指標置為-1
*/
private void buildGraph(Vector<Edge> edges) {
int edgeSize = edges.size();
weight = new Vector<Float>(edgeSize);
rowIndex = new Vector<Integer>(edgeSize);
rowPtr = new Vector<Integer>(nodeCount + 1);
colIndex = new Vector<Integer>(edgeSize);
colPtr = new Vector<Integer>(nodeCount + 1);
// set default value as -1
for (int i = 0; i < nodeCount; ++i) {
rowPtr.add(-1);
colPtr.add(-1);
}
rowPtr.add(edges.size());
colPtr.add(edges.size());

// sort the edge based on first node
EdgeBasedOnFirstNodeComparator cmp = new EdgeBasedOnFirstNodeComparator();
Collections.sort(edges, cmp);
// build row index and pointer
int curNode = edges.elementAt(0).getFirstNode();
int curPtr = 0;
for (int i = 0; i < edgeSize; ++i) {
Edge e = edges.elementAt(i);
// System.out.println("curNode" + curNode + "firstNode: "
// + e.getFirstNode());
weight.add(e.getWeight());
rowIndex.add(e.getSecondNode());
if (curNode != e.getFirstNode()) {
rowPtr.set(curNode, curPtr);
curNode = e.getFirstNode();
curPtr = i;
}

}
rowPtr.set(curNode, curPtr);
// sort the edge based on second node
EdgeBasedOnSecondNodeComparator cmp2 = new EdgeBasedOnSecondNodeComparator();
Collections.sort(edges, cmp2);
// build column index and pointer
curNode = edges.elementAt(0).getSecondNode();
curPtr = 0;
for (int i = 0; i < edgeSize; ++i) {
Edge e = edges.elementAt(i);
colIndex.add(e.getFirstNode());
if (curNode != e.getSecondNode()) {
colPtr.set(curNode, curPtr);
curNode = e.getSecondNode();
curPtr = i;
}

}
colPtr.set(curNode, curPtr);
}

複製代碼 代碼如下:獲得一個節點的出邊
/*
* getOutEdges 返回結點所有的出邊(即所有由結點指出的邊)
*
* @param node 要尋找的結點
*
* @return 返回結點所有的出邊組成的向量
*/
@Override
public Vector<Edge> getOutEdges(int node) {
Vector<Edge> res = new Vector<Edge>();
int startIndex = getStartIndex(node, true);
if (startIndex == -1) {
// 沒有出邊的點
return null;
}
int endIndex = getEndIndex(node, true);
float value;
Edge e;
int outNode;
for (int index = startIndex; index < endIndex; ++index) {
value = weight.elementAt(index);
outNode = rowIndex.elementAt(index);
e = new Edge(node, outNode, value);
res.add(e);
}
return res;
}

獲得一個節點的入邊
?
/*
* getInEdges 擷取結點所有的入邊(即所有指向結點的邊)
*
* @param node 要尋找的結點
*
* @return 返回所有由結點入邊組成的向量
*/
@Override
public Vector<Edge> getInEdges(int node) {
Vector<Edge> res = new Vector<Edge>();
int startIndex = getStartIndex(node, false);
// 沒有入邊的點
if (startIndex == -1) {
return null;
}
int endIndex = getEndIndex(node, false);
float value;
Edge e;
int inNode;
for (int index = startIndex; index < endIndex; ++index) {
inNode = colIndex.elementAt(index);
value = getWeight(inNode, node);
e = new Edge(inNode, node, value);
res.add(e);
}
return res;
}

這裡訪問方式就跟按行訪問不一樣了，行訪問時，直接讀weight向量裡面對應的值就行了，這裡不行，應該weight向量是按行訪問順序存的。我的解決方案，擷取入節點，然後對整個節點對按行訪問獲得對應值。這樣雖然繞了一下，但是對於稀疏圖來說，基本上也是常數級的。下面是getWeight的代碼複製代碼 代碼如下:/*
* getWeight 獲得特定邊的weight
*/
private float getWeight(int row, int col) {
int startIndex = getStartIndex(row, true);
if(startIndex==-1)
return 0;
int endIndex = getEndIndex(row, true);
for (int i = startIndex; i < endIndex; ++i) {
if (rowIndex.elementAt(i) == col)
return weight.elementAt(i);
}
return 0;
}

最後是對行或者列全0時的特殊處理，這裡處理，體現在從指標向量擷取開始和結束位置的函數上複製代碼 代碼如下:/*
* getStartIndex 擷取特定頂點的開始索引
*/
private int getStartIndex(int node, boolean direction) {
// true : out edge
if (direction)
return rowPtr.elementAt(node);
else
return colPtr.elementAt(node);
}

　
?
/*
* getEndIndex 擷取特定頂點的結束索引
*/
private int getEndIndex(int node, boolean direction) {
// true:out edge
if (direction) {
int i = 1;
while ((node + i) < nodeCount) {
if (rowPtr.elementAt(node + i) != -1)
return rowPtr.elementAt(node + i);
else
++i;
}
return rowPtr.elementAt(nodeCount);
} else {
int i = 1;
while ((node + i) < nodeCount) {
if (colPtr.elementAt(node + i) != -1)
return colPtr.elementAt(node + i);
else
++i;
}
return colPtr.elementAt(nodeCount);
}
}

這裡我只實現了兩個最簡單的功能，擷取入邊和出邊。一方面是因為，對於我做的東西，這兩個函數就夠了，另一方面，對於一個圖來說，有這兩個函數，其他函數都可以相應實現。