sort

3 月，跳不动了？>>> 一、分治法的思想 把复杂的问题分解，再分解，成为很小的问题，解决这些小问题之后合并，再合并。这就是分治法的思想。 通常分治法是递归的。 二、归并排序 归并排序就是利用分治法，把无序的数列拆分成多个子数列，子数列再拆分成多个子数列，直至只子数列只有2个数，然后排序，合并，再排序，在合并。。。直到只剩一个有序的数列。 归并排序算法的核心就是：两个各自有序的数列合并成一个完全有序的数列。这个过程可以说很简单，就是从两个数列开头选出最小的数，放入第三个数列中，然后较小的数的指标后移，继续重复操作。直到其中一个数列全部被放入队列中，此时另一个队列剩下的全部数放入第三个数列。 归并排序的时间复杂度是O(nlgn) 如图所示： 三、Java代码实现 public class MergeSort { public static void main(String[] args) { int a[] = {5,3,2,8,7,6,10,20,30,11,22,33,44,100,60,200}; mergeSort(a, 0, a.length - 1); for (int i : a) { System.out.println(i); } } //递归拆分数列 public static void mergeSort(int[] a, int low, int high)

一、题目 　　1、审题 　　 　　2、分析 　　　　给出一个链表，采用插入排序的方式将节点进行排序。 二、解答 　　1、思路： 　　　　方法一、 　　　　　　①、将第一个节点结点作为新的有序链表的开始。指针 node 指向 head， next 指向 head 的下一个元素。 　　　　　　②、将 next 值依次与 node 所指链表节点进行比较，并插入合适位置。 　　　　　　③、next 依次向后移动，直到所有节点全部插入 node 所指链表，即 next 为 空。 public ListNode insertionSortList(ListNode head) { if(head == null) return head; ListNode node = head; ListNode next = head.next; node.next = null; while(next != null) { ListNode pre = node; ListNode cur = node.next; // next 值比头节点还小 if(pre.val >= next.val) { ListNode tmp = next.next; next.next = pre; node = next; next = tmp; } // next 值比头结点大，找到合适位置插入 else {

题目： Sort a linked list using insertion sort. Hide Tags Linked List Sort 链接： https://leetcode.com/problems/insertion-sort-list/ 6/12/2017 46ms, 17% 从head开始遍历，碰到相同或者大的就插入，更新next指针 注意 1. 需要用sortedLength来区分已经排好序的部分，或许不用？ 2. 设一个dummy node这样prev部分比较好解决 3. 排好序的部分最后一个元素next = null，这样才能在插入之后不形成环 4. 第27行判断是否刚加入的node是排序部分最大的，是的话将其next = null 5. 外循环时每次先保存next，不然内循环会被覆盖。第14行 1 public class Solution { 2 public ListNode insertionSortList(ListNode head) { 3 if (head == null || head.next == null) { 4 return head; 5 } 6 int sortedLength = 1; 7 ListNode cur = head.next; 8 ListNode next; 9 ListNode dummy = new

插入排序（Insertion Sort） 是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 插入排序 在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。 一般来说， 插入排序 都采用in-place在数组上实现。具体算法描述如下： 从第一个元素开始，该元素可以认为已经被排序 取出下一个元素，在已经排序的元素序列中从后向前扫描 如果该元素（已排序）大于新元素，将该元素移到下一位置 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 将新元素插入到该位置后 重复步骤2~5 如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。该算法可以认为是 插入排序 的一个变种，称为二分查找插入排序。 从数据第二个元素开始遍历 0 1 2 3 4 5 20 40 30 10 60 50 20 40 30 10 60 50 20 30 40 10 60 50 10 20 30 40 60 50 10 20 30 40 50 60 i=1; temp=a[1]=40; j=i-1=0; a[0]>40，若前面的元素比当前元素大。 i=2; temp=a[2]=30, j=i-1=1;a[1]

Collections的sort方法可以对List类型的集合进行排序，具体如下： import java.util.*; public class _2 { //使用Collections进行排序 public static void main(String[] args) { HashSet<Integer> set=new HashSet<>();//Set集合 无序 不可重复 set.add(1); set.add(13); set.add(34); set.add(24); set.add(23); set.add(21); set.add(30); //给set进行排序： 使用Collections的sort方法 List<Integer> list=new ArrayList<>(set); //使用set集合构造list //按照自然顺序： Collections.sort(list); //Collections集合只对list类型的集合进行排序 无返回值 Integer[] array=new Integer[list.size()]; //包装类的数组 array= list.toArray(array); //将list转化成array，包装类型 for (int i = 0; i <array.length ; i++) { System.out

Problem Statement Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue. Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively. Note: You are not suppose to use the library's sort function for this problem. Example: Input: [2,0,2,1,1,0] Output: [0,0,1,1,2,2] Follow up: A rather straight forward solution is a two-pass algorithm using counting sort. First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array

目的 基于快速排序对数组进行排序，数组元素可以是结构体。 前提 qsort属于内置函数，需要包含头文件 stdlib.h 函数原型 void qsort( void *ptr, size_t count, size_t size,int (*comp)(const void *, const void *) ); /** void *ptr:空指针, 指向需要排序的数组 size_t count:数组元素个数,size_t在32位机器上unsigned int（4byte），64位机器上unsigned long（8byte） size:数组元素的字节数大小，通常用sizeof（）来计算，平台不同，同一类型的变量占据的字节数可能不用，增强可移植性 int (*comp)(const void *, const void *) : 函数指针，将函数名作为参数，该函数的形参的类型均为const void *,函数外表是一样的，内容却有所不同，返回值类型相同 **/ 用户自定义函数 指明具体的比较对象 int cmp(const void *a, const void *b); // 自定义函数内容，若果a值大于b值，返回1， { /** 在函数内部将const void* 转换成实际的类型； **/ //默认升序写法 if ( *(MyType*)a < *(MyType*)b )

算法描述 归并操作的过程如下： 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 设定两个指针，最初位置分别为两个已经排序序列的起始位置 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置 重复步骤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

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

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