内部排序/内排序

内部排序是指待排序列完全存放在内存中所进行的排序过程，适合不太大的元素序列。

　　1.插入排序（直接插入排序）；
　　2.快速排序；
　　3.选择排序（简单选择排序）；
　　4.归并排序（递归排序）；
　　5.冒泡排序；
　　6.希尔排序；
　　希尔排序是对直接插入排序方法的改进。
　　7.堆排序；

---

1. 插入排序

时间复杂度：O(n^2)

---

2. 快速排序

时间复杂度：O(nlog2n)（理想的情况） O(n^2)  (最坏的情况)

​​​​​​​

def quick_sort(data):
    """quick_sort"""
    if len(data) >= 2:
        bench = data[0]
        #把第一个数设为基准
        left,right = [], []
        data.remove(bench)
        for num in data:
            if num >= bench:
                right.append(num)
            else:
                left.append(num)
        return quick_sort(left) + [bench] + quick_sort(right)
    else:
        return data

---

3.选择排序（简单选择排序）

时间复杂度：O(n^2)

 4. 归并排序 （递归排序）

时间复杂度：O(nlogn)

 5. 冒泡排序

时间复杂度： O(n^2)

原理：

- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 

- 针对所有的元素重复以上的步骤，除了最后一个。

- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

def BubbleSort(nums):
    N = len(nums):
    for i in range(N-1):
        for j in range(N - i - 1):
            if nums[j] > nums[j + 1]:
                nums[j], nums[j+1] = nums[j+1], nums[j]

冒泡算法的效率优化：

如果在某次冒泡操作中没有执行交换操作，那么说明这个数组已经排了好了，可以直接返回结果。

def BubbleSort(nums):
    N = len(nums)
    for i in range(N-1):
        flag = False
        for j in range(N-1-i):
            if nums[j] > nums[j+1]:
                nums[j],nums[j+1] = nums[j+1], nums[j]
                flag = True
        if not flag: break

6. 希尔排序

时间复杂度：O（nlogn）～O（n^2）

 6. 堆排序

时间复杂度：O(nlogn)

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。

步骤一

构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。

此时我们从最后一个非叶子结点开始，从左至右，从下至上进行调整。

步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序

---

python自带的sort和sorted的区别

https://www.cnblogs.com/clement-jiao/p/9243066.html