Novas2

BuscaBinaria.java

@@ -0,0 +1,29 @@
+
+public class BuscaBinaria {
+
+	public int posicao;
+
+	BuscaBinaria(int[] array, int Objetivo){
+		this.posicao = BinarySearch(Objetivo, array);
+	}
+	public int GetResultado() {
+		return this.posicao;
+	}
+	public int BinarySearch(int objetivo, int[] array) {
+
+		int comeco = 0;
+		int fim = array.length - 1; 
+        while (comeco <= fim) { 
+            int meio = comeco + (fim-comeco)/2; 
+            if (array[meio] == objetivo) 
+                return meio; 
+            if (array[meio] < objetivo) 
+                comeco = meio + 1; 
+            else
+            	fim = meio - 1; 
+        }
+        return -1; 
+    }
+}
+
+

Mergesort.java

@@ -0,0 +1,53 @@
+
+class MergeSort 
+{ 
+    void merge(int vetor[], int inicio, int meio, int fim) 
+    { 
+        int n1 = meio- inicio+ 1; 
+        int n2 = fim -meio;
+        int Inicial[] = new int [n1]; 
+        int Final[] = new int [n2];
+        for (int i=0; i<n1; ++i) 
+        	Inicial[i] = vetor[inicio + i]; 
+        for (int j=0; j<n2; ++j) 
+            Final[j] = vetor[meio + 1+ j];
+        int i = 0, j = 0;
+        int k = inicio; 
+        while (i < n1 && j < n2) 
+        { 
+            if (Inicial[i] <= Final[j]) 
+            { 
+                vetor[k] = Inicial[i]; 
+                i++; 
+            } 
+            else
+            { 
+                vetor[k] = Final[j]; 
+                j++; 
+            } 
+            k++; 
+        } 
+        while (i < n1) 
+        { 
+            vetor[k] = Inicial[i]; 
+            i++; 
+            k++; 
+        } 
+        while (j < n2) 
+        { 
+            vetor[k] = Final[j]; 
+            j++; 
+            k++; 
+        } 
+    } 
+    void sort(int vetor[], int inicio, int fim) 
+    { 
+        if (inicio < fim) 
+        {
+            int meio= (inicio+fim)/2; 
+            sort(vetor, inicio, meio); 
+            sort(vetor , meio+1, fim); 
+            merge(vetor, inicio, meio, fim); 
+        } 
+    }
+}

Quicksort.java

@@ -0,0 +1,34 @@
+
+class QuickSort 
+{ 
+
+    int partition(int arr[], int low, int high) 
+    { 
+        int pivot = arr[high];  
+        int i = (low-1);  
+        for (int j=low; j<high; j++) 
+        { 
+            if (arr[j] <= pivot) 
+            { 
+                i++;
+                int temp = arr[i]; 
+                arr[i] = arr[j]; 
+                arr[j] = temp; 
+            } 
+        } 
+        int temp = arr[i+1]; 
+        arr[i+1] = arr[high]; 
+        arr[high] = temp; 
+
+        return i+1; 
+    } 
+    void sort(int arr[], int low, int high) 
+    { 
+        if (low < high) 
+        { 
+            int pi = partition(arr, low, high); 
+            sort(arr, low, pi-1); 
+            sort(arr, pi+1, high); 
+        } 
+    } 
+}

fila.java

@@ -0,0 +1,46 @@
+
+public class fila {
+	public processo processoAtual;
+	public fila proximaFila;
+
+
+	public fila() {
+		this.processoAtual = null;
+		this.proximaFila = null;
+	}
+
+	public void inserirfila(processo processoNovo) {
+		if(this.processoAtual == null) {
+			this.processoAtual = processoNovo;
+			this.proximaFila = new fila();
+
+		}else {
+			this.proximaFila.inserirfila(processoNovo);
+		}
+	}
+	public processo removerfila() {
+		processo removido = this.processoAtual;
+		this.processoAtual = this.proximaFila.processoAtual;
+		this.proximaFila = this.proximaFila.proximaFila;
+		return removido;
+	}
+
+	public String checkfila(String vazia) {
+		if(this.proximaFila.proximaFila == null) {
+			vazia = vazia + " " + this.processoAtual.getPrioridade() + " "  + this.processoAtual.getTempo();
+
+		}else {
+			vazia = vazia + " " + this.processoAtual.getPrioridade() + " "  + this.processoAtual.getTempo() + " &&"+ this.proximaFila.checkfila(vazia);
+		}
+		return vazia;
+
+	}
+
+	public boolean vaziafila() {
+		if(this.proximaFila == null) {
+			return true;
+		}
+		return false;
+	}
+
+}

pilha.java

@@ -0,0 +1,51 @@
+
+public class pilha {
+	public processo processoAtual;
+	public pilha proximaPilha;
+
+
+	public pilha() {
+		this.processoAtual = null;
+		this.proximaPilha = null;
+	}
+
+	public void inserirpilha(processo processoNovo) {
+		if(this.processoAtual == null) {
+			this.processoAtual = processoNovo;
+			this.proximaPilha = new pilha();
+
+		}else {
+			this.proximaPilha.inserirpilha(processoNovo);
+		}
+	}
+	public processo removerPilha() {
+		if(this.proximaPilha.proximaPilha == null) {
+			processo removido = this.processoAtual;
+			this.processoAtual = null;
+			this.proximaPilha = null;
+			return removido;
+		}else {
+			return this.proximaPilha.removerPilha();
+		}
+	}
+
+	public String checkpilha(String vazia) {
+		if(this.proximaPilha.proximaPilha == null) {
+			vazia = " " + this.processoAtual.getPrioridade() + " "  + this.processoAtual.getTempo() + vazia;
+
+		}else {
+			vazia = this.proximaPilha.checkpilha(vazia)+ " && " + this.processoAtual.getPrioridade() + " "  + this.processoAtual.getTempo() + " " + vazia;
+		}
+		return vazia;
+		}
+
+	public boolean vaziaPilha() {
+		if(this.proximaPilha == null) {
+			return true;
+		}
+		return false;
+	}
+	public int tempoTrabalhado(int tempo) {
+		return this.processoAtual.trabalhado(tempo);
+	}
+	}

teste.java

@@ -0,0 +1,12 @@
+
+public class teste {
+
+	public static void main(String[] args) {
+		int[] arrayteste = {10,8,6,4,2,0,1,3,5,7,9};
+		 MergeSort ordem = new MergeSort(); 
+	        ordem.sort(arrayteste, 0, arrayteste.length-1); 
+	        for (int i = 0; i < arrayteste.length; i++) {
+				System.out.print(arrayteste[i]+ " ");
+			}
+	}
+}