各种图算法

原创 2015年07月07日 18:44:29

public class TestForString{
public static void main(String[] arg){
int[] array=new int[]{1,8,6,3,9,7};
mergeSort(array,0,5);
for(int i:array){
System.out.print(i+” “);
}
}

 public static int[] mergeSort(int[] array,int low,int heigh){
     if(low>=heigh){
         return array;
     }

     int mid =(low + heigh)/2;
     mergeSort(array,low,mid);
     mergeSort(array,mid+1,heigh);
     return merge(array,low,mid,heigh);

 }



 private static int[] merge(int[] array, int low, int mid, int heigh) {
    int[] temp = new int[heigh-low+1];
    int indexOfLow = low;
    int indexOfHeigh = mid+1;
    int indexOfTemp = 0;



    while(indexOfLow<=mid&&indexOfHeigh<=heigh){
        if(array[indexOfLow]<array[indexOfHeigh]){
            temp[indexOfTemp++]=array[indexOfLow++];

        }else{
            temp[indexOfTemp++]=array[indexOfHeigh++];

        }
    }
    if(indexOfLow<=mid){
        temp[indexOfTemp++]=array[indexOfLow++];

    }
    if(indexOfHeigh<=heigh){
        temp[indexOfTemp++]=array[indexOfHeigh++];
    }

    for(int i:temp){

        array[low++]=i;
    }

    System.out.println();

    return array;
}

public static void insertSort(int[] array){
     for(int i=1;i<array.length;i++){
         int toBeInsert=array[i];
         int n=i;
         while(n>0&&toBeInsert>array[n-1]){
             array[n]=array[n-1];
             n--;
         }
         array[n]=toBeInsert;
    }
 }


 public static void swap(int[] array,int index1,int index2){
     int temp = array[index1];
     array[index1]=array[index2];
     array[index2]=temp;
 }

}

class Edge{
public int srcVert;
public int destVert;
public int distance;

public Edge(int sv,int dv,int d){
    srcVert = sv;
    destVert = dv;
    distance = d;
}

}

class PriorityQ{

private final int SIZE=20;
private Edge[] queArray;
private int size;

public PriorityQ(){
    queArray = new Edge[SIZE];
    size = 0;
}

public void insert(Edge item){
    int j;
    for(j=0;j<size;j++){
        if(item.distance >= queArray[j].distance){
            break;
        }
    }

    for(int i=size;i>j;i--){
        queArray[i]=queArray[i-1];
    }

    queArray[j]=item;

    size++;
}

public Edge removeMin(){
    return queArray[--size];
}

public void removeN(int n){
    for(int i=n;i<size-1;i++){
        queArray[i]=queArray[i+1];
    }

    size--;
}

public Edge peekMin(){
    return queArray[size-1];
}

public int size(){
    return size;
}

public boolean isEmpty(){
    return size==0;
}

public Edge peekN(int n){
    return queArray[n];
}

public int find(int findDex){
    for(int i=0;i<size;i++){
        if(queArray[i].destVert==findDex){
            return i;
        }
    }

    return -1;
}

}

class DistPar{
public int distance;
public int parentVert;
public DistPar(int pv,int d){
distance = d;
parentVert = pv;
}
}

class Vertex{
public char label;
public boolean isInTree;

public Vertex(char lab){
    this.label = lab;
    isInTree = false;
}

}

class Graph{
private final int MAX_VERS=20;
private final int INFINITY=100000;
private Vertex vertexList[];
private int adjMat[][];
private int currentVert;
private PriorityQ thePQ;
private int nTree;
private int nVerts;
private int startToCurrent;
private DistPar sPath[];

public Graph(){
    vertexList = new Vertex[MAX_VERS];
    adjMat = new int[MAX_VERS][MAX_VERS];
    nVerts =0;
    nTree=0;
    for(int i=0;i<MAX_VERS;i++){
        for(int j=0;j<MAX_VERS;j++){
            adjMat[i][j] = INFINITY;
        }
    }

    sPath = new DistPar[MAX_VERS];
}

public void addVertex(char lab){
    if(nVerts<MAX_VERS){
        vertexList[nVerts++]=new Vertex(lab);
    }
}

public void addEdge(int start,int end,int weight){
    adjMat[start][end]=weight;
    //adjMat[end][start]=weight;
}

public void displayVertex(int v){
    System.out.println(vertexList[v].label);
}

public void mstw(){
    currentVert = 0;
    thePQ = new PriorityQ();
    nTree = 0;

    while(nTree<nVerts-1){
        vertexList[currentVert].isInTree = true;
        nTree++;
        for(int i=0;i<nVerts;i++){
            if(vertexList[i].isInTree
                    ||i==currentVert
                    ||adjMat[currentVert][i]==INFINITY){
                continue;
            }

            putIntoPq(currentVert,i,adjMat[currentVert][i]);

        }

        if(thePQ.isEmpty()){
            System.out.print("THE GRIP IS NOT CONNECTED!!!");
            return;
        }

        Edge min = thePQ.peekMin();
        currentVert = min.destVert;
    }
}

private void putIntoPq(int src, int des, int distance) {
    Edge edge = new Edge(src,des,distance);

    int indexOfEdge = thePQ.find(des);
    if(indexOfEdge==-1){
        thePQ.insert(edge);
        return;
    }

    Edge old = thePQ.peekN(indexOfEdge);
    if(old.distance>distance){
        thePQ.removeN(indexOfEdge);
        thePQ.insert(edge);
    }


}

}

图的概念和关于图的几个算法

图是算法中是树的拓展,树是从上xian
  • KangRoger
  • KangRoger
  • 2014年07月19日 17:07
  • 3997

图类算法总结

图算法
  • ntt5667781
  • ntt5667781
  • 2016年10月06日 13:22
  • 4033

无向图的几个基本算法应用

简介     最近在看一些图相关的问题。实际上关于图相关的研究和问题已经非常多了。在前面的几篇文章里,我也谈到过图的定义、遍历法,扩展树生成和最短路径等问题。 除了这些问题及应用以外,还有一...
  • yafeichang
  • yafeichang
  • 2016年12月26日 20:03
  • 2645

图遍历算法的应用

图遍历算法的应用
  • zj20320
  • zj20320
  • 2016年08月05日 18:34
  • 371

算法7_图的应用详解

概述 最小生成树——无向连通图的所有生成树中有一棵边的权值总和最小的生成树 拓扑排序 ——由偏序定义得到拓扑有序的操作便是拓扑排序。建立模型是AOV网 关键路径——在AOE-网中有些活动可以并...
  • wang_zhenwei
  • wang_zhenwei
  • 2016年08月01日 14:53
  • 1322

数据结构与算法--图

数据结构与算法–图 线性表的每个元素有线性关系,每个数据元素只有一个直接前去和一个直接后继。树的数据元素之间有着明细那的层次关系,并且每层上的数据元素可能和下一层中多个元素相关,但只能和上一层中一个...
  • Gavin_Yueyi
  • Gavin_Yueyi
  • 2015年10月15日 19:07
  • 1930

【经典算法】:图的遍历算法的实现

#include #include "StdAfx.h" #define MAX 20 #include "malloc.h" int visited[MAX]; //访问标志数组 ...
  • qq_23100787
  • qq_23100787
  • 2016年06月07日 15:53
  • 513

关于图的遍历算法

前些天做算法设计实验,涉及到图的遍历的一些算法,由于数据结构是在去年学的,很多算法也有些记不清了,今天在网上看到了一篇好的博文,留作看吧. 转载自海子的: http://www.cnblogs.c...
  • u013518289
  • u013518289
  • 2015年11月28日 12:15
  • 2824

【每日算法】图算法(遍历&MST&最短路径&拓扑排序)

图有邻接矩阵和邻接表两种存储方法,邻接矩阵很简单,这里不讨论,下面我们先看看常用的邻接表表示方法。 邻接表常用表示方法 指针表示法 指针表示法一共需要两个结构体: struct ArcNode...
  • jiange_zh
  • jiange_zh
  • 2016年02月28日 21:04
  • 3720

常见图算法总结与Java实现

下面的代码中实现了基于邻接表的图算法包括广度优先遍历、深度优先遍历、最小生成树算法Prim和Kruskal、单源最短路径算法Bellman-Ford和Dijkstra 代码参考算法导论和https:...
  • zfyseu1
  • zfyseu1
  • 2017年02月10日 20:10
  • 284
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:各种图算法
举报原因:
原因补充:

(最多只允许输入30个字)