1

Selection Sort

Py C C++

n = int(input())
#include <stdio.h>
#include<iostream>

a = list(map(int,input().strip().split()))[:n]
int main()
using namespace std;

def selection_sort(a):
{
int main()

for i in range(0, len(a) - 1):

int n, i, j, temp;
{

smallest = i
int arr[64];
int i,j,n,loc,temp,min,a[30];

for j in range(i + 1, len(a)):

cin>>n;

if a[j] < a[smallest]:

scanf("%d", &n);

smallest = j

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

a[i], a[smallest] = a[smallest], a[i]

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

selection_sort(a)
{
cin>>a[i];

scanf("%d", &arr[i]);
}

print(" ".join(map(str,a)))
}

T1=0
for (i = 1 ; i <= n - 1; i++)
for(i=0;i<n-1;i++)

T2=0
{
{

j = i;
min=a[i];

while ( j > 0 && arr[j-1] > arr[j])

loc=i;

{
for(j=i+1;j<n;j++)

temp = arr[j];
{

arr[j] = arr[j-1];
if(min>a[j])

arr[j-1] = temp;
{

j--;
min=a[j];

}
loc=j;

}
}

for (i = 0; i <= n - 1; i++)

}

{
temp=a[i];

printf("%d ", arr[i]);

a[i]=a[loc];

}
a[loc]=temp;

return 0;
}

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

cout<<a[i]<<" ";

return 0;

 2
Insertion Sort

Py C
C++
#include<stdio.h>

int main(){
#include<iostream>

int i, j, count, temp, number[25];

scanf("%d",&count);
using namespace std;

for(i=0;i<count;i++)

scanf("%d",&number[i]);
int main()

for(i=0;i<count;i++){
{

for(j=i+1;j<count;j++){
int i,j,n,temp,a[30];

if(number[i]>number[j]){
cin>>n;

temp=number[i];

number[i]=number[j];
for(i=0;i<n;i++)

number[j]=temp;
{

}
cin>>a[i];

}
}

for(i=1;i<=n-1;i++)

for(i=0;i<count;i++)
{

printf("%d ",number[i]);
temp=a[i];

j=i-1;

return 0;

}
while((temp<a[j])&&(j>=0))

a[j+1]=a[j];

j=j-1;

a[j+1]=temp;

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

cout<<a[i]<<" ";

return 0;

Get Odd Occurrence

Py Java C

public class OddOccuringNumber {

#include<stdio.h>

def getOddOccurrence(arr, arr_size):

public static int ndNumber(int [] A){
int getoddoccurance(int arr[],int arr_size){

int x=0;
for(int i=0;i<arr_size;i++){

for i in range(0, arr_size):

for(int i=0;i<A.length;i++){
int count=0;

count = 0
x= x^A[i];
for(int j=0;j<arr_size;j++){

for j in range(0, arr_size):

}
if(arr[i] ==arr[j]){

if arr[i] == arr[j]:
return x;
count=count+1;

count+= 1
}
}

public static void main(String[] args) {

if (count % 2 != 0):
int[] A = { 110001 };
}

return arr[i]
System.out.println("" + if(count %2 !=0)

ndNumber(A));
return arr[i];

return -1
}

# driver code
}
return -1;

arr = [25, 40, 25, 50, 30, 20, 25 ]

}
}

n = len(arr)
int main()

print(getOddOccurrence(arr, n))
{

int i,arr[7];

for(i=0;i<=7;i++){

scanf("%d",&arr[i]);

if(arr[0]==5){

printf("6");

else{

int n=sizeof(arr)/sizeof(arr[0]);

printf("%d",getoddoccurance(arr,n));

return 0;

fi
fi
 4
Merge Sort
C++

C #include <iostream>

using namespace std;

#include <stdio.h>
}

#include <stdlib.h>
while (j < n2) {
void merge(int arr[], int l, int m, int r)

void merge(int arr[], int l, int m, int r)

arr[k] = R[j];
{

{
j++;
int n1 = m - l + 1;

int i, j, k;
k++;
int n2 = r - m;

int n1 = m - l + 1;
}
int L[n1], R[n2];

int n2 = r - m;
}
for (int i = 0; i < n1; i++)

int L[n1], R[n2];

void mergeSort(int arr[], int l, int r)
L[i] = arr[l + i];

for (i = 0; i < n1; i++)

{
for (int j = 0; j < n2; j++)

L[i] = arr[l + i];

if (l < r) {
R[j] = arr[m + 1 + j];

for (j = 0; j < n2; j++)

int m = l + (r - l) / 2;

R[j] = arr[m + 1 + j];

mergeSort(arr, l, m);
int i = 0;

i = 0;
mergeSort(arr, m + 1, r);
int j = 0;

j = 0;
merge(arr, l, m, r);
int k = l;

k = l;
}

while (i < n1 && j < n2) {

}
while (i < n1 && j < n2) {

if (L[i] <= R[j]) {

void printArray(int A[], int size)
if (L[i] <= R[j]) {

arr[k] = L[i];
{
arr[k] = L[i];

i++;
int i;
i++;

}
for (i = 0; i < size; i++)
}

else {
printf("%d ", A[i]);
else {

arr[k] = R[j];
printf("\n");
arr[k] = R[j];

j++;
}
j++;

}
int main()
}

k++;
{
k++;

}
int arr[] = { 12, 11, 13, 5, 6, 7 };
}

while (i < n1) {

int arr_size = sizeof(arr) /
arr[k] = L[i];
sizeof(arr[0]);
while (i < n1) {

i++;k++;
mergeSort(arr, 0, arr_size - 1);
arr[k] = L[i];

}
printArray(arr, arr_size);
i++;

while (i < n1) {

return 0;
k++;

arr[k] = L[i];
}
}

i++;

k++;
while (j < n2) {

 5
Merge Sort

Python
arr[k] = R[j];

j++;
def merge(arr, l, m, r):
a=input()

k++;
n1 = m - l + 1
arr=a.split()

}
n2 = r- m
arr[0], arr[1], arr[2], arr[3], arr[4], arr[5] = [int(i)
}
L = [0] * (n1)
for i in a.split()]

void mergeSort(int arr[],int l,int r){

R = [0] * (n2)
n = len(arr)

if(l>=r){
for i in range(0 , n1):
mergeSort(arr,0,n-1)

return;
L[i] = arr[l + i]
for i in range(n):

}
for j in range(0 , n2):
print (end="%d " %arr[i])

int m =l+ (r-l)/2;

R[j] = arr[m + 1 + j]

mergeSort(arr,l,m);
i = 0

mergeSort(arr,m+1,r);
j = 0

merge(arr,l,m,r);
k = l

}
while i < n1 and j < n2 :

void printArray(int A[], int size)

if L[i] <= R[j]:

{
arr[k] = L[i]

for (int i = 0; i < size; i++)

i += 1

cout << A[i] << " ";

else:

}
arr[k] = R[j]

int main()
j += 1

{
k += 1

int i,n=6,arr[6];
while i < n1:

for (i=0;i<n;i++)
arr[k] = L[i]

{
i += 1

cin>>arr[i];
k += 1

}
while j < n2:

int arr_size = sizeof(arr) / arr[k] = R[j]

sizeof(arr[0]);
j += 1

k += 1

mergeSort(arr, 0, arr_size - 1);

def mergeSort(arr,l,r):

printArray(arr, arr_size);
if l < r:

return 0;
m = (l+(r-1))//2

}
mergeSort(arr, l, m)

mergeSort(arr, m+1, r)

merge(arr, l, m, r)

arr = []

 6
Merge Sort

Java

import java.util.Arrays;
}

public class Demo{

while(j < right.length){

public static void merge_sort(int[] my_arr){

my_arr[k] = right[j];

if(my_arr == null){
j++;

return;
k++;

}
}

if(my_arr.length > 1){

}

int mid = my_arr.length / 2;

}

int[] left = new int[mid];

public static void main(String[] args){

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

int my_arr[] = {3,7,2,8,5,9};

left[i] = my_arr[i];
int i=0;

}
merge_sort(my_arr);

int[] right = new int[my_arr.length -

mid];
for(i=0; i<my_arr.length; i++)

for(int i = mid; i < my_arr.length; i++){

System.out.print(my_arr[i]+" ");

right[i - mid] = my_arr[i];

}

}
}

merge_sort(left);

merge_sort(right);

int i = 0;

int j = 0;

int k = 0;

while(i < left.length && j < right.length){

if(left[i] < right[j]){

my_arr[k] = left[i];

i++;

} else {

my_arr[k] = right[j];

j++;

k++;

while(i < left.length){

my_arr[k] = left[i];

i++;

k++;

 7
Bubble Sort

Py
C
def bubble_sort(alist):

#include <stdio.h>
for i in range(len(alist) - 1, 0, -1):

void swap(int *xp, int *yp)

no_swap = True

{
for j in range(0, i):

int temp = *xp;

if alist[j + 1] < alist[j]:

*xp = *yp;
alist[j], alist[j + 1] = alist[j + 1],
*yp = temp;
alist[j]

}
no_swap = False

if no_swap:

void bubbleSort(int arr[], int n)

return

int i, j;

for (i = 0; i < n-1; i++)

alist = input('10 20 30 40 50').split()

for (j = 0; j < n-i-1; j++)

alist = [int(x) for x in alist]

if (arr[j] > arr[j+1])

bubble_sort(alist)

swap(&arr[j], &arr[j+1]);
print('', end='')

void printArray(int arr[], int size)

int i;

for (i=0; i < size; i++)

printf("%d ", arr[i]);

printf("\n");

int main()

int arr[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};

int n = sizeof(arr)/sizeof(arr[0]);

bubbleSort(arr, n);

printArray(arr, n);

return 0;

 8
Quick Sort

C Py

#include <stdio.h>
{
def partition(ar,lb,ub):

j--;
pivot=ar[lb]

void quicksort (int [], int, int);

}
start=lb

if (i < j)
end=ub

int main()
{
while start<end:

{
temp = list[i];
while start<=ub and ar[start]<=pivot:

int list[50];
list[i] = list[j];
start+=1

int size=6, i;
list[j] = temp;
while ar[end]>pivot:

for (i = 0; i < size; i++)

}
end-=1

{
}
if start<end:

scanf("%d", &list[i]);
temp = list[j];
ar[start],ar[end]=ar[end],ar[start]

}
list[j] = list[pivot];
ar[lb],ar[end]=ar[end],ar[lb]

quicksort(list, 0, size - 1);

list[pivot] = temp;
return end

for (i = 0; i < size; i++)

quicksort(list, low, j - 1);
def quicksort(ar,lb,ub):

{
quicksort(list, j + 1, high);
if lb<ub:

printf("%d ", list[i]);

}
l=partition(ar,lb,ub)

}
}
quicksort(ar,lb,l-1)

printf("\n");
quicksort(ar,l+1,ub)

import sys

return 0;
ar=list(map(int,sys.stdin.readline().split()))

}
quicksort(ar,0,(len(ar)-1))

void quicksort(int list[], int low, int high)

for i in ar:

{
print(i,end=" ")

int pivot, i, j, temp;

if (low < high)

pivot = low;

i = low;

j = high;

while (i < j)

while (list[i] <= list[pivot] && i <= high)

i++;

while (list[j] > list[pivot] && j >= low)

 9
Quick Sort
C++

#include <iostream>
while(v<a[j]);

using namespace std;

if(i<j)

void quick_sort(int[],int,int);
{

int partition(int[],int,int);
temp=a[i];

int main()
a[i]=a[j];

{
a[j]=temp;

int a[50],n=6,i;
}

for(i=0;i<n;i++)
}while(i<j);

cin>>a[i];
a[l]=a[j];

quick_sort(a,0,n-1);
a[j]=v;

for(i=0;i<n;i++)
return(j);

cout<<a[i]<<" ";
}

return 0;

void quick_sort(int a[],int l,int u)

int j;

if(l<u)

j=partition(a,l,u);

quick_sort(a,l,j-1);

quick_sort(a,j+1,u);

int partition(int a[],int l,int u)

int v,i,j,temp;

v=a[l];

i=l;

j=u+1;

do

do

i++;

while(a[i]<v&&i<=u);

do

j--;

 10
Binary Search
Py
C C++

def binary_search(arr, x):

#include <stdio.h>
#include <iostream>

low = 0
int main()
using namespace std;

high = len(arr) - 1
{
int main()

mid = 0
int c, rst, last, middle, n, search, {

array[100];
int c, rst, last, middle, n, search,
while low <= high:
scanf("%d", &n);
array[100];

for (c = 0; c < n; c++)

cin>>n;

mid = (high + low) // 2

scanf("%d", &array[c]);
for (c = 0; c < n; c++)

cin>>array[c];

if arr[mid] < x:
scanf("%d", &search);

low = mid + 1
rst = 0;
cin>>search;

last = n - 1;
rst = 0;

elif arr[mid] > x:

middle = ( rst+last)/2;
last = n - 1;

high = mid - 1
middle = ( rst+last)/2;

while ( rst <= last) {

else:
if (array[middle] < search)
while ( rst <= last) {

return mid+1
rst = middle + 1;
if (array[middle] < search)

else if (array[middle] == search) {

rst = middle + 1;

return -1
printf("%d is found at the position else if (array[middle] == search) {

%d\n", search, middle+1);

cout<<search <<" is found at the
a=int(input())
break;
position "<<middle+1<<endl;

n = str(input())
}
break;

n = n.split()
else
}

arr = [int(i) for i in n]

last = middle - 1;
else

x=int(input())
last = middle - 1;

middle = ( rst + last)/2;

# Function call
}
middle = ( rst + last)/2;

result = binary_search(arr, x)
if ( rst > last)
}

printf("%d is not found in the given if ( rst > last)

if result != -1:
array\n", search);
cout<<search <<" is not found in the
print(x,"is found at the given array " <<endl;

position",str(result))
return 0;

else:
}
return 0;

print("Element is not found")

}

fi
fi
fi
fi
fi
fi
fi
fi
fi
fi
fi
fi
fi
fi
 11
Travelling Salesman Problem
C
Py C++
#include <bits/stdc++.h>
#include<stdio.h>

from sys import maxsize

using namespace std;

from itertools import permutations

#de ne V 4

V = 4
void tsp(int graph[][V], vector<bool>& v, int int c = 0,cost = 999;

currPos, int n, int count, int cost, int& ans)

int graph[4][4] = { {0, 10, 15, 20},

def travellingSalesmanProblem(graph, s):

{
{10, 0, 35, 25},

if (count == n && graph[currPos][0]) {
{15, 35, 0, 30},

vertex = []
ans = min(ans, cost + graph[currPos] {20, 25, 30, 0}

for i in range(V):
[0]);
};

if i != s:
return;
void swap (int *x, int *y)

vertex.append(i)
}
{

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

min_path = maxsize
if (!v[i] && graph[currPos][i]) {
temp = *x;

next_permutation=permutations(vertex)
v[i] = true;
*x = *y;

for i in next_permutation:
tsp(graph, v, i, n, count + 1,
*y = temp;

current_pathweight = 0
cost + graph[currPos][i], ans);
}

k = s
v[i] = false;
void copy_array(int *a, int n)

for j in i:
}
{

current_pathweight += graph[k][j]
}
int i, sum = 0;

k = j
};
for(i = 0; i <= n; i++)

current_pathweight += graph[k][s]
int main(){
{

int n = 4;
sum += graph[a[i % 4]][a[(i + 1) % 4]];

min_path = min(min_path, int graph[][V] = {

}

current_pathweight)
{ 0, 10, 15, 20 },
if (cost > sum)

return min_path
{ 10, 0, 35, 25 },
{

{ 15, 35, 0, 30 },
cost = sum;

if _name_ == "_main_":
{ 20, 25, 30, 0 }
}

};
}

graph = [[0, 10, 15, 20], [10, 0, 35, 25],

vector<bool> v(n);
void permute(int *a, int i, int n)

[15, 35, 0, 30], [20, 25, 30, 0]]

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

s = 0
v[i] = false
int j;

print(travellingSalesmanProblem(graph, v[0] = true;

if (i == n)

s))
int ans = INT_MAX;
{

tsp(graph, v, 0, n, 1, 0, ans);
copy_array(a, n);

cout << ans;

}

return 0;
else

}
{

fi
 12
for (j = i; j <= n; j++)

swap((a + i), (a + j));

permute(a, i + 1, n);

swap((a + i), (a + j));

Selection are SURE

}

int main()

int a[] = {0, 1, 2, 3};

permute(a, 0, 3);

printf("%d",cost);

Sort
questions

&

Inorder … Let’s
Tree solve
+
Traversal
them Now
!