sort

题目大意： 给出0，1，…n-1的一个序列，要求通过两两狡猾的方式将其变为递增序列，但规定每次只能用0与其他数交换，求最小交换次数 思路： 1）如果数字0在i号位，找见数字i当前所处的位置，然后把0与i交换。 2）一旦一个非0的数字回到了它原先的位置，后面的步骤中就不用与0进行交换。 3）如果在交换过程中出现了0在0号位的情况，就随意选择一个没有在本位的数字与0交换位置 4）可以使用int型变量 count记录除0意外不在本位上的个数，并在读入时预处理其值。 5）在循环中找见一个不在本位上的数时，如果每一次都从头开始枚举，则会有两组数据超时 应当利用每一个移回本位的数不再移动的特点，从整体上定义一个变量k，用来保存目前不在本位上的最小数，当交换过程中出现0回归本位的情况， 总是从当前的k开始继续增大寻找不在本位上的数， 样例： 初始:[3 5 7 2 6 4 9 0 8 1] 第一步：0在7号位，与7交换：[3 5 0 2 6 4 9 7 8 1] 第二布：0在2号位，与2交换：[3 5 2 0 6 4 9 7 8 1] 第三步：0在3号位，与3交换：[0 5 2 3 6 4 9 7 8 1] 第四步：0在0号位，与一个还未在本位的数字5交换：[5 0 2 3 6 4 9 7 8 1] 第五步：0在1号位，与1交换：[5 1 2 3 6 4 9 7 8 0] 第六步：0在9号位

1.归 ListNode* sortList(ListNode* head) { if (head == nullptr || head->next == nullptr) return head; // 1.将待排序序列分为两部分 ListNode* pre = nullptr, *slow = head, *fast = head; while(fast != nullptr && fast->next != nullptr) { pre = slow; slow = slow->next; fast = fast->next->next; } pre->next = nullptr; // 2.对两个子部分再次进行划分 ListNode* l1 = sortList(head); ListNode* l2 = sortList(slow); // 3.合并 return merge(l1, l2); } 2.并 ListNode* merge(ListNode* l1, ListNode* l2) { ListNode* p = nullptr; if(l1->val < l2->val) { p = l1; l1 = l1->next; } else { p = l2; l2 = l2->next; } ListNode* l = p; while(l1 !=

基数排序 （ 英语 ： Radix sort ）是一种非比较型 整数 排序算法 ，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。基数排序的发明可以追溯到1887年 赫尔曼·何乐礼 在 打孔卡片制表机 （Tabulation Machine）上的贡献 [1] 。 它是这样实现的： 将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这 样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。 基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。 wikipedia百科定义： Each key is first figuratively dropped into one level of buckets corresponding to the value of the rightmost digit. Each bucket preserves the original order of the keys as the keys are

快排：最优复杂度 O（n*logn） 最坏时间复杂度O（n^2）平均时间复杂度n^(1.3) 归并排序：最优/平均/最坏 时间复杂度均O（nlogn）,但是内存占用为list大小的两倍，算法稳定 ############################## p5 排序 ################################### def bubble_sort(alist): """顺序表实现bubble""" n=len(alist) for j in range(0,n-1):#遍历次数，没遍历一次 遍历长度-1 遍历j次 -j count = 0 for i in range(0,n-1-j):#一次循环找到最大值，并且移动到最后位置 主体 if alist[i]>alist[i+1]: alist[i],alist[i+1]=alist[i+1],alist[i] count+=1 if 0 == count: return #####count 优化 不交换数字 不增加计数 def choose_sort(alist): """选择排序：找到最小的数字，放到最前面""" min = 0 n = len(alist) for j in range(0,n-2): min = j for i in range(j+1,n): if alist[min]>alist

高效使用STL 参考：http://blog.jobbole.com/99115/ 仅仅是个选择的问题，都是STL，可能写出来的效率相差几倍； 熟悉以下条款，高效的使用STL； 当对象很大时，建立指针的容器而不是对象的容器 1）STL基于拷贝的方式的来工作，任何需要放入STL中的元素，都会被复制； 这也好理解，STL工作的容器是在堆内开辟的一块新空间，而我们自己的变量一般存放在函数栈或另一块堆空间中；为了能够完全控制STL自己的元素，为了能在自己的地盘随心干活；这就涉及到复制； 而如果复制的对象很大，由复制带来的性能代价也不小 ； 对于大对象的操作，使用指针来代替对象能消除这方面的代价； 2）只涉及到指针拷贝操作， 没有额外类的构造函数和赋值构造函数的调用； vecttor vt1; vt1.push_bach(myBigObj); vecttor vt2; vt2.push_bach(new BigObj()); 注意事项： 1）容器销毁前需要自行销毁指针所指向的对象；否则就造成了内存泄漏； 2）使用排序等算法时，需要构造基于对象的比较函数，如果使用默认的比较函数，其结果是基于指针大小的比较，而不是对象的比较； 用empty() 代替size()来检查是否为空 因为对于list，size()会遍历每一个元素来确定大小，时间复杂度 o（n），线性时间；而empty总是保证常数时间；

priority_queue < Type , Container , Functional > 优先队列 1. https : / / www . cnblogs . com / huashanqingzhu / p / 11040390. html //优先队列具有队列的所有特性，包括队列的基本操作，只是在这基础上添加了内部的一个排序，它本质是一个堆实现的。 //对于基础类型 默认是大顶堆 priority_queue < int > a ; //等同于 priority_queue<int, vector<int>, less<int> > a; // 这里一定要有空格，不然成了右移运算符>> ↓↓ priority_queue < int , vector < int > , greater < int > > c ; //这样就是小顶堆 priority_queue < string > b ; 2. https : / / www . cnblogs . com / yaoyueduzhen / p / 4456430. html top ( ) 返回优先队列对顶元素 //队列中最大的元素总是位于队首，所以出队时，并非按照先进先出的原则进行，而是将当前队列中最大的元素出队 //元素的比较规则默认按元素值由大到小排序，可以重载“<”操作符来重新定义比较规则。

算法概述 常见的排序算可以分为以下两类： 非线性时间比较类排序：通过比较来决定元素间的相对次序，由于时间复杂度不能突破nlogn，因此称为非线性时间比较类排序 线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下限，以线性时间运行，因此称为线性时间非比较类排序 排序相关概念： 稳定：如果a原本在b的前面，且a=b，排序之后a仍然在b的前面 不稳定：如果a原本在b的前面，且a=b，排序之后可能出现在b的后面 一、快速排序 快速排序（Quicksort）是对冒泡排序的一种改进。 快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 排序流程 首先设定一个分界值，通过该分界值将数组分成左右两个部分 将大于或等于分界值得数据集中到数组右边，小于分界值得数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成两部分，同样在左边放置较小值，右边放置较大值，右侧的数据数据也可以做类似的处理 重复上述过程

列表的sort()和sorted()方法 sort()与sorted()的不同在于，sort是在原位重新排列列表，而sorted()是产生一个新的列表。 sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 注：sorted不是列表方法。 1. sort ( ) 方法 sort函数的原型 　　sort ( key = None , reverse = False ) 　　key 可指定一些规则，可以是k = int , k = len , k = function函数 　　reverse 默认值是 False 　　可以给它赋值成 True ，那就是反向排序 　　简单的列表排序 l = [ 1 , 7 , 4 , 9 , 2 , 3 , 5 , 0 , 8 , 6 ] l . sort ( ) print ( l ) 结果： [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] #类表中嵌套其他数据类型，如字典 # a = [{'id':1,'name':'小明'}，{'id':3,'name':'小红'}，{'id':2,'name':'老王'}] # 根据字典的key值id进行降序排序并输出排序后的列表。 def function ( date ) : print ( date ) print ( date [

学了不清真的 \(sort\) 写法 \(CDQ\) 分治的蒟蒻在本题的数据面前瑟瑟发抖。。。。。 实际上就是一个常规的 \(CDQ\) 模型，但是关键难点有两个： 需要进行四次 \(CDQ\) 。你可以选择把图旋转四次， 也可以像我一样写四次 \(solve\) 从而获得 \(7kb\) 的代码 用树状数组维护区间最大值的时候 \(y\) 可能为 \(0\) ，会死循环，要 \(+1\) 处理。 不要使用不清真的 \(sort\) 写法！ \(Code:\) // luogu-judger-enable-o2 #include <bits/stdc++.h> using namespace std; const int N = 300000 + 5; const int M = 600000 + 5; const int K = 1000000 + 100; const int MaxK = 1000000 + 50; const int INF = 0x3f3f3f3f; #define lowbit(x) (x & -x) int n, m, tot, qry[N], qryid; struct Node { int x, y, w, id, ans, opt; // 1 / 2 : 操作 / 查询 void out () { if (opt == 1) { cout <<

今天在做一道题时，因为忘了Python中sort和sorted的用法与区别导致程序一直报错，找了好久才知道是使用方法错误的问题！现在就大致的归纳一下sort和sorted的用法与区别 1. sort： 　　sort是Python中列表的方法 　　sort() 方法语法： 　　　　list.sort(key=None, reverse=False) 　　　　有两个参数，这里不讲第一个参数，第二个参数当 reverse=True时为降序排列，reverse=False为升序排列，默认reverse=False 　　　　重要： 该方法没有返回值，也就是返回值为 None，而我也正是在这里犯错了 　　代码案例： 1 """test""" 2 3 a = [4, 5, 6, 3, 2, 320, 5, 1] # 创建一个列表 4 5 print(a) # 打印列表，输出为：[4, 5, 6, 3, 2, 320, 5, 1] 6 7 print(a.sort()) # 输出为：None 8 print(a) # 输出为：[1, 2, 3, 4, 5, 5, 6, 320] 9 10 a = a.sort() 11 print(a) # 输出为：None 　　错用 a = a.sort()，以为可以把列表 a 按升序排列，其实只会把 a 变为 None，并不是真正想要的结果