sort函数

1.python数据结构及算法基础学习笔记思维导图 2.程序代码演示 1.链表模型：linklist.py 1 """ 2 功能: 实现单链表的构建和操作 3 4 """ 5 6 # 创建节点类 7 class Node: 8 """ 9 思路 : *自定义类视为节点类,类中的属性为数据内容 10 *写一个next属性,用来和下一个 节点建立关系 11 """ 12 def __init__(self,val,next = None): 13 """ 14 val: 有用数据 15 next: 下一个节点引用 16 """ 17 self.val = val 18 self.next = next 19 20 21 # 链式线性表操作类 22 class LinkList: 23 """ 24 思路 : 生成单链表,通过实例化的对象就代表一个链表 25 可以调用具体的操作方法完成各种功能 26 """ 27 def __init__(self): 28 # 链表的初始化节点,没有有用数据,但是便于标记链表的开端 29 self.head = Node(None) 30 31 # 初始化链表,添加一组节点 32 def init_list(self,list_): 33 p = self.head # p 作为移动变量 34 for i in list_: 35 #

大概了解了一下八大排序，发现排序方法的难易程度相差很多，相应的，他们计算同一列表的时间也不尽相同。今天，我就准备了八种排序的python代码，并且准备测试一下他们计算的时间 1基数排序 基数排序的基本思想是先将数字按照个位数上数字的大小进行排序，排序之后再将已经排过序的数字再按照十位数上数字的大小进行排序，依次推类 # 统计这个列表中数字最大的数字有几位 def radix_sort_nums(nums): max = nums[0] for i in nums: if max < i: max = i times = 0 while max > 0: max = int(max/10) times += 1 return times # 每个数字各个位置的数字大小，比如（123,1）则是3，（123,2）则是2 def get_num(num,n): return (int(num/(10**(n-1)))) % 10 # 主程序 def radix_sort(nums): count = 10*[None] # 定义的数组，用于存放当前位数的元素个数 bucket = len(nums)*[None] # 用于暂时存放排序结果 # 分别从个位/十位/百位开始循环 for pos in range(1, radix_sort_nums(nums)+1): #

在1960年代，计算机制造商们曾经估计，如果将所有的用户计入，他们制造的计算机有25%的时间用于排序。实际上，有很多计算机花了超过一半的计算时间在排序上。通过这样的评估结果，我们可以得出结论，可能（i）确实有很多非常重要的和排序相关的应用，或者（ii）很多人在进行一些不必要的排序计算，再或者（iii）低效的排序算法被广泛采用造成了计算的浪费。 来源《The Art of Computer Programming》，作者Donald Knuth 在Python实践中，我们往往遇到排序问题，比如在对搜索结果打分的排序（没有排序就没有Google等搜索引擎的存在），当然，这样的例子数不胜数。《数据结构》也会花大量篇幅讲解排序。之前一段时间，由于需要，我复习了一下排序算法，并用Python实现了各种排序算法，放在这里作为参考。 最简单的排序有三种：插入排序，选择排序和冒泡排序。这三种排序比较简单，它们的平均时间复杂度均为O(n^2)，在这里对原理就不加赘述了。贴出来源代码。 插入排序： def insertion_sort(sort_list): iter_len = len(sort_list) if iter_len < 2: return sort_list for i in range(1, iter_len): key = sort_list[i] j = i - 1 while

本文对常见的排序算法进行了总结。 常见排序算法如下： 直接插入排序 希尔排序 简单选择排序 堆排序 冒泡排序 快速排序 归并排序 基数排序 它们都属于内部排序，也就是只考虑数据量较小仅需要使用内存的排序算法，他们之间关系如下： \[ \begin{cases}内部排序 \begin{cases}插入排序\begin{cases}直接插入排序\\希尔排序\end{cases}\\选择排序\begin{cases}简单选择排序\\堆排序\end{cases}\\交换排序\begin{cases}冒泡排序\\快速排序 \end{cases}\\归并排序\\ 基数排序\end{cases}\\外部排序 \end{cases} \] \[ \left\{\begin{matrix} 内部排序\\ 外部排序 \end{matrix}\right. \] 稳定与非稳定 : 如果一个排序算法能够保留数组中重复元素的相对位置则可以被称为是 稳定 的。反之，则是 非稳定 的。 直接插入排序 基本思想 通常人们整理桥牌的方法是一张一张的来，将每一张牌插入到其他已经有序的牌中的适当位置。在计算机的实现中，为了要给插入的元素腾出空间，我们需要将其余所有元素在插入之前都向右移动一位。 算法描述 一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下： 从第一个元素开始，该元素可以认为已经被排序

最简单的排序有三种：插入排序，选择排序和冒泡排序。它们的平均时间复杂度均为O(n^2)，在这里对原理就不加赘述了。 贴出源代码： 插入排序： 1 def insertion_sort(sort_list): 2 iter_len = len(sort_list) 3 if iter_len < 2: 4 return sort_list 5 for i in range(1, iter_len): 6 key = sort_list[i] 7 j = i - 1 8 while j>=0 and sort_list[j]>key: 9 sort_list[j+1] = sort_list[j] 10 j =j - 1 11 sort_list[j+1] = key 12 return sort_list 冒泡排序： 1 def bubble_sort(sort_list): 2 iter_len = len(sort_list) 3 if iter_len < 2: 4 return sort_list 5 for i in range(iter_len-1): 6 for j in range(iter_len-i-1): 7 if sort_list[j] > sort_list[j+1]: 8 sort_list[j], sort_list[j+1] = sort_list

1、算法概述 1.1 算法分类 　　非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。 　　线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。 1.2 算法复杂度 1.3 相关概念 　　稳定：如果a原本在b前面，而a = b，排序之后a仍然在b的前面 　　不稳定：如果a原本在b的前面，而a = b，排序之后a可能会出现在b的后面 　　时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。 　　空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。 2、冒泡排序(Bubble Sort) 　　冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。 2.1 算法描述 　　比较相邻的元素。如果第一个比第二个大，就交换它们两个。 　　对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数。 　　针对所有的元素重复以上的步骤，除了最后一个。 　　重复步骤1~3，直到排序完成。 2.2 动图演示 　　 2.3 代码实现

目录 一、容器 1、vector 2、stack、queue 3、list 4、set 5、map 二、常用函数 1、sort（） 2、next_permulation（） 一、容器 1、vector vector 是STL的动态数组，索引可以在常数时间内完成，插入或删除中间某一项需要线性时间，时间复杂度是O(n) vector<int> b(a); //用a定义b vector<int> a(100); //a有100个值为0的元素 vector<int> a(100, 6) //a有100个值为6的元素 vector<string> a(10, "hello"); vector<string> b(a.begin(), a.end()); // b是a的复制 a.insert(a.begin() + i, k); // 在第i个元素前插入k a.erase(a.begin() + i, a.bejin() + j); //删除区间[i, j - 1]的元素 a.erase(a.begin() + 2); // 删除第三个元素 reverse(a.begin(), a.end()); //翻转数组 hdu 4841 //#include <bits/stdc++.h> #include <vector> #include <iostream> using namespace

排序对比： 排序对比.jpg 排序分类： 排序分类.jpg 冒泡排序（Bubble Sort） 冒泡排序是一种简单的排序算法，它重复的走访要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来，走访数列的工作是重复的进行直到没有再需要交换，也就是说数列已经排序完成，这个算法的名字的由来是因为越小的元素会精油交换慢慢浮到数列的顶端。 1.初级版 function bubbleSort(array) { const length = array.length; for (let i = 0; i < length; i++) { for (let j = 0; j < length - 1 - i; j++) { if (array[j] > array[j + 1]) { let temp = array[j + 1]; array[j + 1] = array[j]; array[j] = temp; } } } return array; } 2.改进版 设置一个标志性变量pos，用于记录每趟排序中最后一次进行交换的位置，由于pos位置之后的记录均已交换到位，故在进行下一趟排序是只要扫描到pos位置即可 function bubbleSort(array) { let i = array.length - 1; while (i > 0) { let pos = 0;

经典排序算法 算法复杂度 相关概念 稳定 ：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定 ：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。 时间复杂度 ：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。 空间复杂度： 是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。 1、冒泡排序（Bubble Sort） 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 1.1 算法描述 比较相邻的元素。如果第一个比第二个大，就交换它们两个； 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 针对所有的元素重复以上的步骤，除了最后一个； 重复步骤1~3，直到排序完成。 1.2 动图演示 1.3 代码实现 1 function bubbleSort(arr) { 2 3 var len = arr.length; 4 5 for (var i = 0; i < len - 1; i++) { 6 7 for (var j = 0; j < len - 1 - i; j++

/** 冒泡排序(Bubble Sort) **/ function bubbleSort(arr) { var len = arr.length; for (var i = 0; i < len; i++) { for (var j = 0; j < len - 1 - i; j++) { if (arr[j] > arr[j+1]) { //相邻元素两两对比 var temp = arr[j+1]; //元素交换 arr[j+1] = arr[j]; arr[j] = temp; } } } return arr; } /**选择排序(Selection Sort) ： 不占用额外的内存空间 **/ function selectionSort(arr) { var len = arr.length; var minIndex, temp; for (var i = 0; i < len - 1; i++) { minIndex = i; for (var j = i + 1; j < len; j++) { if (arr[j] < arr[minIndex]) { //寻找最小的数 minIndex = j; //将最小数的索引保存 } } temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = temp; }