嵌入式学习之路（十九）——数据结构（1）

嵌入式学习之路（十九）——数据结构（1）

今天我们先来看一下数据结构吧,C语言就先讲到这里，以后还有很多机会深入学习的

毕竟C语言在嵌入式的学习过程中是很重要的

今天我们先来看看

1.冒泡排序

2.插入排序

3.选择排序

4.快速排序

一。冒泡排序

算法思路：

    1.从第一个元素开始，相邻的两个做比较，如果前面大于后面，交换位置到最后
    第一轮结束，最大的在最后面
    2.m个数，只要m-1轮就排序完成，第n轮只要比较m-n+1次
    冒泡排序某一轮如果一次交换都没有发生，此时数组就是有序的了
    3.特点：
        冒泡排序平均时间复杂度：O(N^2)级别
        稳定排序
        如果数据基本有序，冒泡很好，对数据的有序性非常敏感

/*************************************************
**
** 文件名称： bubb_sort.c
** 文件简介： 冒泡排序函数
**
*************************************************/
#include "bubb_sort.h"
/*************************************************
**
** 函数名称： bubble_sort()
** 函数功能： 冒泡排序
** 形式参数： 数组地址，数组大小
** 返回值  ： 无
**
*************************************************/
void bubble_sort(int data[],size_t size)/*冒泡排序*/
{
	int i,j;
	int temp = 0;
        /*siz个数，比较size-1次*/
	for(i = 0;i < size - 1;i++)
	{
		/*一轮比较size -1 次，并且每次少一次*/
		temp = 0;
		for(j = 0;j < size - 1 - i;j++)
		{
			/*如果前面大于后面*/
			if(data[j] > data[j + 1])
			{
				temp = data[j];
				data[j] = data[j+1];
				data[j+1] = temp;
			}
		}
		/*如果一轮中一次都没有交换过，说明已经是有序数列*/
		if(0 == temp)
		{
			printf("经过%d次,此序列已经是有序数列\n",i);
			break;
		}
	}
}

二。插入排序

算法思路：

1.第一个元素自然有序。然后把第二到第n个元素插入到前面有序的n-1个元素中，确保每次插入新元素后，依然有序
    2.程序思路：
        1.先把要插入的数字a存起来
        2.拿a和有序的最后一个元素比较，如果a大，就不用动
        3.如果a小于最后一个,最后一个位置向后移位，拿a和倒数第二个
        4.依次执行2，3，直到前面的数字比a小或者已经没有数字了
    3.特点
        1.平均时间复查度O(N^2)级别
        2.稳定排序
        3.插入排序对元素的有序性比较敏感
        4.插入排序只移动不交换，效率优于冒泡

/*************************************************
**
** 文件名称： insert_sort.c
** 文件简介： 插入排序函数
**
*************************************************/
#include "insert_sort.h"
/*************************************************
**
** 函数名称： insert_sort()
** 函数功能： 插入排序
** 形式参数： 数组地址，数组大小
** 返回值  ： 无
**
*************************************************/
void insert_sort(int data[],size_t size)/*插入排序*/
{
	int i,j;
	/*把第二个到最后一个size插入*/
	for(i = 1;i < size;i++)
	{
		int num = data[i];/*保存要插入的数*/
		/*不移动的条件,j = 0,data[j-1] < num*/
		for(j = i;j > 0 && num < data[j-1];j--)
		{
			data[j] = data[j-1];/*data[j-1]向后移*/
		}
		data[j] = num;/*不移动后，放入合适位置*/
	}
}

三。选择排序

算法思路：

1.选择排序思路：
        1.找出最小的，和第一个元素交换
        2.然后在剩下中最小的，和第二个元素交换
        3.依次进行,n个元素着n-1轮
    2.算法：
        1在数组中,着到最小值，记录最小值的下标
        2把最小值的下标对应的元素和第一个元素进行交换(第n次和第n个元素交换)
        3.找最小值，记录下标，用下标完成交换
        4.数组的操作就是操作下标
    3.特点：
        1.平均时间复杂度O(N^2)
        2.非稳定排序
        3.选择排序对元素的有序性不敏感
        4.选择排序只交换一次，所以优于冒泡

/*************************************************
**
** 文件名称： select_sort.c
** 文件简介： 选择排序函数
**
*************************************************/
#include "select_sort.h"
/*************************************************
**
** 函数名称： select_sort()
** 函数功能： 选择排序
** 形式参数： 数组地址，数组大小
** 返回值  ： 无
**
*************************************************/
void select_sort(int data[],size_t size)/*选择排序*/
{
	int i,j;
	/*要找n-1次*/
	for(i = 0;i < size - 1;i++)
	{
		int min = i;/*记录最小值下标*/
		for(j = i+1;j < size;j++)
		{
			if(data[j] < data[min])/*如果有更小的，交换下标*/
			{
				min = j;
			}
		}
		/*最小值下标被交换过，才有必要交换*/
		if(i != min)
		{
			int temp = 0;
			temp = data[i];
			data[i] = data[min];
			data[min] = temp;/*交换每次最小值和第一个位置*/
		}
	}
}

四。快速排序

算法思路：

1.快速排序思路：
        1.如果一个元素前面都比他小，后面都比他大，这个元素位置是正确的
        2.利用递归，继续分前后两个部分对他进行继续排序
        3.以此类推

/*************************************************
**
** 文件名称： qsort.c
** 文件简介： 快速排序函数
**
*************************************************/
#include "qsort.h"
/*************************************************
**
** 函数名称： Qsort()
** 函数功能： 选择排序
** 形式参数： 数组地址，左边下标，右边下标
** 返回值  ： 无
**
*************************************************/
/*只给size 递归不方便，要算数组的首地址*/
void Qsort(int data[],size_t left,size_t right)/*快速排序*/
{
	int i,j,pos;
	i = left;
	j = right;/*i记录左下标，j记录右下标,pos记录要处理排序的位置*/
	pos = (i + j) / 2;/*三个下标已经准备好了*/
	int tmp = data[pos];/*第一步，先存pos下标的数据*/
	/*i == j -> i和j碰面就不循环，停止移动*/
	while(i < j)
	{
		/*i不移动的两个条件*/
		/*i==pos,应该移动j了,i不移动*/
		/*data[i]>temp,找到了比tmp大的数，i也不移动*/
		//for(;(data[i] < tmp && i < pos);i++);/*只负责移动i,i++*/
	/*移动完之后，就找到了比tmp大的数,上面的data[i] < tmp不成立*/
                while(data[i] < tmp && i< pos)
                {
                   i++;
                }
		/*直接把i < pos拿过来用*/
                /*说明找到一个比temp大的数了*/
		if(i < pos)
		{
			data[pos] = data[i];/*将大数移动后面，移动到pos位置*/
			pos = i;/*移动i到pos位置，下次将移动的是j*/
		}
		/*j==pos,应该移动i了,j不移动*/
		/*temp < data[j],找到了比tmp小的数，j也不移动*/
		for(;(data[j] > tmp && j > pos);j--);/*只负责移动j ,j--*/
		/*找到了比tmp小的数*/
		if(j > pos)
		{
			data[pos] = data[j];/*将小数移动前面，移动到pos位置*/
			pos = j;/*移动j到pos位置，下次将移动的是i*/
		}
	}
	data[pos] = tmp;/*数据tmp的正确位置*/
	if(pos - left > 1)
	{
		/*递归前面一段*/
		Qsort(data,left,pos-1);/*tmp的正确位置，tmp已经是有序的*/
	}
	if(right - pos > 1)
	{
		/*递归后面一段*/
		Qsort(data,pos+1,right);/*tmp的正确位置，tmp已经是有序的*/
	}
}