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


}

}