20176510李长宁

@李长宁的笔记

有向图邻接矩阵

#include
#include
#include
using namespace std;

#define MAX 100
class MatrixDG {
private:
char mVexs[MAX];
int mVexNum;
int mEdgNum;
int mMatrix[MAX][MAX];

public:

	MatrixDG();

    MatrixDG(char vexs[], int vlen, char edges[][2], int elen);
	~MatrixDG();


    void DFS();

    void BFS();

    void print();

private:

    char readChar();
    int getPosition(char ch);
    int firstVertex(int v);
    int nextVertex(int v, int w);
    void DFS(int i, int *visited);

};
MatrixDG::MatrixDG()
{
char c1, c2;
int i, p1, p2;
cout << "input vertex number: ";
cin >> mVexNum;
cout << "input edge number: ";
cin >> mEdgNum;
if ( mVexNum < 1 || mEdgNum < 1 || (mEdgNum > (mVexNum * (mVexNum-1))))
{
cout << “input error: invalid parameters!” << endl;
return ;
}

for (i = 0; i < mVexNum; i++)
{
    cout << "vertex(" << i << "): ";
    mVexs[i] = readChar();
}

for (i = 0; i < mEdgNum; i++)
{
    cout << "edge(" << i << "): ";
    c1 = readChar();
    c2 = readChar();

    p1 = getPosition(c1);
    p2 = getPosition(c2);
    if (p1==-1 || p2==-1)
    {
        cout << "input error: invalid edge!" << endl;
        return ;
    }

    mMatrix[p1][p2] = 1;
}

}
MatrixDG::MatrixDG(char vexs[], int vlen, char edges[][2], int elen)
{
int i, p1, p2;
mVexNum = vlen;
mEdgNum = elen;
for (i = 0; i < mVexNum; i++)
mVexs[i] = vexs[i];

for (i = 0; i < mEdgNum; i++)
{

    p1 = getPosition(edges[i][0]);
    p2 = getPosition(edges[i][1]);

    mMatrix[p1][p2] = 1;
}

}

MatrixDG::~MatrixDG()
{
}

int MatrixDG::getPosition(char ch)
{
int i;
for(i=0; i<mVexNum; i++)
if(mVexs[i]==ch)
return i;
return -1;
}

char MatrixDG::readChar()
{
char ch;

do {
    cin >> ch;
} while(!((ch>='a'&&ch<='z') || (ch>='A'&&ch<='Z')));

return ch;

}

int MatrixDG::firstVertex(int v)
{
int i;

if (v<0 || v>(mVexNum-1))
    return -1;

for (i = 0; i < mVexNum; i++)
    if (mMatrix[v][i] == 1)
        return i;

return -1;

}

int MatrixDG::nextVertex(int v, int w)
{
int i;

if (v<0 || v>(mVexNum-1) || w<0 || w>(mVexNum-1))
    return -1;

for (i = w + 1; i < mVexNum; i++)
    if (mMatrix[v][i] == 1)
        return i;

return -1;

}

void MatrixDG::DFS(int i, int *visited)
{
int w;

visited[i] = 1;
cout << mVexs[i] << " ";

for (w = firstVertex(i); w >= 0; w = nextVertex(i, w))
{
    if (!visited[w])
        DFS(w, visited);
}

}

void MatrixDG::DFS()
{
int i;
int visited[MAX];

for (i = 0; i < mVexNum; i++)
    visited[i] = 0;

cout << "DFS: ";
for (i = 0; i < mVexNum; i++)
{

    if (!visited[i])
        DFS(i, visited);
}
cout << endl;

}

void MatrixDG::BFS()
{
int head = 0;
int rear = 0;
int queue[MAX];
int visited[MAX];
int i, j, k;

for (i = 0; i < mVexNum; i++)
    visited[i] = 0;

cout << "BFS: ";
for (i = 0; i < mVexNum; i++)
{
    if (!visited[i])
    {
        visited[i] = 1;
        cout << mVexs[i] << " ";
        queue[rear++] = i;
    }
    while (head != rear)
    {
        j = queue[head++];
        for (k = firstVertex(j); k >= 0; k = nextVertex(j, k))
        {
            if (!visited[k])
            {
                visited[k] = 1;
                cout << mVexs[k] << " ";
                queue[rear++] = k;
            }
        }
    }
}
cout << endl;

}

int main()
{
char vexs[] = {‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’};
char edges[][2] = {
{‘A’, ‘B’},
{‘B’, ‘C’},
{‘B’, ‘E’},
{‘B’, ‘F’},
{‘C’, ‘E’},
{‘D’, ‘C’},
{‘E’, ‘B’},
{‘E’, ‘D’},
{‘F’, ‘G’}};
int vlen = sizeof(vexs)/sizeof(vexs[0]);
int elen = sizeof(edges)/sizeof(edges[0]);
MatrixDG* pG;

pG = new MatrixDG(vexs, vlen, edges, elen);


pG->DFS();
pG->BFS();

return 0;

}