问题:对链表进行排序,要求时间复杂度为NlogN。归并排序。
 inline ListNode* getMidle(ListNode *head){
	if(NULL == head || NULL == head->next)
		return head;
	ListNode *pslow = head;
	ListNode *pfast = head;
	while (pfast->next...
                            
                            
                                分类:
其他好文   时间:
2014-06-10 17:35:56   
                                阅读次数:
282
                             
                    
                        
                            
                            
                                Sort a linked list inO(nlogn) time using 
constant space complexity.单向链表排序O(nlogn),Mergesort可以实现。 1 /** 2 * Definition for 
singly-linked list. 3 * st.....
                            
                            
                                分类:
其他好文   时间:
2014-06-10 00:44:11   
                                阅读次数:
329
                             
                    
                        
                            
                            
                                众所周知,Std::sort()是一个非常快速的排序算法,它基于快排,但又有所修改。一般来说用它就挺快的了,代码一行,时间复杂度O(nlogn)(难道不是大叫一声“老子要排序!!”就排好了么。。。)。我们也知道,不基于比较的排序可以达到O(n),比如说基数排序。什么,它是O(n 
* log(10.....
                            
                            
                                分类:
其他好文   时间:
2014-06-10 00:04:07   
                                阅读次数:
326
                             
                    
                        
                            
                            
                                Sort a linked list in O(n log n) time using 
constant space 
complexity.一谈到时间复杂度O(nlogn),立即联想到以下3种排序方法:1.归并排序(基于分治):时间复杂度O(nlogn),归并排序的最好、平均、最坏时间复杂度没有差别...
                            
                            
                                分类:
其他好文   时间:
2014-06-09 20:37:31   
                                阅读次数:
244
                             
                    
                        
                            
                            
                                Sort a linked list inO(nlogn) time using 
constant space complexity./** * Definition for singly-linked list. * struct 
ListNode { * int val; * L...
                            
                            
                                分类:
其他好文   时间:
2014-06-06 20:01:30   
                                阅读次数:
333
                             
                    
                        
                            
                            
                                POJ 1401 && ZOJ 2202 Factorial 阶乘N!的末尾零的个数
题目地址: 
POJ 1401 
ZOJ 2202
题意: 
求N!后面有几个0。
分析: 
组合数学类型的题目。 
正常的话可能会去分解1~N数里面有几个5和2,但是这样的复杂度为O(nlogn)。 
其实有更巧妙的办法,可以把问题分解成子问题。 
可以发现N!末尾的0与1~N中...
                            
                            
                                分类:
其他好文   时间:
2014-06-05 04:43:02   
                                阅读次数:
248
                             
                    
                        
                            
                            
                                思路:我们先写一个函数,求出从1到整数n之间1出现的次数,而后分别将要求输入的两个数(具体说,应该是最大的数,和最小的数减去1)作为参数传入该函数,得到的值相减,即可得到二者之间的的数中1出现的次数。
    最简单的方法,分别求从1到n之间每个数中的1的个数,由于整数n的位数为O(logn),我们要判断一个数有多少个1,需要判断其每一位是否为1,这样一个数就需要判断O(logn)次,而总共有n个数需要求,那么该方法的时间复杂度为O(nlogn)。在九度OJ上用该方法写的代码测试,会超时。
    剑指of...
                            
                            
                                分类:
其他好文   时间:
2014-06-03 01:43:22   
                                阅读次数:
282
                             
                    
                        
                            
                            
                                Sort ListSort a linked list inO(nlogn) time 
using constant space 
complexity.要求时间复杂度为O(nlogn),那么不能用quickSort了(最坏O(n^2)),所以使用mergeSort.通常写排序算法都是基于数组的,这题...
                            
                            
                                分类:
其他好文   时间:
2014-06-02 06:29:51   
                                阅读次数:
192
                             
                    
                        
                            
                            
                                Sort a linked list inO(nlogn) time using 
constant space complexity./** * Definition for singly-linked list. * struct 
ListNode { * int val; * L...
                            
                            
                                分类:
其他好文   时间:
2014-05-30 15:17:18   
                                阅读次数:
312
                             
                    
                        
                            
                            
                                对Big 
Oh的新的认识一个问题,它有很多种算法都能实现。每种算法它的时间、空间复杂度不一样。比如:问题1:	求最大连续子序列和的问题,可以有O(n3)、O(n2)、O(nlogn)和O(n)四种时间复杂度的解法。请看下面的代码:一、O(n3)算法	二、O(n2)算法	三、O(nlogn)算法用分治...
                            
                            
                                分类:
其他好文   时间:
2014-05-26 19:17:41   
                                阅读次数:
234