Berechnungszeit, Ableitung der Zeitkomplexität und klassische Algorithmusanalyse von Divide and Conquer

Teilen und Erobern ist eine Idee zur Lösung komplexer Probleme. Sie kann ein Problem in mehrere kleine Probleme aufteilen und durch Zusammenführen dieser Probleme die Lösung des ursprünglichen Problems erhalten. Dieser Artikel analysiert die Komplexität der Divide-and-Conquer-Methode und analysiert die zeitliche Komplexität mehrerer spezifischer Algorithmen mithilfe dieser Methode.

1 Komplexitätsanalyse von Divide and Conquer

„Teile und herrsche“ kann die Größe n habenDas Problem von$n$$k$ Skalen$\frac{}{M}$zu lösende Teilprobleme. Stellen Sie den Zerlegungsschwellenwert $N_{}=1$ , und es dauert 1 Zeiteinheit, ein Problem der Größe 1 mit dem Algorithmus zur Lösung des kleinsten Teilproblems zu lösen. Zerlegen wir das ursprüngliche Problem in$k$ Teilprobleme und$Die\; Lösung\; von\; k$ Teilproblemen wird mit$f\left(n\right)$ Zeiteinheiten. mit$T\left(n\right)$ bedeutet, dass die Lösungsskala der Divide-and-Conquer-Methode$Die\; für\; das\; n-$ Problem erforderliche Berechnungszeit beträgt:
$$T\left(n\right)=\{\begin{array}{ll}O\left(1\right)& N=1\\ kT\left(\frac{}{M}\right)+f(n& N>\end{array}$$
则$$T\left(n\right)=N^{lo{g}_{}k}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}{k}^{j}f\left(\frac{}{M^J}\right)\text{\hspace{1em}( 1.1 )}$$
„Einführung in Algorithmen“ verwendet einen rekursiven Baum bei der Ableitung der Formel (1.1). Hier versuchen wir, eine andere Methode zum Ableiten zu verwenden:
wenn$N>1$时，$$T\left(n\right)=kT\left(\frac{}{M}\right)+f\left(n\right),$$
sei$N=M^t$ , 令$G\left(t\right)=T\left(m^t\right)=T\left(n\right)$ , dann
$$\begin{array}{rl}T\left(m^t\right)& =kT\left(m^{t-1}\right)+f\left(m^t\right)\\ G\left(t\right)& =kG(t-1)+f\left(m^t\right)\\ & =k\left(kG\right(t-2)+f(m^{t-1}))+f\left(m^t\right)\\ & =k^{2}G(t-2)+kf\left(m^{t-1}\right)+f\left(m^t\right)\\ & =\cdots \\ & =k^{t}G\left(0\right)+k^{t-1}f\left(m\right)+k^{t-2}f\left(m^2\right)+\cdots +kf\left(m^{t-1}\right)+f\left(m^t\right)\\ & =k^{t}G\left(0\right)+\sum _{j=0}^{t-}{k}^{j}f\left(m^{t-j}\right)\\ & =k^{lo{g}_{}N}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}{k}^{j}f\left(\frac{}{M^J}\right)\\ & =N^{lo{g}_{}k}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}{k}^{j}f(\frac{}{M^J}\end{array}$$
Daher erhält man Formel (1.1): $$T\left(n\right)=N^{lo{g}_{}k}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}{k}^{j}f\left(\frac{}{M^J}\right)$$
Bei der Berechnung der Zeitkomplexität können Sie$n,m,K$ wird in die zu lösende Formel eingesetzt.

2 Klassische Algorithmenanalyse

2.1 Binäre Suche

Die binäre Suche erfolgt in einer geordneten Sequenz $ein[0:n]$ , um ein bestimmtes Element$Die\; Methode\; von\; x$ gibt die Position des Elements in der Sequenz zurück, wenn es gefunden wird, und gibt einen Suchfehler zurück, wenn das Element nicht in der Sequenz ist. Nehmen wir als Beispiel die aufsteigende Reihenfolge: Bei der Suche ist das gefundene Element jedes Mal$x$ und das mittlere Element der Sequenz$midd$ zum Vergleich, wenn$X==midd$ , die Position zurückgeben; wenn$X<midmid$ , was darauf hinweist, dass sich das gesuchte Element möglicherweise in$Vor$$mid$ , kurz vor$ein[0:midd]$ auf die gleiche Weise weitersuchen; wenn$X>midmid$ , was darauf hinweist, dass sich das gesuchte Element möglicherweise in$Nach$$mid$ , kurz nach$a[mid:n]$ , um die Suche auf die gleiche Weise fortzusetzen. Der Code (C-Sprache) lautet wie folgt:

int binary_search(int a[], int num, int low, int high)
//a：要查找的序列，num：要查找的数，low：查找序列的第一个元素，high：查找序列的最后一个元素
{
    
    
	int mid = 0;
	while (low <= high) 
	{
    
    
		mid = (low + high) / 2;
		if (num == a[mid]) return mid;
		else if (num < a[mid]) high = mid - 1;
		else low = mid + 1;
	}
	return -1;
}

Das binäre Suchproblem wird 1 der Größe $Das\; Problem\; von\; n$ wird in 1 Größe n 2 \frac{n}{2}unterteilt$\frac{}{2}$Das Unterproblem des Problems, die Kosten für die Teilung des Problems, ergeben sich aus dem Vergleich von Zahlen, und am Ende ist keine Zusammenführung erforderlich, sodass nur eine konstante Zeitreihenfolge erforderlich ist, um ein Problem zu zerlegen und zu einem zusammenzuführen Problem, das heißt f ( n ) = cf(n)= $f\left(n\right)=c$ , aus Formel (1.1) können wir erkennen, dass die für die binäre Suche erforderliche Zeit
$$\begin{array}{rl}T\left(n\right)& =N^{lo{g}_{}1}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}C\\ & =1+clo{g}_{}\end{array}$$
Dann ist die Zeitkomplexität der binären Suche $O\left(lo{g}_{}n\right)$ .

2.2 Zwei-Wege-Zusammenführungssortierung

Bei der bidirektionalen Zusammenführungssortierung wird eine ungeordnete Sequenz $ein[niedrig,\_\_highgh]$ wird in zwei Sequenzen gleicher Größe aufgeteilt$ein[niedrig,\_\_mid]$ ,$a[mid+1,high]$ und sortieren Sie dann die beiden Sequenzen separat. Nachdem die Sortierung abgeschlossen ist, werden die beiden Sequenzen separat sortiert, und die Sortierung kann durch Zusammenführen der beiden Sequenzen abgeschlossen werden. Der C-Sprachcode lautet wie folgt:

void merge(int a[], int tmp[], int low, int mid, int high)
//合并算法，a[low,mid]有序，a[mid+1,high]有序，merge函数使得a[low,high]有序
{
    
    
	int i, j, k;
	for (i = low; i <= high; i++) tmp[i] = a[i];
	//将a[low,high]复制到tmp[low,high]中
	i = low, j = mid+1, k = low;
	//i,j用来指示数组tmp中的位置，k用来指示数组a中的位置
	while (i <= mid && j <= high)
	{
    
    
		if (tmp[i] <= tmp[j])
		//从tmp的两个有序段中挑出最小的元素放入a的下一个位置
		{
    
    
			a[k] = tmp[i];
			i++;
		}
		else
		{
    
    
			a[k] = tmp[j];
			j++;
		}
		k++;
	}
	while (i <= mid) //tmp[mid+1,high]已经在a中，将tmp[low,mid]中的剩余元素填入a
	{
    
    
		a[k] = tmp[i];
		i++, k++;
	}
	while (j <= high) //tmp[low,mid]已经在a中，将tmp[mid+1,high]中的剩余元素填入a
	{
    
    
		a[k] = tmp[j];
		j++, k++;
	}
}


void merge_sort(int a[], int tmp[], int low, int high)
//归并排序算法，a：要排序的数组，tmp：相同长度的辅助数组，low：排序序列的第一个元素，high：排序序列的最后一个元素
{
    
    
	int mid = 0, i;
	if (low < high)
	{
    
    
		mid = (low + high) / 2;
		merge_sort(a, tmp, low, mid);
		merge_sort(a, tmp, mid + 1, high);
		//将排序问题分成两个规模减半的子问题
		merge(a, tmp, low, mid, high);
		//将子问题的结果合并
	}
}

Der Zwei-Wege-Merge-Sortieralgorithmus hat eine Größe von $Das\; Problem\; von\; n$ ist in 2 Skalen n 2 \frac{n}{2}unterteilt$\frac{}{2}$Teilproblem. Das Aufteilungsproblem wird durch Funktionsaufrufe implementiert, und das Zusammenführungsproblem verbringt hauptsächlich Zeit im Array $a$ und das Array$tmp$ überträgt Elemente aufeinander, also$f\left(n\right)=n$ , aus Formel (1.1) kann man erkennen, dass die für die bidirektionale Zusammenführungssortierung erforderliche Zeit ist:
$$\begin{array}{rl}T\left(n\right)& =N^{lo{g}_{}2}+\sum _{j=0}^{lo{g}_{}\left(n\right)-}{2}^J\frac{}{2^J}\\ & =N+nlo{g}_{}\end{array}$$
Dann beträgt die zeitliche Komplexität der bidirektionalen Zusammenführungssortierung $O\left(nlo{g}_{}n\right)$ .