算法导论-2算法初步

目录

 

1. 插入排序算法

2. 算法复杂性及其度量

(1)时间复杂性和空间复杂性;

(2)最坏、最好和平均情形复杂性;

3. 插入排序的最坏、最好和平均时间

4. 归并排序算法及其时间复杂性


1. 插入排序算法

伪代码:

for j = 2 to A. length

     key = A[j]

     // Insert A[j] into the sorted sequence A[1,j-1].

      i = j-1

     while i > 0 and A[i] > key

             A[i+1] = A[i]

             i=i-1

      A[i+1] = key

c代码:

#include <stdio.h>
#include <string.h>
void printArray ( int intArray[], int length )
{
	int loop;
	for ( loop = 0; loop < length; loop++ )
	{
		printf( "%d ", intArray[loop] );
	}
	printf( "\n" );
}
void insertion_sort(int array[], int first, int last)
{
	int i,j;
	int key;
	for (j = first+1; j<=last;j++)
	{
		key = array[j];
		i=j-1;
		while((i>=first) && (array[i] > key))
		{
			array[i+1] = array[i];
			i--;
		}
		array[i+1] = key; 
	}
}
int main ( void )
{
	int array[6] = { 5, 2, 4, 6, 1, 3 };
	printArray( array, 6 );
	insertion_sort( array, 0, 5);
	printArray( array, 6 );
}

2. 算法复杂性及其度量

(1)时间复杂性和空间复杂性;

时间复杂度评估执行程序所需的时间。可以估算出程序对处理器的使用程度。

空间复杂度评估执行程序所需的存储空间。可以估算出程序对计算机内存的使用程度。

T(n):一个算法中的语句执行次数称为语句频度或时间频度(算法中基本操作重复执行的次数是问题规模n的某个函数,用T(n)表示)。n称为问题的规模。

若有某个辅助函数f(n),使得当n趋近于无穷大时,T(n)/f(n)的极限值为不等于零的常数,则称f(n)T(n)的同数量级函数,记作T(n)=O(f(n)),它称为算法的渐进时间复杂度,简称时间复杂度。

(2)最坏、最好和平均情形复杂性;

最好情况分析:给一个精心构造的输入,让算法的执行时间最短。

最坏情况分析:给一个最坏的输入,让算法执行的时间最长。

平均情况分析:这个和输入的概率有关,比如尽管输入只有12和21两种可能,但是输入21的概率几乎为0,平均分析的时候12占的权重就要很大。

3. 插入排序的最坏、最好和平均时间

最好情况:原本有序,只需O(n)

平均:O(n^{2})

最差:恰好逆序,O(n^{2})

空间复杂度O(1)

4. 归并排序算法及其时间复杂性

伪代码:

MERGE(A, p, q, r)          //A中p到q, q+1到r为排好序的子数组

n1 = q - p + 1

n2 = r - q

for i = 1 to n1

    L[i] = A[p+i-1]

for j = 1 to n2

    R[j] = A [q + j]

L[n1+1] = flag    //flag为一个足够大的值,充当哨兵,可以省去判空的逻辑

R[n2+1] = flag

i = 1; j = 1

for k = p to r

    if L[i] <= R[j]

        A[k] = L[i]

        i = i + 1

    else

        A[k] = L[j]

        j = j + 1

 

MERGE-SORT (A, p, r)

    if p < r

        q = floor ((p + r) / 2)

        MERGE-SORT (A, p, q)

        MERGE-SORT (A, q+1, r)

        MERGE (A, p, q, r)

时间复杂度

递推式:T(n) = 2T(n/2) + O(n),递归展开得到解为T(n) = O(nlgn)

最好情况O(nlgn),平均O(nlgn),最差O(nlgn),空间复杂度O(n)

c代码:

#include <stdio.h>
#include <string.h>
#include <malloc.h>
void merge ( int intArray[], int begin, int mid, int end )
{
	int n1 = mid - begin + 1;	
	int n2 = end - mid;
	int i, j, k;
int *L = (int *) malloc ( sizeof ( int ) * n1 );
	int *R = (int *) malloc ( sizeof ( int ) * n2 );
 	/*利用goto语句实现异常处理,当L或R未能正常分配时
	  将直接跳转至程序末尾,后续程序不再执行*/
	if ( L == NULL || R == NULL )
	{		
		goto error;			
	}
	for ( i = 0; i < n1; i++ )
		L[i] = intArray[begin + i];
 	for ( j = 0; j < n2; j++ )
		R[j] = intArray[mid + 1 + j];
 	i = j = 0;
	k = begin;
 	while ( i < n1 && j < n2 )
	{
		if ( L[i] < R[j] )
		{
			intArray[k++] = L[i++];
		}
		else
		{
			intArray[k++] = R[j++];
		}
	}
 	while ( i < n1 )
	{
		intArray[k++] = L[i++];
	}
	while ( j < n2 )
	{
		intArray[k++] = R[j++];
	}
 	/*程序执行完毕后,在done处,进行资源释放*/
	goto done;
error:
	printf ( "malloc has been failed!\n" );
done:
	if ( L != NULL && R != NULL )
	{
		free ( L );
		free ( R );
	}
}
 
void merge_sort ( int intArray[], int head, int tail )
{
 	int mid;
 	if ( head  < tail )
	{
		mid = ( head + tail ) / 2;
		printf ( "sort ( %d-%d %d-%d ) %d %d %d %d %d %d %d %d\n", head, mid, mid + 1, tail, intArray[0], intArray[1], intArray[2], intArray[3], intArray[4], intArray[5], intArray[6], intArray[7] );
		merge_sort ( intArray, head, mid );
		merge_sort ( intArray, mid + 1,  tail );
		merge ( intArray, head, mid, tail );
		printf ( "merge ( %d-%d %d-%d ) %d %d %d %d %d %d %d %d\n", head, mid, mid + 1, tail, intArray[0], intArray[1], intArray[2], intArray[3], intArray[4], intArray[5], intArray[6], intArray[7] );
	}
}
int main ( void )
{
 	int a[8] = { 5, 2, 4, 7, 1, 3, 8, 6 };
	int i = 0;
	merge_sort ( a, 0, 7 );
 	for ( i = 0; i < 8; i++ )
	{
		printf ( "%d ", a[i] );
	}
 	while ( 1 );
}

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值