各种图算法

原创 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);
    }


}

}

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

ForceAtlas2图布局算法

  • 2017-09-27 15:04
  • 1.67MB
  • 下载

数据结构课设图综合算法

  • 2017-07-19 10:43
  • 969KB
  • 下载

算法讲解:二分图匹配

二分图匹配,自然要先从定义入手,那么二分图是什么呢? 二分图: 二分图又称作二部图,是图论中的一种特殊模型。 设G=(V,E)是一个无向图,如果顶点V可分割为两个互不相交的子集(A,B),...

【原创】二分图匹配 与 匈牙利算法

二分图先来看看什么是二分图。二分图的概念部图在了解二分图之前,我们现在看看图论中的部图。 部图在图论中有这样的定义: 一个图的节点集可分成若干个子集,使得每一条边的两端点不在同一子集内.若一个图...

flex 力导图 弹簧算法

  • 2015-03-17 11:32
  • 158KB
  • 下载

图搜索的通用算法

  • 2014-11-12 15:19
  • 24KB
  • 下载

KM算法(二分图完备匹配下的最大权匹配)

阅读本文之前,首先假设您已经理解匈牙利算法,如果不理解友链在这=>我是匈牙利算法<=有时间会将匈牙利算法的博客补上的。KM算法KM算法求的是二分图完备匹配下的最大权匹配。在二分图中,x点集中的所有点都...

图算法例题

  • 2013-12-22 18:33
  • 67KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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