Heapuri

public class heap {

       
        static int a[]={12,4,7,29,48,16,18};
        int heapsize=0;

       
static int parinte(int i){
   
    return (i-1)/2;

}   
int stanga(int i){
   
    return i*2+1;
}
int dreapta(int i){
   
    return i*2+2;
}

 void insert(int a[],int z){
   
   
    heapsize=heapsize+1;
   
    int i;
    i=heapsize;
   
    while((i>0)&&(a[parinte(i)]>z)){
            a[i]=a[parinte(i)];
            i=parinte(i); }
   
        a[i]=z;
   
        //extragere A[0] , A[0], Reconstituie(A,0),(a.size-1)/2 pana la 0
        // heapsize=0;,for=1,a.length-1;
}

 void reconstituire(int a[],int i){
    int s=stanga(i);
    int d=dreapta(i);
    int min;
   
    if((s<=heapsize)&&(a[s]<a[i]))
        min=s;
    else
            min=i;
    if((d<=heapsize)&&(a[d]<a[min]))
            min=d;
    if(min!=i){
        int aux=a[i];
        a[i]=a[min];
        a[min]=aux;
       
        reconstituire(a,min);
    }
 }

 void heapsort(int a[]){
   
     construieste(a);
   
   
   
     for(int i=a.length-1;i>=1;i--){
         int aux=a[0];
         a[0]=a[i];
         a[i]=aux;
       
    heapsize=heapsize-1;
   
        reconstituire(a,0);
       
     }
 }

void construieste(int a[]){
    heapsize=0;
    for(int i=1;i<a.length;i++)
        insert(a,a[i]);
}

void construiesteiara(int a[]){
    heapsize=a.length;
   
    for(int i=(a.length-1)/2;i>=0;i--)
        reconstituire(a,i);
}

public static void main(String[] args){
   
    heap h=new heap();
   
    //h.construiesteiara(a);
    h.heapsort(a);
   
    //System.out.println("ceva");
   
    for(int k=0;k<a.length;k++){
        System.out.println(a[k]);
    }
}
}

Sortarile

public class tema {
static void inssort(int x[]){
      int j=0;
      int i=0;
      int n=x.length;
      for(j=0;j<n;j++){
        int k=x[j];
        i=j-1;
      while((i>=0)&&(x[i]>k)){x[i+1]=x[i];
                i=i-1;       }
              x[i+1]=k;     }
      }

static void selsort1(int x[]){    //selsort1
        int i=0;
        int j=0;
        int n=x.length;
    for(i=0;i<n-1;i++){
        int min=i;
       
      for(j=i+1;j<n;j++)
          if(x[j]<x[min])
              min=j;
        int a=x[i];
        x[i]=x[min];
        x[min]=a;
    }
}
/*static void selsort2(int x[]){
        int i=0;
        int j=0;
        int n=x.length;
    for(i=0;i<n-1;i++)
        for(j=i+1;j<n;j++){
            if(x[j]<x[i])
           
               
        }
   
}*/
static void bubblesort1(int x[]){
        int i=0;
        int j=0;
        int n=x.length;
   
    for( i=0;i<n;i++)
        for(j=0 ;j<n-1;j++)
                if(x[j]>x[j+1]){
                    int a=x[j];
                    x[j]=x[j+1];
                    x[j+1]=a;
                }
}
static void bubblesort2(int x[]){           
    int i=0;
    int j=0;
    int n=x.length;

for( i=0;i<n-1;i++)
    for(j=0 ;j<n-i;j++)
            if(x[j]>x[j+1]){
                int a=x[j];
                x[j]=x[j+1];
                x[j+1]=a;
            }
}

static void quicksort(int x[], int primul,int ultimul){
       
        int temp,min,max,mijl;
       
        mijl=x[primul+(ultimul-primul)/2];
        min=primul;max=ultimul;
       
        do
        {   
                while ( x[min]< mijl )
                    min++;
                while ( x[max]>mijl )
                    max--;
               
                if (min<=max){
                    temp=x[min];
                    x[min++]=x[max];
                    x[max--]=temp;
                                   
                }
               
        }     while(min<=max);   
               
              
                if (primul < max){
                    quicksort (x,primul,max);}
                if (ultimul > min){
                    quicksort (x,min,ultimul);}
           
}

static void mergesort(int x[],int st, int m , int dr){
       
        int b[]=new int[100000];
                       
                       
          int i,j,k;
       
        i=0;j=st;
       
        while(j<=m)
            b[i++]=x[j++];
       
        i=0;k=st;
       
        while((k<j)&& (j<=dr))
            if(b[i]<=x[j])
                x[k++]=b[i++];
            else
                x[k++]=x[j++];
   
        while(k<j)
            x[k++]=b[i++];
}
static void merge(int x[],int st,int dr){
    if(st<dr)
    {
        int m =(st+dr)/2;
        merge(x,st,m);
        merge(x,m+1,dr);
        mergesort(x,st,m,dr);
    }
}

public static void main(String [] args){
   
      int tab[] = new int[100000];
      for(int i=0;i<tab.length;i++)
        tab[i]=(int)Math.round(Math.random()*10000);
      long t1=System.currentTimeMillis();
               inssort(tab);                        // in jur de 6 secunde // 8 CPU'S
      long t2=System.currentTimeMillis();
          long d=t2-t1;
         
         
     //     for(int k=0;k<tab.length;k++)
    //      System.out.println(tab[k]);
         
          
              System.out.println(d);
             
/////////////////////////////////////////////////////////////             
             
      int tab1[]=new int[100000];
      for(int i=0;i<tab1.length;i++)
          tab1[i]=(int)Math.round(Math.random()*10000);
      long t3=System.currentTimeMillis();
          selsort1(tab1);                        // in jur de 14    secunde               
      long t4=System.currentTimeMillis();
         long e=t4-t3;  
              
        // for(int k=0;k<tab1.length;k++)
        //     System.out.println(tab1[k]);
         
              System.out.println(e);
             
////////////////////////////////////////////////////////////             
         
     int tab2[]=new int[100000];
     for(int i=0;i<tab2.length;i++)
         tab2[i]=(int)Math.round(Math.random()*10000);
     long t5=System.currentTimeMillis();
         bubblesort1(tab2);                        // in jur de  36 secunde
     long t6=System.currentTimeMillis();
         long f=t6-t5;
        
     //    for(int k=0;k<tab2.length;k++)
     //        System.out.println(tab2[k]);
        
         System.out.println(f);
        
////////////////////////////////////////////////////////////////             
     
     int tab3[]=new int[100000];
     for(int i=0;i<tab3.length;i++)
         tab3[i]=(int)Math.round(Math.random()*10000);
    
     long t7=System.currentTimeMillis();
    
     quicksort (tab3,0,99999);            // 14 milisecunde :)) asta e mai rapid ca Buggati :))
    
     long t8=System.currentTimeMillis();
         long g=t8-t7;
        
         //for(int k=0;k<tab3.length;k++)
         //    System.out.println(tab3[k]);
        
         System.out.println(g);

////////////////////////////////////////////////////////////////
        
         int tab4[]=new int[100000];
         for(int i=0;i<tab3.length;i++)
             tab4[i]=(int)Math.round(Math.random()*10000);
        
         long t9=System.currentTimeMillis();
        
             merge(tab4,0,99999);            // 7 secunde    
            
           long t10=System.currentTimeMillis();
             long h=t10-t9;
        
         //for(int k=0;k<tab4.length;k++)
         //    System.out.println(tab4[k]);
        
        System.out.println(h);
   
      }
}

grafuri

import java.awt.*;



public class Vertex {

   
        Color color;
        Vertex predecessor;
        int distance;
        int discovered;
        int finalized;
        char label;
        int index;
        int infinite = 100;
       
    public Vertex(int i){
        index=i;
        color=Color.white;
        distance=infinite;
        predecessor=null;
    }
}

//////////////////////////////////////////////////

import java.awt.*;
import java.util.*;


public class Graph {
   
        int maxVerts = 20;
        int nVerts = 0;
        ArrayList vertexList = new ArrayList();
        int A[][] = new int[maxVerts][maxVerts];
       
public Graph(){
   
    for(int i=0; i<maxVerts ; i++)
        for(int j=0 ; j<maxVerts; j++)
             A[i][j]=0;
}
public void addVertex(){
    vertexList.add(new Vertex(nVerts++));
}
public void addEdge(int v1,int v2){
    A[v1][v2]=1;
    A[v2][v1]=1;
}
public void addEdge (int v1, int v2, int w) {
     
      A[v1][v2] = w;
      A[v2][v1] = w;
   
     }



public static void main( String[] args){
    Graph graph = new Graph();
    graph.addVertex();
    graph.addVertex();
    graph.addVertex();
    graph.addVertex();
    graph.addEdge(0,1);
    graph.addEdge(1,2);
    graph.addEdge(0,3);
    graph.BFS(0);
    graph.DFS();
    graph.DJIKSTRA(0);
}
   
public void BFS(int s){   // asta nu intra la examen
        System.out.println("Parcurgerea in latime");
    LinkedList queue = new LinkedList();
    ((Vertex)vertexList.get(s)).color=Color.gray;
    ((Vertex)vertexList.get(s)).distance=0;
   
    queue.addFirst(vertexList.get(s));
   
    while(!queue.isEmpty()){
        Vertex u=(Vertex)queue.getLast();
       
        System.out.println(u.index);
     for(int v=0;v<nVerts;v++)
         if(A[v][u.index]==1&&((Vertex)vertexList.get(v)).color==Color.white){
             ((Vertex)vertexList.get(v)).color=Color.gray;
             ((Vertex)vertexList.get(v)).distance=u.distance+1;
             ((Vertex)vertexList.get(v)).predecessor=u;
             queue.addFirst(vertexList.get(v));
         }
         queue.removeLast();
         u.color=Color.black;
     }       
    }
public void DFS(){
    System.out.println("Parcurgerea in adancime");
   
    int t;
   
    Iterator u= vertexList.iterator();
    Vertex v;
   
      while(u.hasNext()){
          ((Vertex)u.next()).color=Color.white; }
     t=0;
   
     u=vertexList.iterator();
   
     while (u.hasNext()){
         v = (Vertex)u.next();
          if (v.color==Color.white)
              EXPLORARE(v);
     }
}
public void EXPLORARE (Vertex u){
    u.color=Color.gray;
   
    int t; t=0;
   
    System.out.println(u.index);
    u.distance=t;
    t++;
   
    Iterator i= vertexList.iterator();
     while (i.hasNext()){
         Vertex v=(Vertex)i.next();
         if (v.color==Color.white)
             v.predecessor=u;
     }
     u.color = Color.black;
     u.finalized=t;
     t++;       
}
public void DJIKSTRA(int s){
   
        System.out.println("Algoritmul D");
       
        Vertex u;
    Iterator i = vertexList.iterator();
      while (i.hasNext()){
          u=(Vertex)i.next();
          u.distance=u.infinite;
          u.predecessor=null;
      }
    ((Vertex)vertexList.get(s)).distance=0;
      ArrayList DList = (ArrayList) vertexList.clone();
     
      while (!DList.isEmpty()){
          int min =0;
          for(int k=1;k<DList.size();++k)
              if(((Vertex)DList.get(min)).distance > ((Vertex)DList.get(k)).distance)
                min=k;
          u=(Vertex)DList.get(min);
          DList.remove(min);
    for(int k=0; k<nVerts;k++)
             if(A[k][u.index]!=0)
                 if(((Vertex)vertexList.get(k)).distance > u.distance + A[k][u.index])
                 {
                     ((Vertex)vertexList.get(k)).distance = u.distance + A[k][u.index];
                     ((Vertex)vertexList.get(k)).predecessor=u;
                 }
    for( int k=0 ; k< nVerts ; ++k){
              System.out.println("Distance: "+((Vertex)vertexList.get(k)).distance+ " ");
           
          }
      }
}
}
   
   

cmlsc , regine si turnuri

public class CMLSC {



 public void CMLSC(int A[]){

    int n; int i;

    n=A.length;
   int imax=A.length-1;

   int L[]=new int[A.length];
   int S[]=new int[A.length];

for(i=n-1; i>=0; i--){
      S[i]=-1;
      L[i]=1;

for(int j=i+1;j<n;j++){
     if(A[j]>A[i]&&L[j]+1>L[i]){
         L[i]=L[j]+1;
         S[i]=j;

          } }
     if(L[i]>L[imax])
          imax=i;

    }

  i=imax;
   while(i!=-1){
    System.out.println(A[i]);
       i=S[i];
   }
  }


public static void main(String[] args) {

                int A[]=new int[12];

                A[0]=3;    A[1]=5;   A[2]=76;     A[3]=1;
                A[4]=45;    A[5]=2;   A[6]=67;     A[7]=52;
                A[8]=90;   A[9]=0;   A[10]=4;   A[11]=15;

                CMLSC cmlsc=new CMLSC();
                cmlsc.CMLSC(A);


        }

}


---------------------------------------------------------------------




public class Hanoi {


    public static void hanoi(int n, String from, String temp, String to) {
        if (n == 0) return;
        hanoi(n-1, from, to, temp);
        System.out.println("Move disc " + n + " from " + from + " to " + to);
        hanoi(n-1, temp, from, to);
    }

    public static void main(String[] args) {

        hanoi(3, "A", "B", "C");
    }
}



---------------------------------------------------------------------------




public class regine {

     int S[]=new int[4];

public  void queen(int k){

  int n=4;


   for(int i=0;i<n;i++){

     if (accept(k,i)){
         S[k]=i;

         if(k==n-1){
           for(k=0;k<n;k++){
             System.out.print(S[k]+ " ");
           }
     }
     else queen(k+1);
     }
   }
}
public boolean accept(int k , int i){

   int j;


    for(j=0;j<=k-1;j++){
      if(S[j]==i) return false;

    if (Math.abs(j-k)==Math.abs(S[j]-i))
      return false;
    }
      return true;
    }




  public static void main(String[] args) {
    regine regine1 = new regine();
    regine1.queen(0);



  }

}

Arbori / Binary tree / Java

public class Node {
 
    int key;

     float data;
 
     Node leftChild;

     Node rightChild;

     Node parent;



public Node(int k){
 
    key=k;
   
  }

}


&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

public class BinaryTree {

  Node root=null;

  public BinaryTree(){
      insert(new Node(7));
      insert(new Node(1));
      insert(new Node(5));
}

static void inordine(Node x){ // traversarea arborelui in inordine
      if (x!=null){
        inordine(x.leftChild);
        System.out.println(x.key);
        inordine(x.rightChild);
      }
    }
static void preordine(Node x){  // traversarea arborului in preordine
    if (x!=null){
        System.out.println(x.key);
        preordine(x.leftChild);
        preordine(x.rightChild);
    }
}
static void postordine(Node x){ // traversarea arborului in postordiine
    if (x!=null){
        postordine(x.leftChild);
        postordine(x.leftChild);
        System.out.println(x.key);
    }
}

static Node cauta_rec(Node x, int k){ // cautarea recursiva
      if((x==null)||(k==x.key)){
         return x;
      }
      if(k<x.key){
     return cauta_rec(x.leftChild,k);
      }
        else
      return cauta_rec(x.rightChild,k);

}
static Node cautare_ite(Node x,int k){ // cautare iterativa mult mai eficienta !!!! :P
    while((x!=null)&&(k!=x.key)){
        if (k<x.key)
            x=x.leftChild;
        else
            x=x.rightChild;
    }
    return x;
   
}
static Node minim (Node x){    // Minimul :)
    while(x.leftChild!=null){
        x=x.leftChild;
        }
    return x;
}

static Node maxim(Node x){    // maximul
    while(x.rightChild!=null){
        x=x.rightChild;
    }
    return x;
}

static Node succesor(Node x){  // succesorul
    if (x.rightChild!=null)
        return minim(x.rightChild);
    Node y=x.parent;
   
    while((y!=null)&&(x==y.rightChild)){
        x=y;
        y=y.parent;
    }
    return y;
}

Node sterge(Node z){         // stergerea
        Node x,y;
    if((z.leftChild==null)||(z.rightChild==null))
         y=z;
    else
        y=succesor(z);
    if(y.leftChild!=null)
        x=y.leftChild;
    else
        x=y.rightChild;
    if(x!=null)
        x.parent=y.parent;
    if(y.parent==null)
        root=x;
    else if (y==y.parent.leftChild)
        y.parent.leftChild=x;
    else
        y.parent.rightChild=x;
    if(y!=z)
        z.key=y.key;
       
        return y;
}

public void insert(Node z){
    Node y=null;
    Node x=root;

    while(x!=null){
      y=x;
      if(z.key<x.key) x=x.leftChild;
        else x=x.rightChild;
    }
    z.parent=y;
    if(y==null)root=z;
      else if(z.key<y.key) y.leftChild=z;
        else y.rightChild=z;
  }

  public static void main(String[] args) {
    BinaryTree binaryTree1 = new BinaryTree();
    BinaryTree.inordine(binaryTree1.root); // traversarea in ordine
   
    Node x=BinaryTree.cautare_ite(binaryTree1.root,7); // cautarea recursiva
    System.out.println(x.key);
   
    x=BinaryTree.minim(binaryTree1.root); // minimul
    System.out.println(x.key);
   
    x=BinaryTree.maxim(binaryTree1.root); // maximul
    System.out.println(x.key);
   
    Node y=new Node(4);    // apelul succesorului
    binaryTree1.insert(y);
    System.out.println(succesor(y));

  
   
    binaryTree1.sterge(binaryTree1.root);   //stergerea
    BinaryTree.inordine(binaryTree1.root);
  }
 
}