【算法设计zxd】第2章 算法分析实例 递归非递归——交换,n阶乘,矩阵乘法,汉诺塔,二路归并,

目录

非递归形式算法分析:

递归形式算法分析:

【例2-9】交换a和b的值。

非递归

 【例2-10】求n!

非递归:

思考题:韩信点兵

【例2-11】对于任意给定的n阶方阵A和B,求A×B的积C并且 分析它算法执行效率。

问题分析:

计算模型:

非递归:

【例2-13】汉诺塔(Tower of Hanoi)问题。

 问题分析:

计算规模:​

【例2-14】试分析二路归并排序算法的时间复杂度。



非递归形式算法分析:

 决定用哪些参数表示输入规模
找出算法的核心操作,它通常位于算法的最内层循环中;
检查核心操作的执行次数是否只依赖于输入规模。如果 它还依赖于一些其他的特性,则可能需要对最差效率、 平均效率以及最优效率分别研究;
以式 (2-1) 的思想为核心,建立一个算法基本操作执行次 的求和表达式;
利用求和运算标准公式和法则来建立一个操 作次数的闭合公式,或者至少确定它的增长
次数。

递归形式算法分析:

决定用哪些参数作为输入规模的度量标准
找出算法的核心操作,它通常是递推公式
检查一下,对于相同规模的不同输入,核心操作的执 行次数是否可能不同。如果有这种可能,则必须对最 差效率、平均效率以及最优效率做单独研究;
对于算法核心操作的执行次数,建立一个递推关系以 及相应的边界条件
解这个递推式,或者至少确定它的解的增长 次数
谨慎使用递归算法,因 为它们的简洁可能会掩 盖其低效率的事实。

【例2-9】交换ab的值。

非递归

算法设计与描述 算法分析
输入:a,b (1)输入a,b两个数,规模为2
输出:a,b

swap(a,b)

{
        Temp <- a;

        a <- b;

        b <- Temp;

        output(a,b);

}

(2)核心操作为3条交换语句;

(3)核心操作执行的次数是一个与输入规模无关的常数

(4)算法的时间复杂度为常数阶 T(n)= O(1)   //O渐近上界 0 ≤ f(n)  ≤ c*g (n )

 【例2-10】求n!

非递归:

算法设计与描述 算法分析
输入:n (1)输入n,规模为n ,控制迭代次数。
输出:n !

F (n)

{
        s <- 1;

        for i <- 1 to n do

                s=s*i ;

        output(s);

}

(2)核心操作为 s=s*i ; 一次乘法运算

(3)核心操作执行的次数,只受输入规模n控制

(4)依据定理2.5 算法的时间复杂度为常数阶 T(n)= ∑(n,i=1) 1 = Θ(n) //渐近紧界

递归:
计算模型:
算法设计与描述 算法分析
输入:n (1)输入n,规模为n ,计算规模也是n
输出:n !

F (n)

{
        if(n==0) return 1;

        else return n*F(n-1);

}

(2)核心操作为 n*F(n-1) ; 一次乘法运算

(3)根据递推公式,每递推一次,执行一次乘法操作,因此有以下推导过程:
T(n) =1+T(n-1) =1+1+T(n-2)……=1+1+…+1+T(1)=1+1+…+1=n=Θ(n)

(4) //渐近紧界

思考题:韩信点兵

【算法设计zxd】第2章 算法分析实例 递归非递归——交换,n阶乘,矩阵乘法,汉诺塔,二路归并,_第1张图片

#include
using namespace std;
int main()
{
	int n=1;
	while( (n%3!=2)||(n%5!=3)||(n%7!=2)){
		n++;
	}
	cout<

优化:

//a,b,c中,c的大小对该结果影响最大,因此从c入手可以稍微提高运算效率。
void hanxin01()
{
	int n=9;//7+2
	int i=0; 
	while(true)
	{
		if(n%3==2&&n%5==3)
		break;
		i++;
		n+=7;
	}
	cout<<"次数:"<

【例2-11】对于任意给定的n阶方阵AB,求A×B的积C并且 分析它算法执行效率。

问题分析:

C也是n阶方阵,每个元素 = 矩阵A的行 和矩阵B的列 的点积 。

对于 i>=0 , j<= n-1 的每一对下标 ,有 C[i,j] = A[i,0]B[0,j] +... + [i,k]B[k,j] + .... + A[i,n-1]B[n-1,j] 

计算模型:

设 i , j, k ∈[0, n-1],矩阵运算中将反复执行下述计算公式:

非递归:

算法设计与描述 算法分析
输入:A,B  (1)输入A,B,规模为n x n 
输出:C=Ax B

MatrixMultiplication  (A[n] ,B[n] )

{

        for i <- 0 to n-1 do

                for j <- 0 to n-1 do

                {

                        C[i,j] <- 0.0 ;

                        for k <- 0 to n-1 do

                                C[i,j] = C[i,j] + A[i,k]*B[k,j];

                }

        return C;

}

(2)核心操作 通过加法和乘法运算 求C[i,j]

(3)核心操作执行的次数,只受输入规模n控制 ∑(n-1 , k=0) 1 

(4)依据定理2.5 算法的时间复杂度为常数阶 T(n)=  Θ(n^3 ) //渐近紧界

【算法设计zxd】第2章 算法分析实例 递归非递归——交换,n阶乘,矩阵乘法,汉诺塔,二路归并,_第2张图片

【例2-13汉诺塔(Tower of Hanoi)问题。

如图 2-2 所示,有 n个 大小不同的盘子和 3 根木桩。开始时,所有盘子都套在第A根 木桩上,最大的盘子在底部,最小的盘子在顶部。现在要借 助第 B 根木桩把所有盘子都移动到第 C根木桩上,但是移动时, 必须保证大盘子在下面,小盘子在上面。
【算法设计zxd】第2章 算法分析实例 递归非递归——交换,n阶乘,矩阵乘法,汉诺塔,二路归并,_第3张图片

 问题分析:

把n 个盘子从木桩A移到木桩C,三个步骤:
1)把n-1个盘子从木桩A移到木桩B,借助于木桩C;
2)把一个盘子从木桩A移到木桩C
3)把n-1个盘子从木桩B移到木桩C,借助木桩A

计算规模:

 递归:

算法设计与描述 算法分析
输入:n (1)输入n,计算规模是n
输出:显示 【算法设计zxd】第2章 算法分析实例 递归非递归——交换,n阶乘,矩阵乘法,汉诺塔,二路归并,_第4张图片

Hanoi (A,C,n)

{
        if(n==1) move(A,C,1);//移动展示

        else 

        {

                Hanio(A,B,n-1);//n-1个盘子,从A移到B,借助另一个

                move(A,C); // 从A移动到C

                Hanoi(B,C,n-1); //

        }

}

(2)核心操作为 移动盘子

(3)根据递推公式,。。。【不全】

 

 【算法设计zxd】第2章 算法分析实例 递归非递归——交换,n阶乘,矩阵乘法,汉诺塔,二路归并,_第5张图片

【例2-14试分析二路归并排序算法的时间复杂度。

问题分析:

二路归并排序的思想是:将待排序 的数列分成相等的两个子数列(数量 相差±1),然后,再使用同样的算 法对两个子序列分别进行排序,最 后将两个排好的子序列归并成一个 有序序列。
代码:
#include
#include
using namespace std;
//二路归并
int a[100];
int n=10;
void merge(int a[],int low,int mid,int high)
{
	int sum1=mid-low+1;//元素个数 
	int sum2=high-mid;
	int b[100]={0};
	int c[100]={0};
	for(int i=0;isum1)//c有剩余 
	{
		for(;j

算法设计与描述 MergeSort( A,p,r ) 算法分析【换元迭代】
输入:n个数的无序序列A[p,r] , 1<= p <= r <= n , (1)输入n,计算规模是n
输出:n个数的有序序列A[p,r]

MergeSort (A,p,r)

{
        if( p

        {

                q <- (p+r)/2 ;//中间

                MergeSort (A,p,q); //左侧

                MergeSort(A,q+1,r) ;//右侧

                Merge (A,p,q,r); 

        } 

}

(2)核心操作为 移动盘子

(3)

(4)

换元 

代码代码

Merge

算法设计与描述 Merge( A,p,q,r ) 算法分析
输入:n按递增顺序排好的 A[p...q] 和 A[q+1...r ] (1)输入n,计算规模是n
输出:按照递增顺序排序的A[p,r]

Merge (A,p,q,r)

{

        x <- q-p+1 ,y <- r-q;//x,y分别是两个子数组的元素数

        A[p...q] -> B[1...x] , A[q+1...r] -> C[1...y] //两个新数组
        

        i <- 1 ,j<- 1 ,k <- p 

        while i<=x and j <= y do 

        {

                if ( B[i] <= C[ j ] ) //注意是i 和 j 

                {

                        A[k] <- B[i];//较小数

                        i <- i+1;

                }

                else

               {

                        A[k] <- C[j] ;

                        j <- j+1;

               }

                k=k+1;

        } 

        if(i>x)        C[j...y] -> A[k..r] //如果还要剩余的元素,就不需要比较,直接赋值回去就行

        else         B[i..x] -> A[k...r]

}

(2)核心操作为 移动盘子

(3)根据递推公式,。。。【不全】

你可能感兴趣的:(算法,算法zxd,算法)