【数据结构】 图、树、括号匹配

## 以邻接矩阵和邻接表作为存储结构，实现以下图的基本操作。
## 1. 增加一个新顶点 InsertVex（G，v）
## 2. 删除顶点V及其相关的边 DeleteVex（G，v）
## 3. 增加一条边 InsertArc（G，v，w）
## 4. 增加一个新顶点 DeleteArc（G，v，w）

##以邻接矩阵实现

##增加新顶点 其实就是邻接矩阵里长度加1  输入顶点信息
Status InsertVex(AMGraph &G,char v){
    if(G.vexnum+1>MAXNum)return false;
    G.vexs[++G.vexnum]=v;
    return OK;
}

## 应该不考 里边好多调用的地方没法考
Status DeleteVex(AMGraph &G,char v){
    n=G.vexnum;
    if(m=LocateVex(G,v)<0) return Error;
    G.vexs[m]<->G.vex[n];//将待删除顶点交换到最后
    for(i=0;i<n;i++){
        G.arcs[m]=G.arcs[n];
        G.arcs[m]=G.arcs[n];
    }
    G.arcs[m][m].adj=0;
    G.vexnum--;
    return OK;
}

## 增加一条边 邻接矩阵的增加删除边 基本都是判断下该边存不存在 然后相等就行  //20年图考过
Status InsertArc（AMGraph &G，char v，char w）{
    if((i=LocateVex(G,v))<0)return Error;
    if((j=LocateVex(G,v))<0)return Error;
    if(i==j)return Error;
    if(G.arcs[i][j]==0){
        G.arcs[i][j]==G.arcs[j][i]=1;
        G.arcnum++;
    }
    return OK;
}

## 删除一条边
Status DeleteArc(AMGraph &G,char v,char w){
    if((i=LocateVex(G,v))<0)return Error;
    if((j=LocateVex(G,v))<0)return Error;
    if(i==j)return Error;
    if(G.arcs[i][j]!=0){
        G.arcs[i][j]=G.arcs[j][i]=0;
        G.arcnum--;
    }
    return OK;
}


## 以邻接表为存储结构 给有向图插入一条边 新建边节点 看该顶点有没有边界点 若没有 直接插入 若有 将q指针循环到最后 插入p节点 
##  想删除边的话 就遍历被 让q=G.vertices[i].firstarc 然后for循环向后找，找到就让p指向后边的后边就OK了
Status InsertArc（AMGraph &G,char v,char w){
    if((i=LocateVex(G,v))<0)return Error;
    if((j=LocateVex(G,v))<0)return Error;
    if(i==j)return Error;
    p=new ArcNode;
    p=>adjvex=j;
    p->nextarc=null;
    if(!G.vertices[i].firstarc){
        G.vertices.firstarc=p;
    }else{
        for(q=G.vertices.firstarc;q->q->nextarc;q=q->nextarc){
            if(q->adjvex==j)return ERROR;//已存在该边
        }
        q->nextarc=p;循环到最后插入
    }
    G.arcnum++;
    return OK;
}



## 一个连通图采用邻接表为存储结构 设计一个算法 实现从顶点V出发的深度优先便利的非递归过程。  ********可能会考的
void DFSn(Graph G,int v){
    Stack s; ## 生成一个栈 将栈置空 将首个元素入栈  当栈不为空时 依次弹出并访问  并将当前元素所有邻接元素入栈 （没被访问过的和没环的）
    setEmpty(s);
    Push[s,v];
    while(!StackEmpty(s)){
        pop(s,k);//把第一个节点弹给了k
        if(!visited[k]){
            visited[k]=TRUE;
            ## visitFunc(k);
            for(w=FirstAdjVex(G,k);w;w=NextAdjVex(G,k,w)){ ##将k的所有邻接点进栈
                if(!visited[w]&&w!=GetTop(s)){  ## 前提是k的邻接点没有被访问过且w不等于栈顶元素 即不能有环
                    push(s,w);
                }
            }
        }
    }
}

## 以邻接矩阵为存储结构 统计有向图所有出度之和
#define MAXInt 32767;
#define MAXNum 100;
typedef char VerTexType;
typedef int ArcType;
typedef struct{
    VerTexType vexs[MAXNum];
    ArcType arcs[MAXNum][MAXNum];
    int vexnum,arcnum;
}AMGraph
int ODCount(AMGraph &G){
    sum=0;
    for(i=0;i<G.vexnum;i++){
        for(j=0;j<G.vexnum;j++){
            if(arcs[i][j]!=MaxInt){
                sum++;
            }
        }
    }
    return sum;
}



#编写算法实现表达式中左括号与有括号是否配对的判别
Status Matching(){
    //检验表达式中所含括号是否正确匹配 如果匹配 返回true 否则返回false
    InitStack(S);
    flag=1;
    cin>>ch;
    while(ch!='#' && flag){
        switch(ch){
            case '[':
            case '{':
                push(S,ch);
                break;
                case ')':
                    if(!StackEmpty(S)&&GetTop(S)=='(')
                        pop(S,x);
                    else flag=0;
                    break;
                case ']':
                    if(!StackEmpty(S)&&GetTop(S)=='[')
                        pop(S,x);
                    else flag=0;
                    break;
        }
        cin>>ch;
    }

    if(StackEmpty(S)&&flag)return true;
    else return false;
}