嵌入式学习第三十五天！（算法）

算法：解决特定问题求解步骤

1. 算法的设计：

    1. 正确性：语法正确；合法的输入能得到合理的结果；对非法的输入，给出满足要求的规格说明；对精心选择，甚至刁难的测试都能正常运行，结果正确；

    2. 可读性：便于交流，阅读，理解（高内聚，低耦合）；

    3. 健壮性：输入非法数据，能进行相应的处理，而不是产生异常；

    4. 高效率：运行时间短（时间复杂度低）

    5. 低存储：（空间复杂度）

2. 算法时间复杂度：

     执行这个算法所花时间的度量，时间复杂度越高，效率越低。

    将数据量增长和时间增长用函数表示出来，这个函数就叫做时间复杂度。

    一般用大O表示：O(n)——>时间复杂度是关于数据n的一个函数，随着n的增加，时间复杂度增长较慢的算法时间复杂度低。

3. 时间复杂度的计算规则：

    1. 用常数1取代运行时间中的所有加法常数；

    2. 在修改后的运行函数中，只保留最高阶项；

    3. 如果最高阶存在且系数不是1，则去除这个项相乘的常数；

    练习：

Fun(int a,int b)  //3 -> 时间复杂度为O(1)
{
    Int tmp = a;
    A = b;
    B = tmp;
}

for(i = 0; i < n; i++)    //3n -> 时间复杂度为O(n)
{
    Int tmp = a;
    A = b;
    B = tmp;    
}

for(i = 1; i < n; i *= 2)  //2^x = n 即1*2*2*2*2*2*2 < n 时间复杂度为O(logn)

for(i = 0; i < n; i++)    //时间复杂度为O(nlogn)
{
    for(i = 0; i < n; i *= 2)    //时间复杂度为O(logn)
    {
    }
}

for(i = 0; i < n; i++)    //3(n+1)*n/2 -> n^2 时间复杂度为O(n^2)
{
    for(j = i; j < n; j++)
    {
        Int tmp = a;
        A = b;                         
        B = tmp;  
    }
}

    时间复杂度排序：

        O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

4. 排序算法：

    1. 冒泡排序：时间复杂度：O(n²)

void Bubble_Sort(int *parry, int len)
{
	int tmp = 0;

	for(int i = 0; i < len-1; i++)
	{
		for(int j = 0; j < len-1-i; j++)
		{
			if(parry[j] > parry[j+1])
			{
				tmp = parry[j];
				parry[j] = parry[j+1];
				parry[j+1] = tmp;
			}
		}
	}
	return;
}

    2. 选择排序：时间复杂度O(n²)

void Select_Sort(int *parry, int len)
{
	int tmp = 0;

	for(int i = 0; i < len-1; i++)
	{
		for(int j = i+1; j < len; j++)
		{
			if(parry[i] > parry[j])
			{
				tmp = parry[i];
				parry[i] = parry[j];
				parry[j] = tmp;
			}
		}
	}
	return;
}

    3. 插入排序：时间复杂度O(n²)

void Insert_Sort(int *parry, int len)
{
	int tmp = 0;
	int j = 0;

	for(int i = 1; i < len; i++)
	{
		tmp = parry[i];
		j = i;
		while(tmp < parry[j-1] && j > 0)
		{
			parry[j] = parry [j-1];
			j--;
		}
		parry[j] = tmp;
	}
	return;
}

    4. 快速排序：时间复杂度O(nlogn)

void Qulik_Sort(int *parry, int head, int tail)
{
	if(head >= tail)
	{
		return;
	}
	int i = head;
	int j = tail;
	int key = parry[i];

	while(i < j)
	{
		while(i < j && key <= parry[j])
		{
			j--;
		}
		parry[i] = parry[j];

		while(i < j && key >= parry[i])
		{
			i++;
		}
		parry[j] = parry[i];
	}
	parry[i] = key;
	Qulik_Sort(parry, head, i-1);
	Qulik_Sort(parry, i+1, tail);
}

        注意：在一个待排的序列中，如果两个相同的数的相对位置没有改变，说明排序算法稳定，所以根据上诉排序算法原理可知：冒泡排序、插入排序是稳定的排序算法，选择排序、快速排序是不稳定的排序算法。

    5. 二分查找：必须是一个有序序列才能使用，时间复杂度O(logn)

int Binary_Search(int *parry, int len, int data)
{
	int left = 0;
	int right = len-1;

	while(left <= right)
	{
		int middle = left + (right-left)/2;
		if(data < parry[middle])
		{
			right = middle - 1;
		}
		else if(data > parry[middle])
		{
			left = middle + 1;
		}
		else
		{
			return middle;
		}
	}

	return -1;
}