数据结构第六天————图、以及算法

数据结构
1. 逻辑思维 --> 编辑能力
2. 封装接口
3. 模块化编程 --> .h .c .c
复习树
二叉树
二叉排序树 二叉搜索树
特点：中序遍历的结果是从小到大有序。
今天的内容
1. 二叉树的层次遍历
代码截图
2. 图
a. 概念：
非线性结构，可能有环，可能是有方向的。
b. 图的分类
有向图和无向图
//连通图和非连通图
c. 图的表示方式
V={v0,v1,v2…}; //顶点
R={<v0,v3><v0,v5>…} //有向图
或者
R={(v1, v3)(v3, v5)…}//无向图
d. 图的存储方式
矩阵方式
A[5][5] = {}; //二维数组
邻接表方式
类似于hash表+链式来解决冲突
e. 图的遍历
广度优先
类似于二叉树的层次遍历
顶点–它的后继
深度优先
类似于二叉树的先序遍历
顶点–它的某一个后继
f. 图的应用
多用于各种拓扑结构，与当前的人工智能紧密结合。
将来工作中更多的倾向于算法研究。
3. 排序算法
插入排序
直接插入排序***

void insertSort(data_t * pArr, int len)
				{
					int i = 0; int k = 0;
					for ( i = 0; i < len - 1; i++)
					{
						//前面从0~i的元素已经有序，准备插入的是第j=i+1个元素
						//将i+1和前面元素进行比较，从小到大进行排序，
						//如果当前比较的元素>i+1，向后移动
						k = i;
						data_t tmp = pArr[i + 1];
						while ( k >= 0 )
						{
							if ( pArr[k] > tmp ) //向后移动
							{
								pArr[k+1] = pArr[k];
								k--;
							}
							else 
							{
								break;
							}
						}
						pArr[k+1] = tmp;
					}
				}

			直接插入排序的时间复杂度T(n)=O(n2)
		二分法排序(折半排序)****

	void binarySort (data_t * pArr, int len )   
				{   
					int i, j, low, high, mid;
					for ( i = 1; i < len; i++ )  
					{  
						data_t tmp = pArr[i]; //待插入记录存入监视哨∥
						low = 0; high = i - 1;
						while (low <= high)   //查找pArr[i]的位置∥
						{  
							mid = ( low + high ) / 2;
							if ( tmp >= pArr[mid] )   
								low = mid + 1;   //调整下界∥
							else  
								high = mid - 1;  //调整上界∥
						}
						for ( j = i - 1; j >= low; j--)
							pArr[j + 1] = pArr[j];   //记录顺移∥
						pArr[low] = tmp;    ∥原pArr[i]插入low位置∥
					}
				} 

			折半排序的时间复杂度T(n)=O(nlog2n)
		链表排序*****

LIST * linkListSort( LIST * pList )
				{
					LIST * p, *q, *h;					
					if ( NULL == pList || NULL == pList->pNext )
					{
						return pList;
					}					
					// 让p指向准备插入的结点
					p = pList->pNext;
					// 让q指向p后面的结点 
					q = p->pNext;
					// 将链表置空
					pList->pNext = NULL;					
					while ( p )
					{
						h = pList;
						q = q->pNext;
						
						//循环找合适的位置 
						while ( h->pNext && h->pNext->data < p->data )
						{
							h = h->pNext;
						}
						//将p插入到h后面
						p->pNext = h->pNext;
						h->pNext = p;
						//准备插入下一个结点
						p = q;						
					}
					return pList;
				}

	交换排序
		冒泡排序

	void bubbleSort(data_t * pData , int len )
				{
					for ( int i = 0; i < len - 1; i++ )
					{
						for (int j = 0; j < len - i - 1; j++ )
						{
							if ( pData[j] < pData[j + 1])
							{
								data_t tmp = pData[j];
								pData[j] = pData[j + 1]
								pData[j + 1] = tmp;
							}
						}
					}
				}

		选择排序

思路：
					i = 0到len-1结束
					for ( int i = 0; i < len; i++ )
					{
						min = pData[i];
						每次从i+1到len-1的位置比较，找出最小值，并且记录下标为k
						for ( int j = i + 1; j < len; j++ )
						{
							if ( min < pData[j] )
							{
								min = pData[j];
								k = j;
							}
						}
						交换i和k所在位置的两个值
						pData[k] = pData[i];
						pData[i] = min;
					}	

		快速排序