Merge pull request larissalages#1 from larissalages/master

Pull

Author: Meuman

classical_algorithms/Binary search.py

@@ -0,0 +1,23 @@
+def binary(arr,low,high,x):
+    while low < high:
+        mid = low + (high-1) // 2
+        if(arr[mid] == x):
+            return mid
+        elif(arr[mid] <x):
+            low = mid + 1
+        else:
+            high = mid - 1
+    return -1
+
+n =int(input("Enter a sorted list of number\n"))
+arr =[]
+for i in range(n):
+    arr.append(int(input()))
+
+x =int(input("ENter the number to find\n"))
+
+result = binary(arr,0,len(arr)-1,x)
+if(result == -1):
+    print("Element not found")
+else:
+    print("Element found at ",result+1," position")

classical_algorithms/Heap Sort.py

@@ -0,0 +1,40 @@
+def heapify(arr, n, i): 
+	largest = i # Initialize largest as root 
+	l = 2 * i + 1	 # left = 2*i + 1 
+	r = 2 * i + 2	 # right = 2*i + 2 
+
+	# See if left child of root exists and is 
+	# greater than root 
+	if l < n and arr[i] < arr[l]: 
+		largest = l 
+
+	# See if right child of root exists and is 
+	# greater than root 
+	if r < n and arr[largest] < arr[r]: 
+		largest = r 
+
+	# Change root, if needed 
+	if largest != i: 
+		arr[i],arr[largest] = arr[largest],arr[i] # swap 
+
+		# Heapify the root. 
+		heapify(arr, n, largest) 
+
+def heapSort(arr): 
+	n = len(arr) 
+
+	# Build a maxheap. 
+	for i in range(n//2 - 1, -1, -1): 
+		heapify(arr, n, i) 
+
+	# One by one extract elements 
+	for i in range(n-1, 0, -1): 
+		arr[i], arr[0] = arr[0], arr[i] # swap 
+		heapify(arr, i, 0) 
+
+print('Enter a list of numbers')
+arr = list(map(int,input().split()))
+heapSort(arr) 
+print('After performing heap sort')
+for i in arr:
+    print(i,end =' ')

classical_algorithms/Linear Search .py

@@ -0,0 +1,31 @@
+def linear(arr,n,x):
+    for i in range(n):
+        if(arr[i] == x):
+            return i
+    return -1
+
+n = int(input("Enter the total number of elements\n"))
+arr =list(map(int,input().split()))
+x = int(input("Enter which element you want to find\n"))
+result = linear(arr,n,x)
+if (result == -1):
+        print("Element not found")
+else:
+        print("Element found at" ,result+1,"position")
+
+        
+
+
+    
+
+
+    
+
+
+
+    
+
+    
+
+
+    

classical_algorithms/MergeSort.java

@@ -0,0 +1,111 @@
+import java.util.*;
+import java.lang.*;
+
+
+class MergeSort
+{
+
+	public void sort(int a[], int low, int high)
+	{
+		if(low<high)
+		{
+			int mid=(low+high)/2;
+			sort(a,low,mid);
+			sort(a,mid+1,high);
+			merge(a,low,mid,high);
+		}
+	}
+
+	public void merge(int a[], int low, int mid, int high)
+	{
+		int h=low, i=low, j=mid+1,k;
+		int b[]=new int[high+1];
+
+		while((h<=mid) && (j<=high))
+		{
+			if(a[h]<a[j])
+			{
+				b[i]=a[h];
+				h=h+1;
+			}
+			else
+			{
+				b[i]=a[j];
+				j=j+1;
+			}
+		i=i+1;
+		}
+
+
+		if(h>mid)
+		{
+			for(k=j;k<=high;k++)
+			{
+				b[i]=a[k];
+				i=i+1;
+			}
+		}
+
+
+		if(j>high)
+		{
+			for(k=h;k<=mid;k++)
+			{
+				b[i]=a[k];
+				i=i+1;
+			}
+		}
+
+		for(k=low;k<=high;k++)
+		{
+			a[k]=b[k];
+		}
+	}
+
+   	static void printArray(int a[], int n)
+	{
+	
+		for(int i=0;i<n;i++)
+		{
+			System.out.print( a[i]+ "\t");
+		}
+	}
+
+ 	public static void main(String args[])
+	{
+		try{
+			int low,high,mid;
+			int n,i;
+
+			Scanner scan= new Scanner(System.in);
+	
+			System.out.println("How many elements do you want in the array?");
+			n=scan.nextInt();
+			int a[]= new int[n];
+			System.out.println("Enter the array elements one by one");
+			for(i=0;i<n;i++)
+			{
+				a[i]=scan.nextInt();		
+			}
+
+			System.out.println("Array before sorting is:");
+			printArray(a, n);
+			low=0;
+			high=n-1;
+
+  			MergeSort obj = new MergeSort(); 
+      			obj.sort(a, low, high);
+                  			System.out.println();
+
+			System.out.println("The sorted array is: ");
+			printArray(a, n);
+
+		}catch(Exception e){e.printStackTrace();}
+                   
+	}
+}
+
+
+
+
+

classical_algorithms/Sieve of Eratosthenes.py

@@ -0,0 +1,28 @@
+import math
+# taking input
+n  = int(input())
+# making a list named primes
+    # initialize primes with 1 only 
+# here 1 represent the value is prime 
+primes = [1]*(n+1)
+
+# making first and second values as 0
+# as  0, 1 is not a prime and start by checking 
+# from second value
+primes[0] = 0
+primes[1] = 0
+
+# looping through 2,sqrt(n)+1 as every number 
+# comes with 2 factor if first factor is seen then
+# we don't have to look for second one
+# in second loop we are initialize all multiple of 
+# i in first loop
+for i in range(2,int(math.sqrt(n)+1)):
+    if primes[i] ==1:
+    	for  j in range(i*i,n+1,i):
+	    	primes[j] = 0
+
+# printing all primes
+for i in range(len(primes)):
+    if primes[i] == 1:
+        print(i,end = " ")

classical_algorithms/mergesort.cpp

@@ -0,0 +1,62 @@
+void merge(int a[], int l, int m, int r)
+{
+  int l1 = m - l + 1;
+  int l2 = r - m;
+
+  int temp1[l1];
+  int temp2[l2];
+
+  for (int i = 0; i < l1; i++)
+  {
+    temp1[i] = a[l + i];
+  }
+  for (int j = 0; j < l2; j++)
+  {
+    temp2[j] = a[m + j + 1];
+  }
+  int i = 0;
+  int j = 0;
+  int k = l;
+
+  while (i < l1 && j < l2)
+  {
+    if (temp1[i] < temp2[j])
+    {
+      a[k] = temp1[i];
+      i++;
+    }
+
+    else
+    {
+      a[k] = temp2[j];
+      j++;
+    }
+
+    while (i < l1)
+    {
+      a[k] = temp1[i];
+      i++;
+      k++;
+    }
+
+    while (j < l2)
+    {
+      a[k] = temp2[j];
+      j++;
+      k++;
+    }
+  }
+}
+
+void mergesort(int a[], int l, int r)
+{
+  if (l < r)
+  {
+    int m = r + (l - r) / 2;
+
+    mergesort(a, l, m);
+    mergesort(a, m + 1, r);
+
+    merge(a, l, m, r);
+  }
+}

classical_algorithms/selection sort.py

@@ -0,0 +1,15 @@
+n = int(input())
+li = []
+for i in range(n):
+    m = int(input())
+    li.append(m)
+
+for i in range(n):
+    mini = i 
+    for j in range(i+1,n):
+        if(li[j] < li[mini]):
+            mini = j
+    temp = li[i]
+    li[i] = li[mini]
+    li[mini] = temp
+    print(li)