一、Python所有方向的学习路线
Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
二、学习软件
工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。
三、入门学习视频
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
预排列的原理也是插入排列，只不过这里的将数组分成了gap组，分别对每一个小组进行插入排序
如下动图：对于升序，当gap从5 – 2 – 1的过程中，排在后面的数值小的数能更快排到前面，当gap为1的时候实际上就是进行了一次插入排序
- 动图展示：
// 希尔排序
void ShellSort(int\* a, int n)
{
//多组预排（一锅炖）+插排
int gap = n;
while (gap > 1)
{
gap /= 2;//保证最后一次分组gap==1,即最后一次为直接插入排序
//gap = gap / 3 + 1;//也可以写成这样，除3预排的效率相比于除2的好点
for (int i = 0; i < n - gap; i++)
{
int end = i;
int x = a[end + gap];
while (end >= 0)
{
if (a[end] > x)
{
a[end + gap] = a[end];
end-=gap;
}
else
break;
}
a[end + gap] = x;
}
}
}
- 希尔排序的特性总结：
- 希尔排序是对直接插入排序的优化
- 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比
- 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，一般来说为O(n^1.3)
- 稳定性：不稳定
五、选择排序
1、直接选择排序
- 基本思想：
每一次遍历待排序的数据元素从中选出最小（或最大）的一个元素，存放在序列的起始（或者末尾）位置，直到全部待排序的数据元素排完
- 动图展示：
- 实现代码：
// 选择排序
void SelectSort(int\* a, int n)
{
int begin = 0, end = n - 1;//记录下标
while (begin < end)
{
int mini = begin;
for (int i = begin; i <= end; i++)
{
//遍历找到最小数据并记录下标
if (a[i] < a[mini])
mini = i;
}
Swap(&a[begin], &a[mini]);//交换
begin++;//缩小范围
}
}
这里我们还可以对直接选择排序做一个优化：每次遍历待排序数据找出最大和最小的数据，分别排列到序列起始和末尾
- 优化代码：
// 选择排序（优化版）
void SelectSort(int\* a, int n)
{
int begin = 0, end = n - 1;
while (begin < end)
{
int maxi = begin, mini = begin;
for (int i = begin; i <= end; i++)//遍历找到最大最小的下标
{
if (a[i] > a[maxi])
maxi = i;
if (a[i] < a[mini])
mini = i;
}
Swap(&a[begin], &a[mini]);//交换
//当最初始位置begin与对大数据下标重合的情况
if (begin == maxi)//修正下标位置
maxi = mini;
Swap(&a[end], &a[maxi]);
begin++;//缩小范围
end--;
}
}
- 直接选择排序的特性总结：
- 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：不稳定
2、堆排序
堆排序是指利用堆（数据结构）进行选择数据的一种排序算法
- 基本思想:
- 原则：
先将原数组建成堆，需要注意的是排升序要建大堆，排降序建小堆
注：以大堆为例- 建堆：
一个根节点与子节点数据如果不符合大堆结构，那么则对根节点数据进行向下调整，而向下调整的前提是左右子树也符合大堆结构,所以从堆尾数据的根节点位置开始向下调整建大堆- 排序：
大堆堆顶数据一定是待排数据中最大的，将堆顶数据与堆尾数据交换,交换后将除堆尾数据看成新堆，对现堆顶数据进行向下调整成大堆,以此循环直至排列完毕- 向下调整：
找到子节点中的较大数据节点比较，如果父节点数据比大子节点小则交换，直到不符合则停止向下交换，此时再次构成了一个大堆结构
具体堆排序详解：堆排序超详解
- 动图展示：大堆排序
- 实现代码：
void Adjustdown(int\* a, int n,int parent)
{
int child = parent \* 2 + 1;
while (child < n)
{
//找到数据大的子结点
if (child + 1 < n && a[child + 1] > a[child])
{
child++;
}
//父节点数据小于子节点就交换
if (a[parent] < a[child])
{
Swap(&a[parent], &a[child]);
//更新下标
parent = child;
child = parent \* 2 + 1;
}
else//否则向下调整完毕
break;
}
}
// 堆排序(升序)建大堆
void HeapSort(int\* a, int n)
{
int i;
//建大堆
for (i = (n - 1 - 1) / 2; i >= 0; i--)
{
Adjustdown(a, n, i);
}
//交换调整
for (i = n - 1; i >= 0; i--)
{
Swap(&a[0], &a[i]);//与当前堆尾数据交换
Adjustdown(a, i, 0);//对交换后堆顶数据进行向下调整
}
}
- 直接选择排序的特性总结：
- 堆排序使用堆来选数，效率就高了很多。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(1)
- 稳定性：不稳定
六、交换排序
1、冒泡排序
- 基本思想：
每次遍历待排序数组，对相邻数据进行比较，不符合排序要求则交换
- 动图展示：
- 实现代码：
// 冒泡排序
void BubbleSort(int\* a, int n)
{
int i, j;
for (i = 0; i < n - 1; i++)//遍历趟数
{
for (j = 0; j < n - 1 - i; j++)//比较次数
{
if (a[j] > a[j + 1])//升序
Swap(&a[j], &a[j + 1]);//交换
}
}
}
- 冒泡排序的特性总结：
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：稳定
2、快速排序
- 基本思想为：
任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列
左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值 然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止
- 按基准值划分左右的方式有：
1）hoare
注：基本操作过程如图示
- 实现代码：
// 按基准划分hoare版本
int PartSort1(int\* a, int left, int right)
{
int mid = GetMidIndex(a, left, right);//三数取中（优化取基准值，后面会解释）
Swap(&a[mid], &a[left]);//使得中间值永远在最左，便于决定谁先走
int key = left;
while (left < right)
{
//Key设在左边，先从右边寻找小于a[key]的
while (left < right && a[right] >= a[key])
{
right--;
}
//再从左边寻找大于a[key]的
while (left < right && a[left] <= a[key])
{
left++;
}
//找到后交换
Swap(&a[left], &a[right]);
}
//最后相遇时将key与相遇点交换
Swap(&a[key], &a[left]);
return left;//返回相遇点下标
}
- key的位置与左右下标谁先走的关系：
注：对于排升序来说
一般来说在三数取中后得到中等值key，我们让该值与待排序数组的最左边起始位置交换，使得key永远在最左边，并且之后会让右下标先走找小于key的值，找到后再让左下标走找大于key的值，都找到则交换，相遇后再将key与相遇位置的值交换
- 右下标先走的话，对于两下标相遇的的情况只有两种：
- 右下标走着走着遇到左下标，此时左下标的值一定是小于key的值（交换后左下标是原来右下标的小于key的值）
- 左下标走着走着遇到右下标，此时右下标的值一定是小于key的是（右下标找小于key的值）
- 所以这样保证了最后下标相遇与key交换后，key左边区间一定小于key，右边区间一定大于key
2）挖坑法
注：基本操作过程如图示
- 实现代码：
// 快速排序挖坑法
int PartSort2(int\* a, int left, int right)
{
int mid = GetMidIndex(a, left, right);
Swap(&a[mid], &a[left]);//使得中间值永远在最左，便于决定谁先走
int key = a[left];//保存key值（基准值）
int pivot = left;//保存坑下标
while (left < right)
{
//右边先找
while (left<right && a[right]>=key)
{
right--;
}
//填坑
a[pivot] = a[right];
pivot = right;
//再从左边找
while (left < right && a[left] <= key)
{
left++;
}
//填坑
a[pivot] = a[left];
pivot = left;
}
//相遇
a[pivot] = key;
return pivot;
}
3）前后指针法
注：基本操作过程如图示
- 实现代码：
// 快速排序前后指针法（推荐）
int PartSort3(int\* a, int left, int right)
{
int mid = GetMidIndex(a, left, right);
Swap(&a[mid], &a[left]);
//初始化前后指针
int cur = left+1, prev = left;
while (cur < right)
{
if(a[cur]<a[left] )//找到比基准值小的
Swap(&a[++prev], &a[cur]);
cur++;
}
Swap(&a[prev], &a[left]);//遍历结束将基准值放在定位点
return prev;
}
注：推荐掌握，简单易于操控
4）优化
- 三数取中：
- 如果基准值取到的是待排序列中的中位数，对于快排来说效率是最优的
- 如果基准值取到的是待排序列中的最大或最小，对于快排来说效率是最差的
为了优化这种特殊情况，我们在取基准值时会采取三数取中，即堆待排序序列的开始处，末尾处和中间处位置的数据进行比较，得到排中的数据，尽量使得快速排序的效率达到理想状态O(N*logN)
- 实现代码：
int GetMidIndex(int\* a, int left, int right)//优化快排(避免特殊情况造成效率降低)
{
int mid = right + (left - right) >> 1;//获取中间下标（注意避免和溢出）
if (a[mid]>a[left])//返回中等数据的下标
{
return a[mid] < a[right] ? mid : right;
}
else//a[mid]<=a[left]
{
return a[left] < a[right] ? left : right;
}
}
整体实现代码：
//快排
void QuickSort(int\* a, int left, int right)
{
//当区间只有一个元素或没有元素时不需要排序了
if (left >= right)
return;
//遍历一趟进行交换排序
int mid=PartSort3(a, left, right);
//递归排序左右区间
QuickSort(a, left, mid - 1);
QuickSort(a, mid+1, right);
}
- 小区间优化：
当待排序数组的区间很小时，递归开辟的函数栈帧数量时很大的，很多时甚至可能造成栈溢出
为了解决这一问题，当区间小到一定程度时，我们选择使用希尔排序，小到一定程度时待排序数列已经快接近有序，而希尔排序对于接近有序数列的排序时非常高效的
- 实现代码：
//快排+局部优化
void QuickSort1(int\* a, int left, int right)
{
if (left >= right)//当区间只有一个元素或没有元素时递归结束
return;
if (right - left + 1 <= 10)
{
InsertSort(a + left, right - left + 1);
}
else
{
int mid = PartSort3(a, left, right);//进行一趟交换排序
QuickSort1(a, left, mid - 1);//递归交换排序
QuickSort1(a, mid + 1, right);
}
}
- 快速排序的特性总结：
- 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
- 时间复杂度：O(N*logN)
- 空间复杂度：O(logN)
- 稳定性：不稳定
3、快排非递归
- 基本思想;
对于递归函数在内存实际上是在栈中进行开辟函数栈帧，这里我们使用数据结构中的栈来模拟内存中的栈，从而实现快排的非递归
- 实现代码：
// 快速排序 非递归实现
void QuickSortNonR(int\* a, int left, int right)
{
//首先构建一个栈（C语言来说需要自己实现）
ST st;
StackInit(&st);
StackPush(&st, left);//将左右区间入栈
StackPush(&st, right);
while (!StackEmpty(&st))
{
int end = StackTop(&st);//读取区间数据
StackPop(&st);
int begin = StackTop(&st);
StackPop(&st);
int mid = PartSort3(a, begin, end);//排序（排好基准值）
//划分基准值的左右区间
int begin1 = mid + 1, end1 = end;
//先入右边区域（栈的特点是先入后出）
if (end1 - begin1 + 1 > 1)
{
StackPush(&st, begin1);
StackPush(&st, end1);
}
//再将左边区域入栈
int begin2 = begin, end2 = mid-1;
if (end2 - begin2 + 1 > 1)
{
StackPush(&st, begin2);
StackPush(&st, end2);
}
}
//到空栈则排序结束
StackDestroy(&st);//栈销毁
}
七、归并排序
归并排序是建立在归并操作上的一种有效的排序算法，采用分治法
1、归并排序
1）递归归并
- 基本思想：
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序
- 核心步骤：
- 动图展示：
- 实现代码：
//归并排序
void \_MergeSort(int\* a, int left, int right, int\* tmp)
{
if (left >= right)//只有一个元素或没有元素为有序，则返回
return;
int mid = (right + left) / 2;
\_MergeSort(a, left, mid, tmp);
\_MergeSort(a, mid+1, right, tmp);
//左区间和右区间有序后开始归并
int begin1 = left, end1 = mid;
int begin2 = mid+1, end2 = right;
int p = left;//记录下标
while (begin1<=end1&&begin2<=end2)//归并排序
{
if (a[begin1] < a[begin2])//升序
{
tmp[p++] = a[begin1++];
}
else
{
tmp[p++] = a[begin2++];
}
}
while (begin1 <= end1)//剩下部分
{
tmp[p++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[p++] = a[begin2++];
}
//拷贝回数组a
for (int i = left; i <= right; i++)
{
a[i] = tmp[i];
}
void MergeSort(int\* a, int n)
{
//创建暂存数据数组（保存归并好的数据）
int\* tmp = (int\*)malloc(sizeof(int) \* n);
if (tmp == NULL)
{
perror("nalloc fail\n");
exit(-1);
}
//归并排序
\_MergeSort(a, 0, n - 1, tmp);
//释放
free(tmp);
tmp = NULL;
}
- 归并排序的特性总结：
- 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题
- 时间复杂度：O(N*logN)
- 空间复杂度：O(N)
- 稳定性：稳定
2）非递归归并
- 基本思路：
感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：
① 2000多本Python电子书（主流和经典的书籍应该都有了）
② Python标准库资料（最全中文版）
③ 项目源码（四五十个有趣且经典的练手项目及源码）
④ Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）
⑤ Python学习路线图（告别不入流的学习）
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
扫一扫
481
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
