排序算法

算法描述 归并操作的过程如下： 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 设定两个指针，最初位置分别为两个已经排序序列的起始位置 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置 重复步骤3直到某一指针达到序列尾 将另一序列剩下的所有元素直接复制到合并序列尾 示例代码 #include<iostream> using namespace std; int data[8]={1,2,3,4,1,9,6,8}; int merge(int unSorted[],int sorted[],int first,int mid,int last){ int fpoint=first; int spoint=mid+1; int sortedPoint=first; while(fpoint<=mid && spoint<=last){ if(unSorted[fpoint]<unSorted[spoint]) sorted[sortedPoint++]=unSorted[fpoint++]; else sorted[sortedPoint++]=unSorted[spoint++]; } if(fpoint>mid) while(sortedPoint<=last) sorted[sortedPoint++]=unSorted

介绍： 比较算法大致可以分为两种，一种为比较算法，另一种为非比较算法。 比较算法有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序，希尔排序。 非比较算法有：计数排序，基数排序，桶排序。 https://gitee.com/linqiankun/Utils/tree/v3.0/ 时间复杂度: 排序方法 最好情况 平均情况 最差情况 辅助空间 稳定性 冒泡排序 n n^2 n^2 1 yes 选择排序 n^2 n^2 n^2 1 no 插入排序 n n^2 n^2 1 yes 归并排序 nlogn nlogn nlogn n yes 堆排序 nlogn nlogn nlogn 1 no 快速排序 nlogn nlogn n^2 1 no 希尔排序 n^1.3 nlogn～n^2 n^2 logn~n no 比较算法： 冒泡排序 普通冒泡排序 冒泡排序是一种极为简单的排序算法。通过循环反复的遍历数组中的元素，依次比较相邻的两个元素。如果不满足排序规则，就进行位置交换，直到没有元素需要交换位置，排序完成。 这个算法会慢慢的使元素按照需要的顺序浮出来。 时间复杂度为：O(n)～O(n^2)~O(n^2) 冒泡排序运行顺序： 比较相邻元素，按照排序规则进行位置交换。 对每一对相邻元素进行第一步的操作，操作完之后，队伍最后会是满足条件的数。循环体的内层循环走完一圈。

从刚上大一那会儿学的 C 语言开始，就已经接触到了不少排序 算法 ，但当时都只是为了完成简单的排序任务而已，而且所给的数据也不够多，所以看不出各个排序 算法 间的执行效率的优劣。最近有个数据结构课程设计的实验，是有关于排序 算法 之间的效率比较，我就顺便把它放上来了，并对各个算法执行的效率时间做了柱形统计图表。此次实验主要测试了8种排序算法：插入排序、快速排序、冒泡排序、希尔排序、简单选择排序、堆排序、归并排序、折半插入排序。 总共建立了三种情况，分别是平均排序、最好情况排序、最坏情况排序。第一种情况就是使用了VC6.0下的随机数生成函数输出100000个随机数进行排序；第二种情况是100000个数本身已经按从小到大的顺序排列了；第三种情况就是100000个数全部是按逆序排列。代码如下： #include<stdio.h> #include<stdlib.h> #include<time.h> #include<windows.h> #define MAX 100000 void InsSort(int r[],int length) { int i,j; for (i=2;i<=length;i++) { r[0]=r[i]; j=i-1; while(r[0]<r[j]) { r[j+1]=r[j]; j=j-1; } r[j+1]=r[0]; } } //插入排序 void

排序法 最好时间分析 最差时间分析 平均时间复杂度 稳定度 空间复杂度 冒泡排序 O(n)（改进的冒泡排序） O(n2) O(n2) 稳定 O(1) 快速排序 O(n*log2n) O(n2) O(n*log2n) 不稳定 O(log2n)~O(n) 选择排序 O(n2) O(n2) O(n2) 不稳定 O(1) 二叉树排序 O(n2) O(n*log2n) O(n) 插入排序 O（n） O(n2) O(n2) 稳定 O(1) 堆排序 O(n*log2n) O(n*log2n) O(n*log2n) 不稳定 O(1) 希尔排序 / 与增量序列的选取有关 与增量序列的选取有关 不稳定 O(1) 归并排序 O(n*log2n) O(n*log2n) O(n*log2n) 稳定 O(n) 本文中的排序验证OJ：http://pta.patest.cn/pta/test/18/exam/4/question/633 OJ测试点说明： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：10 3 个随机整数； 数据4：10 4 个随机整数； 数据5：10 5 个随机整数； 数据6：10 5 个顺序整数； 数据7：10 5 个逆序整数； 数据8：10 5 个基本有序的整数； 数据9：10 5 个随机正整数，每个数字不超过1000。 排序算法稳定性：

sort排序总结+详细 C++中vector和set都是非常方便的容器， sort方法是algorithm头文件里的一个标准函数，能进行高效的排序，默认是按元素从小到大排序 将sort方法用到vector和set中能实现多种符合自己需求的排序 首先sort方法可以对静态的数组进行排序 #include<iostream> using namespace std; int main(){ int a[10] = { 9, 0, 1, 2, 3, 7, 4, 5, 100, 10 }; sort(a, a +10); for (int i = 0; i < 10; i++) cout << a[i] << endl; return 0; } 这里可以看到是sort(a,a+10)，但是数组a一共只有9个元素，为什么是a+10而不是a+9呢？ 因为sort方法实际上最后一位地址对应的数是不取的， 而且vector，set，map这些容器的end()取出来的值实际上并不是最后一个值，而end的前一个才是最后一个值！ 需要用prev(xxx.end())，才能取出容器中最后一个元素。 对vector使用sort函数： 第一种情形：基本类型,如vector,vector,vector也是可以的 #include<iostream> #include<vector> #include

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。 示例: 输入: [ 1->4->5, 1->3->4, 2->6 ] 输出: 1->1->2->3->4->4->5->6 思路： 两个两个组合，排序 使用递归 使用递归就要找截止条件(当节点为null) /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode mergeKLists ( ListNode [ ] lists ) { //当长度为0 就是没有链表 if ( lists . length == 0 ) { return null ; } //当长度为1 只有一个单链表 不用排序 直接返回 if ( lists . length == 1 ) { return lists [ 0 ] ; } //当长度为2 将这两个链表直接排序 if ( lists . length == 2 ) { return mergeTwoLists ( lists [ 0 ] , lists [ 1 ] ) ; } //将数组分成两部分 int

C++风格的常用排序算法（冒泡，选择，插入，归并，选择） # include <vector> # include <array> # include <iostream> using namespace std ; # define vint vector<int> //异或置换函数 void swapab ( int & a , int & b ) { a = a ^ b ; b = a ^ b ; a = a ^ b ; } //冒泡排序 vint mp ( vint arr ) { int temp = 0 ; for ( int i = 0 ; i < arr . size ( ) ; i ++ ) { for ( int j = 0 ; j < arr . size ( ) - i - 1 ; j ++ ) { if ( arr [ j ] > arr [ j + 1 ] ) { swapab ( arr [ j ] , arr [ j + 1 ] ) ; } } } return arr ; } //选择排序 vint xz ( vint arr ) { int is = 0 ; int currMin = 0 ; int temp = 0 ; for ( int i = 0 ; i < arr . size ( ) ; i ++ ) { currMin = i ;

题目描述 排序在各种场合经常被用到。 快速排序是十分常用的高效率的算法。 其思想是：先选一个“标尺”， 用它把整个队列过一遍筛子， 以保证：其左边的元素都不大于它，其右边的元素都不小于它。 这样，排序问题就被分割为两个子区间。 再分别对子区间排序就可以了。 下面的代码是一种实现，请分析并填写划线部分缺少的代码。 思路 就是快排的另一种写法，思路和 快速排序 一样 代码 # include <stdio.h> void swap ( int a [ ] , int i , int j ) { int t = a [ i ] ; a [ i ] = a [ j ] ; a [ j ] = t ; } int partition ( int a [ ] , int p , int r ) { int i = p ; int j = r + 1 ; int x = a [ p ] ; while ( 1 ) { while ( i < r && a [ ++ i ] < x ) ; while ( a [ -- j ] > x ) ; if ( i >= j ) break ; swap ( a , i , j ) ; } swap ( a , p , i ) ; //填空处 return j ; } void quicksort ( int a [ ] , int p , int r )

题目 解题 设置两个节点newhead,newnext,newnext用于遍历链表中的所有元素，newhead通过判断newhead.val与newnext.val是否相等，指向不重复的元素，达到删除重复元素的效果。 注意遍历结束后要将newhead.next=null,否则若原链表最后两个元素相等，删除后的新链表会保留该重复元素。 public ListNode DeleteDuplicates ( ListNode head ) { if ( head == null || head . next == null ) { return head ; } ListNode newhead = head ; ListNode newnext = head . next ; while ( newnext != null ) { if ( newhead . val != newnext . val ) { newhead . next = newnext ; newhead = newnext ; } newnext = newnext . next ; } newhead . next = null ; return head ; } 来源： CSDN 作者： Leeyayai 链接： https://blog.csdn.net/qq_44425179/article

1.快速排序 import time def cal_time ( func ) : def inner ( * args , ** kwargs ) : time1 = time . time ( ) func ( * args , ** kwargs ) time2 = time . time ( ) print ( 'this is consume %s miao' % ( time2 - time1 ) ) return inner def paration ( li , left , right ) : tmp = li [ left ] while left < right : while left < right and li [ right ] >= tmp : right -= 1 li [ left ] = li [ right ] while left < right and li [ left ] <= tmp : left += 1 li [ right ] = li [ left ] li [ left ] = tmp return left def _quick_sort ( li , left , right ) : if left < right : mid = paration ( li , left , right ) _quick_sort