Generowanie podciągów, który sposób najlepszy?

void wypisz(int zbior[],int k)
{
	for(int i=0;i<k;i++)
		if(zbior[i]!=-1)
			cout<<zbior[i]<<" ";
	cout<<endl;
}

void gen_podzb(int zbior[],int n,int ost, int gleb)
{	
	wypisz(zbior,n);
	for(int i=ost+1;i<n;i++)
	{		
		zbior[gleb]=i;
		gen_podzb(zbior,n,i,gleb+1);
		zbior[gleb]=-1;
	}
}

void gen_podzb(bool ciag[],int n, int gleb)
{
	if(gleb==n)
		wypisz(ciag,n);
	else
	{		
		ciag[gleb]=false;
		gen_podzb(ciag,n,gleb+1);
		
		ciag[gleb]=true;
		gen_podzb(ciag,n,gleb+1);
	}
}
int main()
{
	int k=3;
	int n=20;
	int *zbior = new int[n];	
	for(int i=0;i<n;i++)
			zbior[i]=-1;
		
	gen_podzb(zbior,n,-1,0);
		int N=20;
	bool *ciag =new bool[N];
	for(int i=0;i<N;i++)
		ciag[i]=false;	
	gen_podzb(ciag,N,0);
}

void gen_podzb_kel(int zbior[],int n, int k)
{
	int p=0;
	while(k>0 && zbior[0]<n-k)
	{
		
		while(zbior[k-1]<n)
		{
			wypisz(zbior,k);
			zbior[k-1]++;
		}
		zbior[k-1]--;
		
		p=k-2;	
		while(p>=0 && zbior[p]+1==zbior[p+1])
			p--;
			
		zbior[p]++;
		
		while(p<k-1)
		{
			zbior[p+1]=zbior[p]+1;
			p++;
		}
	}
	
	if(k!=1)
		wypisz(zbior,k);
}

void gen_podzb(int zbior[],int n)
{
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<i;j++)
			zbior[j]=j;
			
		gen_podzb_kel(zbior,n,i);

	}
}
int main()
{
	int n=5;
	int k=20;
	int *zbior = new int[k];	
	for(int i=0;i<k;i++)
			zbior[i]=i;
	gen_podzb(zbior,k);
}

Napisałem generowanie podzbiorów trzema różnymi metodami. Chciałbym zapytać się która z nich jest 'najlepsza' lub gdzie stosować które podejście gdyż problem generowania podzbiorów jest popularny w programach i często przed napisaniem zastanawiam się czy napisać iteracyjno-rekurencyjnie, rekurencyjnie czy iteracyjnie.

Dlaczego nie użyjesz std::generate albo std::iota?

PS: https://dsp.krzaq.cc/post/176/ucze-sie-cxx-kiedy-uzywac-new-i-delete/

Najlepszy będzie sposób iteracyjny, wiadomo. Ciekawe czy kiedyś zobaczymy kod C++ w dziale C++, std::vector i te sprawy :)

Najlepiej sprawdź dla różnych wartości.
Na linuxie masz getrusage i jeszcze inne których nie pamiętam.
Na windows to w sumie nie wiem, może jakoś time + clock? (Ale zawsze będziesz miał różne wyniki dla różnego obciążenia systemu)