简介
基础的数据结构一般就包括，链表，队列，二叉树图，基础的数据结构对象，再就是比较基础的算法，查找排序，刚开始学算法宇数据结构的小伙伴都会接触到这几种类型，在大学的时候，因为当时是用的C++进行的编程，对几种简单的排序算法比较熟悉，简单的说分为4种，选择排序，冒泡排序，归并排序，希尔排序，这四种可以说是比较常规的四种排序算法，其中冒泡排序跟归并排序算法是稳定的，算法的时间复杂度分别是O(),O(),O(),O(),跟冒泡排序算法相似的，还有个就是快速排序，跟冒泡排序类似，都属属于交换元素排序。下面废话不说，直接贴python实现的代码，个人最近在转python，所以什么还是都是用python撸一把吧。
选择排序
def select_sort(origin_items, comp=lambda x, y: x < y):#不得不说lambda函数是真的好用啊，跟R里面的apply函数族有一拼了
"""简单选择排序"""
items = origin_items[:]
for i in range(len(items) - 1):
min_index = i
for j in range(i + 1, len(items)):
if comp(items[j], items[min_index]):#调用定义的lambda函数
min_index = j
items[i], items[min_index] = items[min_index], items[i]
return items
#简单的总结一下，其实选择排序，不断将小的元素向前移动，大的元素向后移，慢慢成为一个有序的序列
冒泡排序
def bubble_sort(origin_items, comp=lambda x, y: x > y):
"""高质量冒泡排序(搅拌排序)"""
items = origin_items[:]
for i in range(len(items) - 1):
swapped = False
for j in range(i, len(items) - 1 - i):
if comp(items[j], items[j + 1]):
items[j], items[j + 1] = items[j + 1], items[j]
swapped = True
if swapped:
swapped = False
for j in range(len(items) - 2 - i, i, -1):
if comp(items[j - 1], items[j]):
items[j], items[j - 1] = items[j - 1], items[j]
swapped = True
if not swapped:
break
return items
####冒泡排序算法跟选择排序很类似，正常的是一次只确定一个最终的位置，一般是确定最大的元素的在排序种的位置，这个是修改之后的冒泡排序算法，主要是多了一步将最小元素排序的操作，也就是一次循环到结尾，再回来的时候将最小的排完，然后以此类推，排序的范围越来越小，提高了排序的效率，也叫做鸡尾酒排序，下面是示意图。
希尔排序算法
希尔排序是小规模数据排序的最优选择，算法的核心思想就是对插入排序的封装，逐渐减小增量形成新的数组进行插入排序。希尔排序跟前面的白话的排序算法不是很相似，他主要是将数据按步长进行分组，然后对每组中的数，按简单插入排序，然后排序结束之后再将数进行组合，再组合结束后形成新的顺序，然后再将数按新的步长进行排序，随着增量的减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
对于步长的选择如下
在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。举个简单的例子如下
[例子来源https://www.cnblogs.com/chengxiao/p/6104371.html]
对直接插入排序还不懂的小伙伴需要复习下了，这个是很简单的，说白了就是将无序的队列中的元素插入到有序的队列中
下面是实现的代码
def shell_sort(A):
N = len(A)
increment = N//2
while increment > 0:
i = increment
while i < N:
j = i - increment
tmp = A[i]
while j >= 0 and A[j] > tmp:
A[j + increment] = A[j]
j -= increment
A[j + increment] = tmp
i += 1
increment //= 2
return None
归并排序
归并排序算法其实是一种比较经典的分治法排序的算法，将一个大的序列不断分成小的了序列，然后将小的序列进行排序，排完序之后再将这些小的序列进行合并，其实主要是分为两个简单的步骤，第一个是分，第二个是合，个人觉得再合部分可能有点歧义，下面补充一个简单的例子来进行展示。
下面直接上代码
def merge_sort(items, comp=lambda x, y: x <= y):
"""归并排序(分治法)"""
if len(items) < 2:
return items[:]
mid = len(items) // 2
left = merge_sort(items[:mid], comp)
right = merge_sort(items[mid:], comp)
return merge(left, right, comp)
def merge(items1, items2, comp):
"""合并(将两个有序的列表合并成一个有序的列表)"""
items = []
index, index2 = 0, 0
while index1 < len(items1) and index2 < len(items2):
if comp(items1[index1], items2[index2]):
items.append(items1[index1])
index1 += 1
else:
items.append(items2[index2])
index2 += 1
items += items1[index1:]
items += items2[index2:]
return items
拓展内容
现在是大数据的时代，那么如何对海量的大数据进行排序呢？其实我觉的 Hadoop就是来解决这种问题，他的Mapreduce策列，可以很好的实现大数据的分布与计算，但这里不进行Hadoop的介绍，这里主要是介绍一些传统的方法。
1.首先比较传统的思想肯定是分割，也就是分治法，大的数据集不断分成小的数据，然后将小的数据进行排序，最后形成有序的数据。特别注意，对数据的分割要是有序的。再就是如果是进一步提高性能的话，可以再I/O的过程进行优化，减少I/O的过程，将多个段进行合并之后在进行I/O操作，还有就是：
可以使用并发的操作：如多磁盘（并发I/O提高）、多线程、使用异步I/O、使用多台主机集群计算等。（其实这些再Hadoop里面可以完全都顾及了，Spark实现map，Hadoop实现对资源的整合与利用）
2.字典树方法，其数据结构如下
String name; // 结点的字符名称
int fre; // 单词的词频
boolean end; // 是否是单词结尾
boolean root; // 是否是根结点
Node[] children; // 子节点信息
boolean visited; // 是否已经遍历过了
int minLength; // 通过该节点的最小的数字长度
int prefixCount = 0; // 有多少单词通过这个节点,即节点字符出现的次数
Node parent; // 当前节点的父节点
具体的字典树的操作不在这里详细的赘述。
下次更新下Hadoop里面的Mapreduce的原理过程。