数据结构
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;
}
快速排序