2012年01月_MichealTX

11月 06月 05月 04月 01月

原创第九章中位数和顺序统计学之“查找第i小的元素（迭代版）平均运行时间为O(n)算法”（练习9.2-3）

这个是相对前一篇文章来说的，这是个迭代版本。递归化为迭代的一个关键点，就是看递归调用时，哪些参数值发生改变，然后针对这个参数设计循环。#include #include #define BUFFER_SIZE 10int RandomizedPartition(int *a,int p,int r){ int i=0; int j=0; int tmp=0; int x

2012-01-17 19:03:08 1301

原创第九章中位数和顺序统计学之“查找第i小的元素（递归版）平均运行时间为O(n)算法”

类似于快速排序的随机化版本，但是这里每次只处理划分的一侧。最坏情况下时间复杂度为O(n^2)，即每次都是按最大区间进行划分。但在平均情况下，任何顺序统计量（特别是中位数）都可以在线性时间内得到，时间复杂度为O(n)。#include #include #define BUFFER_SIZE 10int RandomizedPartition(int *a,int p,in

2012-01-17 15:41:48 1118

原创第九章中位数和顺序统计学之“寻找第2小元素”（练习9.1-1待改进）

在最坏的情况下，利用n+(lgn的上限)-2次比较，即可找到n个元素中的第2小元素。（提示：同时找最小元素）#include #include #define BUFFER_SIZE 10void FirstAndSecond(int *a,int len,int *first,int *second){ int i=0; int j=0; if(a[0]<a[1

2012-01-17 15:09:34 932

原创第九章中位数与顺序统计学之“同时找出最小值和最大值”

在一个数组同时找出最小值和最大值。可以分别找出最小值，比较n-1次；找出最大值，比较n-1次，共比较2n-2次。其实还有更少的比较次数。就是成对的处理元素，先将一对输入元素互相比较，找出最小值和最大值，然后再用最小值与当前的最小值比较得出新的最小值，用最大值和当前最大值比较，得出新的最大值，所以这一对元素共比较了3次。n个元素则只需比较3*（（n/2）的下限）次。当然对于n为偶数和奇数，处理过

2012-01-10 20:59:26 1801

原创第八章线性时间排序之“桶排序BUCKET-SORT”

要对n个数进行排序，就要准备n个桶。先对n个数归一化，就是把它们除以一个较大的数，使之分布在【0,1）之间，然后对每个桶中的数插入排序，最后合并n个桶。时间复杂度为O（n）。#include #include typedef struct _Node { double value; struct _Node *next;}Node;#define BUFFER_SI

2012-01-10 16:39:00 760

原创坏蛋unsigned int型造成的循环陷阱

下面的循环执行几次呢？unsigned int i=10;for(i=10;i>=0;i--){ printf("HELLO GIRL!\n");}11次？O(∩_∩)O~，其实它是个死循环！为虾米？因为i是个unsigned int型，当减小到0时，再减1变成2^32-1，判断条件仍然成立！把判断条件写成i!=0就好了。我好像在C++ Primer上

2012-01-10 11:18:52 1027

原创第八章线性时间排序之“基数排序RADIX-SORT”（练习8.3-1）

利用基数排序对a[17][4]={" ","COW","DOG","SEA","RUG","ROW","MOB","BOX","TAB","BAR","EAR","TAR","DIG","BIG","TEA","NOW","FOX"}进行排序。“基数排序”可以看做给“计数排序”创造条件，一般的小数用基数排序很麻烦，而且效率不如计数排序，但是要是n个长度为b的长整数或者字符串，可以先用r（r

2012-01-10 09:45:18 921

原创第八章线形时间排序之“计数法排序COUNTING-SORT”

这个方法很牛逼，这个排序方法不再像前面那些排序方法一样根据比较来进行。时间复杂度为O(k+n+k+n+n)=O(n)，当k=O（n）时，可以保证时间复杂度为O（n），就可以用计数法来进行排序了。这个方法的一个前提是必须要知道要排序的数组中元素的取值范围。#include #include #define BUFFER_SIZE 10void CountingSort(in

2012-01-09 14:53:30 880

原创第七章快速排序之“区间模糊排序FUZZY-SORT”（待改进。。。）

快速排序可以看成区间大小为1的模糊排序。#include #include #define BUFFER_SIZE 10typedef struct{ int start; int end;}Node; int FuzzyPartition(Node *a,int p,int r){ Node tmp; int i=0; int j=0; int k=0; N

2012-01-07 17:14:03 1159

原创第七章快速排序之“采取“尾递归”和“三数取中”技术的快速排序”（思考题7-4、7-5）

QUICKSORT算法包含两个对其自身的递归调用，即调用PARTITION后，左边的子数组和右边的子数组分别被递归排序。QUICKSORT中的第二次递归调用并不是必须的，可以用迭代控制结构来代替它，这种技术叫做“尾递归”，大多数的编译器也使用了这项技术。最坏的情况下，就是划分不好的时候，递归深度为O(n)，能够二分的话递归深度为O（lgn），但是怎么才能得到好的划分呢？前面在快速排序中用了个随机化

2012-01-06 17:04:52 3715

原创第七章快速排序之“快速排序Hoare版本HOARE-QUICKSORT”（思考题7-1）

这是个历史更早的版本，Hoare是人名，这个版本的Partition（）函数跟现在的不一样。我觉得这个老版本不如现在的版本好理解，大面上看起来可能好理解，但是具体写代码时考虑指针移动，很麻烦。#include #include #define BUFFER_SIZE 10int HoarePartition(int *a,int p,int r){ int tmp=0

2012-01-05 22:05:05 2344

原创第七章快速排序之“快速插入排序”（练习7.4-5）

O(∩_∩)O~，这个名字乍听起来比较黄。其实就是先快速排序进行划分，等划分小到一定规模比如k时，进行插入排序，因为规模小到一定程度，插入排序的效率更高。我在前面还写过一个合并插入排序的算法，思想跟这个相似。总的时间复杂度为O(nk+nlg(n/k))，这个很好证明：先进行二分，划分到规模都为K时停止划分，此时深度为h，则T(n/2^h)=k，则h=lg(n/k)，最底层规模为K的叶节点数

2012-01-05 22:03:27 3280

原创第七章快速排序之“快速排序的随机化版本RANDOM-QUICKSORT”

因为快速排序的最坏情况是O(n^2)，最佳情况是O(nlgn)，采用随机化版本时间复杂度可以达到平均情况O(nlgn)。书上的证明过程让人心静、让人谦卑，its amazing！比起那些让人拍案叫绝的证明过程，用代码实现反而不是最重要的了。#include #include #define BUFFER_SIZE 10int Partition(int *a,int p,

2012-01-05 17:13:48 1619

原创第七章快速排序之“快速排序QUICKSORT”

#include #include #define BUFFER_SIZE 10int Partition(int *a,int p,int r){ int x=0; int i=0; int j=0; int tmp=0; x=a[r]; i=p-1; for(j=p;j<r;j++) {//将数组划分为四个区，(a[p]~a[i])x，(a[j]~a[r-1])

2012-01-05 09:47:42 704

原创第六章堆排序之“Young氏矩阵（Young tableau）”（思考题6-3）

这个程序是利用Young氏矩阵为n*n的数组排序。其中涉及到：插入法建立Young氏矩阵，然后再调用”去掉返回堆顶元素”的函数得到从小到大的排列。总的时间复杂度为O（n^3）。其中向Young氏矩阵“插入一个元素”的时间复杂度为O（m+n），m为Young氏矩阵的行数，n为Young氏矩阵的列数，建立Young氏矩阵要插入n*n个元素则为O（（n^2）*2n）=O（n^3）。“去掉返回

2012-01-04 17:29:38 1531

原创第六章堆排序之“对d叉堆的分析”（思考题6-2）

d叉堆在数组中如何表示：（1）若某个子节点索引为i，则它的父节点的索引为（i-2）/d+1，向下取整。（2）若某个父节点索引为i，则它的第j个子节点的索引为d*(i-1)+j+1。下面的程序是用插入法建立d叉最大堆，并显示了一次去掉和返回堆顶元素后剩余堆的情况。其中 “调整d叉堆” 的时间复杂度都为O(dlogd(n))，d为底哦。（纵向进行logd(n)（即深度）次，每次再横向比

2012-01-04 11:20:47 2816

原创第六章堆排序之“插入法建堆”（思考题6-1）

建堆既可以用堆调整方法将原数组调整为一个堆，也可以借助往堆中插入元素的方法从无到有的建立一个堆。两种方法比较：（1）借助堆调整建堆的时间复杂度为O(n)。借助插入法建堆的时间复杂度为O(nlgn) ，书上第二问要求证明这个复杂度，但是我认为插入法的复杂度也是O（n），因为它和堆调整的区别在于针对每个节点i，堆调整是自上向下进行调整，插入法是自下向上进行调整。（2）对于同样的输入两个方法

2012-01-04 09:50:39 3683

原创第六章堆排序之“用最小堆将k个已排序链表合并为一个排序链表”（练习6.5-8）

问题：请给出一个时间为O(nlgk)，用来将k个已排序链表合并为一个排序链表的算法。此处的n为所有输入链表中元素的总数。（提示：用一个最小堆来做k路合并）编程思路：假设k个链表都是非降序排列的。（1）取k个元素建立最小堆，这k个元素分别是k个链表的第一个元素。建堆的时间复杂度O(k)。（2）堆顶元素就是k个链表中最小的那个元素，取出它。时间复杂度O(1)。（3）若堆顶元素所在链

2012-01-04 08:33:08 3564 3

原创 “作为函数参数的二维数组”即“怎么给函数传二维数组的指针”

刚才在百度知道看到了这个问题，回答了下，这个问题很好，总结一下。声明一个二维数组int matrix[100][100];当把二维数组作为参数传递的时候很多人可能一上来就这样写intfun(int **matrix)，这样写是没有区分“指向整型指针的指针”与“指向整型数组的指针”的区别。这样传参是错的，因为matrix是个二维数组，matrix[100][100]是个二维

2012-01-03 18:54:13 10780

原创第六章堆排序之“删除最大堆中的指定元素HEAP-DELETE”（练习6.5-7）

题目：HEAP-DELETE(A,i)操作将节点i中的项从堆中删去。对含n个元素的最大堆，请给出时间为O（lgn）的HEAP-DELETE的实现。编程思路:我们可以用堆中最后一个元素a[heapSize]放到节点i 位置，然后将heapSize减一。然后就涉及到堆调整以保持堆的性质。调整的依据就是这最后一个元素a[heapSize]跟原来i节点的元素a[i]的相对大小，分三种情况：

2012-01-03 14:32:57 6164

原创第六章堆排序之“优先级队列实现先进先出队列和栈”（练习6.5-6）

这个不写代码了。思路如下：首先要先明确优先级是谁？优先级队列嘛，当然最重要的是要先知道“优先级”是谁，才能按它排序。这里的优先级就是进出队的次序。（1）优先级队列实现先进先出队列先进队的优先级更高，赋予每个进队的元素一个优先级值，但优先级的值我们令0最大，1次之，2再次之，···，然后按着这个优先级值建立最大优先级队列，每次用HeapExtractMax（）取堆顶元素，这个肯定

2012-01-03 11:52:59 3741

原创第六章堆排序之“最小优先级队列”（练习6.5-3）

用最小堆实现最小优先级队列：//返回堆中关键字最小的元素HeapMinimum()//去掉并返回堆中关键字最小的元素HeapExtractMin()//将堆中元素x的关键字减小到k，k要小于x原来的关键字值HeapDecreaseKey()//将元素x插入到堆中MInHeapInsert()#include #include #include

2012-01-03 10:39:43 1034

原创第六章堆排序之“最大优先级队列”

用最大堆实现最大优先级队列：//返回堆的最大值int HeapMaximum(int *a)//去掉并返回堆中具有最大关键字的元素int HeapExtractMax(int *a,int *heapSize)//将元素x的关键字值增加到k，这里k不能小于x的原关键字值void HeapIncreaseKey(int *a,int i,int k)//将元素x插入到堆中

2012-01-02 22:01:38 874

原创第六章堆排序之“堆排序HEAPSORT”

（1）先用BuildMaxHeap（）建立最大堆（2）交换a[1]和a[heapSize]，把最大的换到最后（3）堆大小heapSize减1（4）因为将最后一个元素换到堆顶可能会破坏堆的性质，所以调用MaxHeapIfy（）将新的heapSize大小的堆调整最大堆（5）将（2）~（4）重复heapSize-1次，这里的heapSize是最初的那个heapSize。因为一共有heap

2012-01-02 19:45:59 868

原创第六章堆排序之“建堆BUILD-MAX-HEAP”（迭代版）

自下向上对每一个结点或者只对每个非叶结点使用“保持堆的性质”即“堆调整”MAX-HEAPIFY#include #include #include #define BUFFER_SIZE 10void MaxHeapIfy(int *a,int i,int heapSize){ int left=i; int right=i; int tmp; int largest

2012-01-02 16:00:38 2705

原创第六章堆排序之“建堆BUILD-MAX-HEAP”（递归版）

自下向上对每一个结点或者只对每个非叶结点使用“保持堆的性质”即“堆调整”MAX-HEAPIFY#include #include #include #define BUFFER_SIZE 10void MaxHeapIfy(int *a,int i,int heapSize){ int left=i<<1; int right=(i<<1)+1; int tmp

2012-01-02 15:58:12 1461

原创第六章堆排序之“保持堆的性质MAX-HEAPIFY”（迭代版，练习6.2-5）

MAX-HEAPIFY用于最大堆的堆调整，i的左右子堆已经满足最大堆要求。数组的第0个位置未用，这样计算左右子女的索引简单点。递归的话对某些编译器来说可能会很低效，所以改为循环迭代。void MaxHeapIfy(int *a,int i,int heapSize){ int left=i; int right=i; int tmp; int largest=i;

2012-01-02 15:23:46 1288

原创第六章堆排序之“保持堆的性质MAX-HEAPIFY”（递归版）

MAX-HEAPIFY用于最大堆的堆调整，i的左右子堆已经满足最大堆要求。数组的第0个位置未用，这样计算左右子女的索引简单点。void MaxHeapIfy(int *a,int i,int heapSize){ int left=i<<1;//左子索引 int right=i<<1+1;//（移位运算比算术运算优先级低，切记！）右子索引 int tmp; int large

2012-01-02 14:57:14 2440