Divide

Hatvany
*******************
#include <iostream>
using namespace std;

int hatvany(int a,int n)
{
	if (n==0) return 1;
	else
	{
		int x=hatvany(a,n/2);
		if (n%2==0) return x*x;
			else return x*x*a;
	}
}

int main()
{
	int a;
	int n;
	cout<<"Add meg az alapot:";
	cin>>a;
	cout<<"A hatvanykitevo:";
	cin>>n;
	if (n>0)
		cout<<"Eredmeny:"<<hatvany(a,n);
	else
		cout<<"Eredmeny:"<<(float)1/hatvany(a,-n);
	return 0;
}
*******************************
Quicksort
*********************************
#include <iostream>

using namespace std;
void beolvas(int a[],int &n)
{
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
}
void quick(int a[],int e,int u)
{
    int x=a[(e+u)/2];
    int i=e,j=u;
    do{
            while(a[i]<x) i++;
            while(a[j]>x) j--;
            if(i<=j)
            {
                if(i<j){ int s=a[i];a[i]=a[j];a[j]=s;}
                i++;
                j--;
            }
    }while(i<=j);

    if(e<j) quick(a,e,i);
    if(i<u) quick(a,i,u);
}
int main()
{
    int a[20],n;
    beolvas(a,n);
    quick(a,1,n);
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";


    return 0;
}
***********************
Mergesort
************************
#include <iostream>

using namespace std;
void beolvas(int a[],int &n)
{
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
}
void fesul(int a[],int e/**elso*/,int k,int u/**utolso*/)
{
    int c[50],m=e;
    int i=e,j=k+1;
    while(i<=k && j<=u)
    {
        if(a[i]<a[j])
        {
            c[m]=a[i];
            m++;i++;
        }
        else
        {
            c[m]=a[j];
            m++;j++;
        }
    }
    for(int x=i;x<=k;x++)
    {
        c[m]=a[x];m++;
    }
    for(int x=j;x<=u;x++)
    {
        c[m]=a[x];m++;
    }
    for(int x=e;x<=u;x++) a[x]=c[x];
}
void mergesort(int a[],int e,int u)
{
	if (e<u)
	{
		int k=(e+u)/2;
		mergesort(a,e,k);
		mergesort(a,k+1,u);
		fesul(a,e,k,u);
	}
}
int main()
{
    int a[50],n;
    beolvas(a,n);
    mergesort(a,1,n);
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
    return 0;
}
*****************************
rek min max
**************************
/**2. Adott egy n elemű sorozat. Határozzuk meg:
 a. a sorozat legnagyobb elemét
 b. a sorozat páros elemeinek számát
 c. a sorozat elemeinek lnko-ját
 d. a sorozat prím elemeinek összegét
 e. a sorozat tükörelemeinek számát
 f. a sorozat legkisebb és legnagyobb elemét egyszerre
**/
#include <iostream>

using namespace std;
int max(int a[],int e,int u)
{
    if(e==u) return a[e];
    else
    {
        int k=(e+u)/2;
        int m1=max(a,e,k);
        int m2=max(a,k+1,u);
        if(m1>m2) return m1;
        else return m2;
    }

}
int paros(int a[],int e,int u)
{
    if(e==u) if(a[e]%2==0) return a[e];
        else return 0;
    else
    {
        int k=(e+u)/2;
        int m1=paros(a,e,k);
        int m2=paros(a,k+1,u);
        return m1+m2;
    }
}
int prim(int n)
{
    for(int i=2;i<=sqrt(n);i++)
        if(n%i==0)
        return 0;
    else if(i==sqrt(n) and n%i!=0) return 1;
}
int prim_ellenoriz(int a[],int e,int u)
{
    if(e==u) if(prim(a[e])==1) return a[e];
        else return 0;
    else
    {
        int k=(e+u)/2;
        int m1=prim_ellenoriz(a,e,k);
        int m2=prim_ellenoriz(a,k+1,u);
        return m1+m2;
    }
}
int lnko(int a, int b) {
   int c;
   if (a<0) a=-a;
   if (b<0) b=-b;
   while(b > 0) {
      c=b;
      b=a%b;
      a=c;
   }
   return a;
}
int lnko_ellenoriz(int a[],int e,int u)
{
    if(e==u) return a[e];
    else
    {
        int k=(e+u)/2;
        int m1=lnko_ellenoriz(a,e,k);
        int m2=lnko_ellenoriz(a,k+1,u);
        return lnko(m1,m2);
    }
}

tukor(int n)
{
    int nn=n,f=0;
    while(n!=0)
    {
        f=f*10+n%10;
        n=n/10;
    }
    if(nn==f)
        return 1;
    else return 0;
}
int tukor_ellenoriz(int a[],int e,int u)
{
    if(e==u) if(tukor(a[e])==1) return 1;
        else return 0;
    else
    {
        int k=(e+u)/2;
        int m1=tukor_ellenoriz(a,e,k);
        int m2=tukor_ellenoriz(a,k+1,u);
        return m1+m2;
    }
}
void max_min(int a[],int e,int u,int &min,int &max)
{
	if (e==u) return a[e];
	else
	{
		int k=(e+u)/2;
		int m1=max_min(a,e,k);
		int m2=max_min(a,k+1,u);
		if (m1>m2) min=m2;
			else min=m1;
		int m1=max_min(a,e,k);
		int m2=max_min(a,k+1,u);
		if (m1<m2) max=m2;
			else max=m1;
	}
}



int main()
{

    return 0;
}
****************************