无向图　ＤＳＴ图的深度遍历　　BST图的广度遍历

2019年3月16日 409次阅读来源: 数据结构之图

GRAPH_H
#define _GRAPH_H
#define  DEFAULT_VERTEX_SIZE 10
template<class Type>
class Graph;
class Edge
{
public:
Edge(int num):dest(num),link(NULL)
{}
~Edge()
{}
int dest;
Edge* link;
};
template<class Type>
class Vertex
{
friend Graph<Type>;
public:
Vertex():data(Type()),adj(NULL)
{}
~Vertex()
{}
private:
Edge *adj;
Type data;
};
template<class Type>
class Graph
{
public:
Graph(int sz=DEFAULT_VERTEX_SIZE)
{
MaxVertices=sz>DEFAULT_VERTEX_SIZE?sz:DEFAULT_VERTEX_SIZE;
NumVertices=NumEdge=0;
NodeTable=new Vertex<Type>[MaxVertices];
}
~Graph()
{
Edge *t;
for(int i=0;i<NumVertices;++i)
    {
        Edge *w;
        t=NodeTable[i].adj;
        while(t!=NULL)
        {
            w=t;
            t=t->link;
            delete w;
        }
    }
    delete[] NodeTable;

    //////
}
int GetPosOfVertex(const Type &v)const
{
    for(int i=0;i<NumVertices;++i)
    {
        if(NodeTable[i].data==v)
        return i;
    }
    return -1;

}
void InsertVertex(const Type &val)
{
if(NumVertices<MaxVertices)
{
    NodeTable[NumVertices++].data=val;
}
}
bool InsertEdge(const Type &vertex1, const Type &vertex2)
{
        int v1 = GetPosOfVertex(vertex1);
        int v2 = GetPosOfVertex(vertex2);
        if(v1==-1 || v2==-1)
            return false;
        //v1 --> v2
        Edge *e = new Edge(v2);
        e->link = NodeTable[v1].adj;
        NodeTable[v1].adj = e;
        //v2 --> v1
        e = new Edge(v1);
        e->link = NodeTable[v2].adj;
        NodeTable[v2].adj = e;
        NumEdge++;
        return true;
    }

/*
bool InsertEdge(const Type &v1,const Type &v2)
{
    int V1=GetPosOfVertex(v1);
    int V2=GetPosOfVertex(v2);
    if(V1==-1||V2==-1)
    return false;
    //v1-->v2
    cout<<"v1: "<<V1<<"  v2:  "<<V2<<endl;
    Edge *s=new Edge(V2);
    s->link=NodeTable[V1].adj;
    NodeTable[V1].adj=s;
    //v2-->v1
    Edge *s1=new Edge(V1);
    s1->link=NodeTable[V2].adj;
    NodeTable[V1].adj=s1;
    ++NumEdge;
    return true;
}
*/
int NumOfVertex()const
{
    return NumVertices;
}
int NumOfEdge()const
{
    return NumEdge;
}
Type GetValueByIndex(int i)
{
    if(i<=NumVertices&&i>=0)
    return NodeTable[i].data;
}
int GetFirstNeighbor(const Type &vertex)const
{
    int v=GetPosOfVertex(vertex);
    if(v==-1)
    return -1;
   if(    NodeTable[v].adj!=NULL)
       return NodeTable[v].adj->dest;
    else
    return -1;

}
int GetNextNeighbor(const Type &vertex1,const Type &vertex2)const
{
    int v1=GetPosOfVertex(vertex1);
    int v2=GetPosOfVertex(vertex2);
    if(v1==-1||v2==-1)
    return -1;
    if(NodeTable[v1].adj==NULL)
    return -1;
    Edge *t=NodeTable[v1].adj;
    while(t!=NULL&&t->dest!=v2)
    t=t->link;
    if(t==NULL)
    return -1;
    else
    if(t->link!=NULL)
    return t->link->dest;
    else
    return -1;
}

bool RemoveEdge(const Type &vertex1,const Type &vertex2)
{
    int v1=GetPosOfVertex(vertex1);
    int v2=GetPosOfVertex(vertex2);
    if(v1==-1||v2==-1)
    return false;
    Edge *t=NodeTable[v1].adj;
    Edge *p=t;
    while(t!=NULL&&t->dest!=v2)
    {
        p=t;
        t=t->link;
    }
    if(t==NULL)
        return false;
    else
    {
        if(p==t)
        {
            Edge *w=NodeTable[v1].adj;
            NodeTable[v1].adj=NodeTable[v1].adj->link;
            delete w;
        }
        else
        {
            Edge *w=p->link;
            p->link=t->link;
            delete w;
        }
    //
        t=p=NodeTable[v2].adj;
        while(t->dest!=v1)
        {
            p=t;
            t=t->link;
        }
        if(t==p)
        {
            Edge *w=NodeTable[v2].adj;
            NodeTable[v2].adj=NodeTable[v2].adj->link;
            delete w;
        }
        else
        {    
            Edge *w=p->link;
            p->link=t->link;
            delete w;
        }
        --NumEdge;
        return true;
    }

}
bool RemoveVertex(const Type &vertex)
{
    int v=GetPosOfVertex(vertex);
    if(v==-1)
    return false;
    Edge* t=NodeTable[v].adj;
    while(t!=NULL)
    {
        Edge *p=NodeTable[t->dest].adj;
        Edge *p1=p;
        while(p!=NULL)
        {
            while(p->dest!=v)
            {
                p1=p;
                p=p->link;
            }
            if(p==p1)
            {
                Edge *w=NodeTable[t->dest].adj;
                NodeTable[t->dest].adj=NodeTable[t->dest].adj->link;
                delete w;
                break;
            }
            else
            {
                Edge* w=p1->link;
                p1->link=p->link;
                delete w;
                break;
            }
        }
        p1=t;
        t=t->link;
        delete p1;
        --NumEdge;
    }
    if(v!=NumVertices-1)
    {
        NodeTable[v].data=NodeTable[NumVertices-1].data;
        NodeTable[v].adj=NodeTable[NumVertices-1].adj;
        Edge *t1=NodeTable[NumVertices-1].adj;
        while(t1!=NULL)
        {
            Edge *p3=NodeTable[t1->dest].adj;
            while(p3->dest!=NumVertices-1)
            p3=p3->link;
            p3->dest=v;

            t1=t1->link;
        }
    }
    --NumVertices;
    return true;
}
void DFSTraverse()//深度遍历
{
bool *visited=new bool[NumVertices];
    for(int i=0;i<NumVertices;++i)
        visited[i]=false;
    for(int i=0;i<NumVertices;++i)
        if(!visited[i])
            DFS(i,visited);
}
void DFS(int v,bool *&visited)
{
    if(v<=-1&&v>=NumVertices)
    return ;
    visited[v]=true;
    cout<<NodeTable[v].data<<"  ";
    for(int w=GetFirstNeighbor(GetValueByIndex(v));w>=0;w=GetNextNeighbor(GetValueByIndex(v),GetValueByIndex(w)))
    if(!visited[w])
    DFS(w,visited);
    
}
void DFSTraverse_1(Type val)
{
    bool *visited=new bool[NumVertices];
    for(int i=0;i<NumVertices;++i)
        visited[i]=false;
    int x=GetPosOfVertex(val);
    visited[x]=true;
    cout<<NodeTable[x].data<<"  ";
    for(int w=GetFirstNeighbor(val);w>=0;w=GetNextNeighbor(val,GetValueByIndex(w)))
    {
        if(!visited[w])
        {
            visited[w]=true;
            cout<<NodeTable[w].data<<"  ";
        }
    }
    for(int i=0;i<NumVertices;++i)
    {
        if(!visited[i])
        {
            visited[i]=true;
            cout<<NodeTable[i].data<<"  ";
            for(int w=GetFirstNeighbor(GetValueByIndex(i));w>=0;w=GetNextNeighbor(GetValueByIndex(i),GetValueByIndex(w)))
            if(!visited[w])
            {
                visited[w]=true;
                cout<<NodeTable[w].data<<"  ";
            }
        }

    }
    
}
void BFSTraverse()//广度遍历
{
    bool *visited=new bool[NumVertices];
    for(int i=0;i<NumVertices;++i)
        visited[i]=false;
    queue<int>  Q;
    for(int i=0;i<NumVertices;++i)
    {
        if(!visited[i])
        {
            visited[i]=true;
            cout<<NodeTable[i].data<<"  ";
        }
        Q.push(i);
        while(!Q.empty())
        {
            int u=Q.front();
            Q.pop();
            Edge *s=NodeTable[u].adj;
            while(s!=NULL)
            {
                if(!visited[s->dest])
                {
                    visited[s->dest]=true;
                    cout<<NodeTable[s->dest].data<<"  ";
                    Q.push(s->dest);
                }
                s=s->link;
            }
        }
    }
}
void BFSTraverse_1(Type v)
{
    bool *visited=new bool[NumVertices];
    queue<int> Q;
    int x=GetPosOfVertex(v);
    if(x==-1)
        return;
    Q.push(x);
    cout<<v<<"  ";
    visited[x]=true;
    Edge *s=NodeTable[x].adj;
    while(s!=NULL)
    {    
        if(!visited[s->dest])
        {
            visited[s->dest]=true;
            Q.push(s->dest);
            cout<<NodeTable[s->dest].data<<"  ";
        }
        s=s->link;
    }
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        s=NodeTable[u].adj;
        while(s!=NULL)
        {
            if(!visited[s->dest])
            {
                visited[s->dest]=true;
                cout<<NodeTable[s->dest].data<<"  ";
                Q.push(s->dest);
            }
            s=s->link;
        }

    }
}
void ShowGraph()
{
    for(int i=0;i<NumVertices;++i)
    {
        cout<<i<<"  "<<NodeTable[i].data<<"  "<<"-->";
        Edge* e=NodeTable[i].adj;
        while(e!=NULL)
        {
            cout<<e->dest<<"-->";
            e=e->link;
        }
        cout<<"NUL"<<endl;;
    }
}
private:
Vertex<Type>*NodeTable;
int MaxVertices;
int NumVertices;
int NumEdge;
};

#endif

#ifndef _GRAPH_H

#define _GRAPH_H

#define DEFAULT_VERTEX_SIZE 10

template<class Type>

class Graph;

class Edge

{

public:

Edge(int num):dest(num),link(NULL)

{}

~Edge()

{}

int dest;

Edge* link;

};

template<class Type>

class Vertex

{

friend Graph<Type>;

public:

Vertex():data(Type()),adj(NULL)

{}

~Vertex()

{}

private:

Edge *adj;

Type data;

};

template<class Type>

class Graph

{

public:

Graph(int sz=DEFAULT_VERTEX_SIZE)

{

MaxVertices=sz>DEFAULT_VERTEX_SIZE?sz:DEFAULT_VERTEX_SIZE;

NumVertices=NumEdge=0;

NodeTable=new Vertex<Type>[MaxVertices];

}

~Graph()

{

Edge *t;

for(int i=0;i<NumVertices;++i)

{

Edge *w;

t=NodeTable[i].adj;

while(t!=NULL)

{

w=t;

t=t->link;

delete w;

}

delete[] NodeTable;

//////

}

int GetPosOfVertex(const Type &v)const

{

for(int i=0;i<NumVertices;++i)

{

if(NodeTable[i].data==v)

return i;

}

return -1;

}

void InsertVertex(const Type &val)

{

if(NumVertices<MaxVertices)

{

NodeTable[NumVertices++].data=val;

}

bool InsertEdge(const Type &vertex1, const Type &vertex2)

{

int v1 = GetPosOfVertex(vertex1);

int v2 = GetPosOfVertex(vertex2);

if(v1==-1 || v2==-1)

return false;

//v1 –> v2

Edge *e = new Edge(v2);

e->link = NodeTable[v1].adj;

NodeTable[v1].adj = e;

//v2 –> v1

e = new Edge(v1);

e->link = NodeTable[v2].adj;

NodeTable[v2].adj = e;

NumEdge++;

return true;

}

bool InsertEdge(const Type &v1,const Type &v2)

{

int V1=GetPosOfVertex(v1);

int V2=GetPosOfVertex(v2);

if(V1==-1||V2==-1)

return false;

//v1–>v2

cout<<“v1: “<<V1<<” v2: “<<V2<<endl;

Edge *s=new Edge(V2);

s->link=NodeTable[V1].adj;

NodeTable[V1].adj=s;

//v2–>v1

Edge *s1=new Edge(V1);

s1->link=NodeTable[V2].adj;

NodeTable[V1].adj=s1;

++NumEdge;

return true;

}

int NumOfVertex()const

{

return NumVertices;

}

int NumOfEdge()const

{

return NumEdge;

}

Type GetValueByIndex(int i)

{

if(i<=NumVertices&&i>=0)

return NodeTable[i].data;

}

int GetFirstNeighbor(const Type &vertex)const

{

int v=GetPosOfVertex(vertex);

if(v==-1)

return -1;

if( NodeTable[v].adj!=NULL)

return NodeTable[v].adj->dest;

else

return -1;

}

int GetNextNeighbor(const Type &vertex1,const Type &vertex2)const

{

int v1=GetPosOfVertex(vertex1);

int v2=GetPosOfVertex(vertex2);

if(v1==-1||v2==-1)

return -1;

if(NodeTable[v1].adj==NULL)

return -1;

Edge *t=NodeTable[v1].adj;

while(t!=NULL&&t->dest!=v2)

t=t->link;

if(t==NULL)

return -1;

else

if(t->link!=NULL)

return t->link->dest;

else

return -1;

}

bool RemoveEdge(const Type &vertex1,const Type &vertex2)

{

int v1=GetPosOfVertex(vertex1);

int v2=GetPosOfVertex(vertex2);

if(v1==-1||v2==-1)

return false;

Edge *t=NodeTable[v1].adj;

Edge *p=t;

while(t!=NULL&&t->dest!=v2)

{

p=t;

t=t->link;

}

if(t==NULL)

return false;

else

{

if(p==t)

{

Edge *w=NodeTable[v1].adj;

NodeTable[v1].adj=NodeTable[v1].adj->link;

delete w;

}

else

{

Edge *w=p->link;

p->link=t->link;

delete w;

}

t=p=NodeTable[v2].adj;

while(t->dest!=v1)

{

p=t;

t=t->link;

}

if(t==p)

{

Edge *w=NodeTable[v2].adj;

NodeTable[v2].adj=NodeTable[v2].adj->link;

delete w;

}

else

{

Edge *w=p->link;

p->link=t->link;

delete w;

}

–NumEdge;

return true;

}

bool RemoveVertex(const Type &vertex)

{

int v=GetPosOfVertex(vertex);

if(v==-1)

return false;

Edge* t=NodeTable[v].adj;

while(t!=NULL)

{

Edge *p=NodeTable[t->dest].adj;

Edge *p1=p;

while(p!=NULL)

{

while(p->dest!=v)

{

p1=p;

p=p->link;

}

if(p==p1)

{

Edge *w=NodeTable[t->dest].adj;

NodeTable[t->dest].adj=NodeTable[t->dest].adj->link;

delete w;

break;

}

else

{

Edge* w=p1->link;

p1->link=p->link;

delete w;

break;

}

p1=t;

t=t->link;

delete p1;

–NumEdge;

}

if(v!=NumVertices-1)

{

NodeTable[v].data=NodeTable[NumVertices-1].data;

NodeTable[v].adj=NodeTable[NumVertices-1].adj;

Edge *t1=NodeTable[NumVertices-1].adj;

while(t1!=NULL)

{

Edge *p3=NodeTable[t1->dest].adj;

while(p3->dest!=NumVertices-1)

p3=p3->link;

p3->dest=v;

t1=t1->link;

}

–NumVertices;

return true;

}

void DFSTraverse()//深度遍历

{

bool *visited=new bool[NumVertices];

for(int i=0;i<NumVertices;++i)

visited[i]=false;

for(int i=0;i<NumVertices;++i)

if(!visited[i])

DFS(i,visited);

}

void DFS(int v,bool *&visited)

{

if(v<=-1&&v>=NumVertices)

return ;

visited[v]=true;

cout<<NodeTable[v].data<<” “;

for(int w=GetFirstNeighbor(GetValueByIndex(v));w>=0;w=GetNextNeighbor(GetValueByIndex(v),GetValueByIndex(w)))

if(!visited[w])

DFS(w,visited);

}

void DFSTraverse_1(Type val)

{

bool *visited=new bool[NumVertices];

for(int i=0;i<NumVertices;++i)

visited[i]=false;

int x=GetPosOfVertex(val);

visited[x]=true;

cout<<NodeTable[x].data<<” “;

for(int w=GetFirstNeighbor(val);w>=0;w=GetNextNeighbor(val,GetValueByIndex(w)))

{

if(!visited[w])

{

visited[w]=true;

cout<<NodeTable[w].data<<” “;

}

for(int i=0;i<NumVertices;++i)

{

if(!visited[i])

{

visited[i]=true;

cout<<NodeTable[i].data<<” “;

for(int w=GetFirstNeighbor(GetValueByIndex(i));w>=0;w=GetNextNeighbor(GetValueByIndex(i),GetValueByIndex(w)))

if(!visited[w])

{

visited[w]=true;

cout<<NodeTable[w].data<<” “;

}

void BFSTraverse()//广度遍历

{

bool *visited=new bool[NumVertices];

for(int i=0;i<NumVertices;++i)

visited[i]=false;

queue<int> Q;

for(int i=0;i<NumVertices;++i)

{

if(!visited[i])

{

visited[i]=true;

cout<<NodeTable[i].data<<” “;

}

Q.push(i);

while(!Q.empty())

{

int u=Q.front();

Q.pop();

Edge *s=NodeTable[u].adj;

while(s!=NULL)

{

if(!visited[s->dest])

{

visited[s->dest]=true;

cout<<NodeTable[s->dest].data<<” “;

Q.push(s->dest);

}

s=s->link;

}

void BFSTraverse_1(Type v)

{

bool *visited=new bool[NumVertices];

queue<int> Q;

int x=GetPosOfVertex(v);

if(x==-1)

return;

Q.push(x);

cout<<v<<” “;

visited[x]=true;

Edge *s=NodeTable[x].adj;

while(s!=NULL)

{

if(!visited[s->dest])

{

visited[s->dest]=true;

Q.push(s->dest);

cout<<NodeTable[s->dest].data<<” “;

}

s=s->link;

}

while(!Q.empty())

{

int u=Q.front();

Q.pop();

s=NodeTable[u].adj;

while(s!=NULL)

{

if(!visited[s->dest])

{

visited[s->dest]=true;

cout<<NodeTable[s->dest].data<<” “;

Q.push(s->dest);

}

s=s->link;

}

void ShowGraph()

{

for(int i=0;i<NumVertices;++i)

{

cout<<i<<” “<<NodeTable[i].data<<” “<<“–>”;

Edge* e=NodeTable[i].adj;

while(e!=NULL)

{

cout<<e->dest<<“–>”;

e=e->link;

}

cout<<“NUL”<<endl;;

}

private:

Vertex<Type>*NodeTable;

int MaxVertices;

int NumVertices;

int NumEdge;

};

#endif

    原文作者：数据结构之图
    原文地址: https://blog.csdn.net/Faded0104/article/details/56036116
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。