Dutor » 排序 http://www.dutor.net 熟读而精思，循序而渐进，厚积而薄发。 Tue, 17 Jan 2012 14:44:19 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 迭代版快速排序 http://www.dutor.net/index.php/2011/04/recursive-iterative-quick-sort/ http://www.dutor.net/index.php/2011/04/recursive-iterative-quick-sort/#comments Fri, 29 Apr 2011 08:43:54 +0000 dutor http://www.dutor.net/?p=2575 　　递归是一种使用相同的方法，通过解决问题的子集以达到解决整个问题的方法，是一种使用有限代码解决“无限”计算的方法。在C/C++语言中递归表现在函数对自身的直接/间接的调用上，在实现上，递归依赖于语言的运行时调用堆栈，使用堆栈来保存每一次递归调用返回时所需要的条件。递归通常具有简洁的编码和清晰的思路，但这种简洁是有代价的。一方面，是函数调用的负担；另一方面，是堆栈占用的负担（堆栈的大小是有限的）。
　　避免这种负担的方法就是将递归转化为迭代。迭代的思想主要在于，在同一栈帧中不断使用现有数据计算出新的数据，然后使用新的数据来替换原有数据。递归于迭代可以相互转化。将递归转化为迭代需要做两方面的工作：显式地维护一个堆栈，在递归算法中堆栈的维护由编译器隐式地完成；使用迭代控制结构，完成出栈、入栈和相关的计算。
　　以快速排序为例，递归版本的快排通常是这个样子的，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

int
partition(int *a, int n) //~ seperate a[], using a[0] as pivot
{
    int l = 0, r = n;
    int pivot = a[l];
    while(l < r)
    {
        while( l < r && a[--r] > pivot) ;
        a[l] = a[r];
        while(l < r && a[++l] < pivot) ;
        a[r] = a[l];
    }
    a[l] = pivot;
    return l; //~ return the final index of pivot
}
void
qsort_recur(int *a, int n)
{
    if(n <= 1)
        return;
    int m = partition(a, n);
    if(m <= n / 2)
    {
        qsort_recur(a, m);
        qsort_recur(a + m + 1, n - m - 1);
    }
    else
    {
        qsort_recur(a + m + 1, n - m - 1);
        qsort_recur(a, m);
    }
}

　　为了将递归排序转化为迭代排序，首先要做的就是考察需要将哪些变量保存到堆栈，这些变量何时入栈何时出栈，需要做什么计算，迭代的终止条件是什么。
　　根据快速排序的核心思想（分而治之），所需要的做的“计算”就是将“区间”按照某个支点（比如区间第一个元素）分为两个子区间，然后再分别对两个子区间进行相同的操作。可见，我们需要在栈中维护的信息就是“区间”，因为在对一个区间进行“计算”时，其他区间信息需要保存。这样才能在处理完当前区间的工作之后继续处理其他区间。迭代的终止条件是什么？所有的区间都处理完了。
　　下面是迭代版本的快速排序，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

void
qsort_iter(int *a, int n) //~ qsort of 'iterative version
{
    if(n <= 1)
        return ;
    stack<int> ranges; //~ stack of ranges to be sorted
    int l = 0;
    int r = n;
    ranges.push(l); //~ initial range
    ranges.push(r);
    while(!ranges.empty())
    {
        int tr = r = ranges.top(); ranges.pop();
        int tl = l = ranges.top(); ranges.pop();
        if(r - l <= 1) //~ range sorted
            continue;
        //~ partition begins
        int pivot = a[tl];
        while(tr > tl)
        {
            while(tr > tl && a[--tr] > pivot);
            a[tl] = a[tr];
            while(tr > tl && a[++tl] < pivot);
            a[tr] = a[tl];
        }
        a[tl] = pivot;
        //~ partition ends
 
        //~ ranges pushed, with order counting for little
        ranges.push(l); ranges.push(tl);
        ranges.push(tl+1); ranges.push(r);
    }
}

　　代码中，堆栈使用STL的stack适配器，它默认使用deque做底层存储，因此，我们的栈使用的是堆内存，因此你就不必担心stack overflow了。你可能注意到了，这个版本中也使用了不少的函数调用，但都是可以通过自己建立堆栈来消除的。再者，这里只是提供一种思路，相对于迭代的带来的所谓性能“提升”，其带来的复杂性也是不可忽视的。

参考：Recursion

]]> http://www.dutor.net/index.php/2011/04/recursive-iterative-quick-sort/feed/ 21 几种排序算法 http://www.dutor.net/index.php/2010/10/sorts-of-sort-methods/ http://www.dutor.net/index.php/2010/10/sorts-of-sort-methods/#comments Mon, 18 Oct 2010 01:28:11 +0000 dutor http://www.dutor.net/?p=2484
  • 没有实现计数、基数排序等线性复杂度的算法；
  • 各算法只是对算法思想的一次简单模拟，没有过多的优化；
  • 各排序主程序接口参数均为整型数组及元素个数；
  • 程序计时使用了glibc的gettimeofday()，因此。。。；
  • 归并排序中，每次调用都申请和释放堆空间，因此比较耗时。可以采用原地归并、使用全局/静态的方法加以优化；
  • 快速排序中，对待排子序列的长度进行的了判断，对短序列进行优先排序可以减小函数的递归深度（而不是次数）；
  • 希尔排序中，为了简洁，步长因子统一取做2.2（11/5）。
    • ]]>     　　简单实现了常见的几种内部排序算法，包括冒泡（Bubble），插入（Insert），快速排序（Quick Sort），堆排序（Heap Sort），归并（Merge），希尔排序（Shell Sort），并对这些算法的耗时在伪随机数上进行了简单的测试。
    　　说明：

    • 没有实现计数、基数排序等线性复杂度的算法；
    • 各算法只是对算法思想的一次简单模拟，没有过多的优化；
    • 各排序主程序接口参数均为整型数组及元素个数；
    • 程序计时使用了glibc的gettimeofday()，因此。。。；
    • 归并排序中，每次调用都申请和释放堆空间，因此比较耗时。可以采用原地归并、使用全局/静态的方法加以优化；
    • 快速排序中，对待排子序列的长度进行的了判断，对短序列进行优先排序可以减小函数的递归深度（而不是次数）；
    • 希尔排序中，为了简洁，步长因子统一取做2.2（11/5）。

    　　下面是主程序，

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

    #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>
#include <sys/time.h> //~ gettimeofday()
 
typedef void (*SORTFUN)(int *a, int n);
 
#define ASIZE 24*1024 //~ array size
#define SCOUNT 6 //~ number of sort method
enum {BUBBLE, INSERT, QSORT, HEAP, MERGE, SHELL};
char *fname[SCOUNT] =
    {
        "Bubble", "Insert", "Qsort",
        "Heap", "Merge", "Shell"
    };
 
SORTFUN fpointer[SCOUNT]; //~ pointers to sort functions
 
int array[SCOUNT][ASIZE]; //~ array(s) under sort.
 
long timeused[SCOUNT]; //~ time taken by every sort function
 
/*******************Generate random data*********************/
void
gen_data(void)
{
    srand(time(NULL)); //~ rand seeding
    for(int i = 0; i < ASIZE; ++i) //~ generate random array[0]
    {
        array[0][i] = rand() % ASIZE;
    }
    for(int i = 1; i < SCOUNT; ++i) //~ copy array[0] to the rest
    {
        for(int j = 0; j < ASIZE; ++j)
        {
            array[i][j] = array[i-1][j];
        }
    }
    //NOTE: using TWO loops to maximize caching
}
 
/***********************Time the time**********************/
long
timer(void) //~ Current Time by millisecond
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
}
int
main(int AC, char **AV) //~ Both of AC and AV are fascinating ^_^
{
    gen_data();
 
    //NOTE: to disable a function, just comment it out below.
    fpointer[BUBBLE] = bubble_sort;
    fpointer[INSERT] = insert_sort;
    fpointer[QSORT] = quick_sort;
    fpointer[HEAP] = heap_sort;
    fpointer[MERGE] = merge_sort;
    fpointer[SHELL] = shell_sort;
 
    for(int i = 0; i < SCOUNT; ++i)
    {
        long starttime = timer();
        SORTFUN fp = fpointer[i];
        if(fp)
            fp(array[i], ASIZE);
        timeused[i] = timer() - starttime;
    }
 
    //~ Header
    printf("%%Method\t\t%%Time\t\t%%Elements\n");
    printf("-----------------------------------------\n");
    //~ result
    for(int i = 0; i < SCOUNT; ++i)
    {
        printf("%s\t\t%ld\t\t%d\n", fname[i], timeused[i], ASIZE);
    }
    printf("\n");
    return 0;
}

    　　各种排序，

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

    /************************Bubble Sort**************************/
void
bubble_sort(int *a, int n)
{
    for(int i = n - 1; i > 0; --i)
    {
        int issorted = 0; //~ flag, for some optimition
        for(int j = 0; j < i; ++j)
        {
            if(a[j] > a[j+1])
            {
                issorted = 1;
                int tmp = a[j];
                a[j] = a[j+1];
                a[j+1] = tmp;
            }
        }
        if(!issorted)
            break;
    }
}
 
/************************Insert Sort**************************/
void
insert_sort(int *a, int n)
{
    for(int i = 0; i < n - 1; ++i)
    {
        int j = i + 1;
        int tmp = a[j];
        while(j > 0 && tmp < a[j-1])
        {
            a[j] = a[j-1];
            --j;
        }
        a[j] = tmp;
    }
}
 
/************************Quick Sort**************************/
int
partition(int *a, int n) //~ seperate a[], using a[0] as pivot
{
    int l = 0, r = n;
    int pivot = a[l];
    while(l < r)
    {
        while( l < r && a[--r] > pivot) ;
        a[l] = a[r];
        while(l < r && a[++l] < pivot) ;
        a[r] = a[l];
    }
    a[l] = pivot;
    return l; //~ return the final index of pivot
}
void
quick_sort(int *a, int n)
{
    if(n <= 1)
        return;
    int m = partition(a, n);
    if(m <= n / 2)
    {
        quick_sort(a, m);
        quick_sort(a + m + 1, n - m - 1);
    }
    else
    {
        quick_sort(a + m + 1, n - m - 1);
        quick_sort(a, m);
    }
}
 
/************************Quik Sort**************************/
void
sift(int *a, int i, int n) //~ sift to rebuild the heap rooted by a[i]
{
    int tmp = a[i];
    while(2*i + 1 < n)
    {
        int j = 2*i + 1;
        if(j + 1 < n && a[j+1] > a[j])
            ++j;
        if(a[j] > tmp)
        {
            a[i] = a[j];
            i = j;
        }
        else
            break;
    }
    a[i] = tmp;
}
void
heap_sort(int *a, int n)
{
    for(int i = (n-2) / 2; i >= 0; --i) //~ build heap
    {
        sift(a, i, n);
    }
    for(int i = 1; i < n; ++i) //~ rebuild the decreasing heap over and over
    {
        int tmp = a[0];
        a[0] = a[n-i];
        a[n-i] = tmp;
        sift(a, 0, n - i);
    }
}
 
/***********************Merge Sort**********************/
void
merge_sort(int *a, int n)
{
    if(n == 1)
        return;
    int *ext = (int*)malloc(sizeof(int) * n / 2);
    merge_sort(a, n / 2);
    merge_sort(a + n / 2, (n + 1) / 2);
 
    memcpy(ext, a, n / 2 * sizeof(int));
    int i = 0, j = n / 2, k = 0;
    while(i < n / 2 && j < n)
    {
        if(a[j] < ext[i])
            a[k++] = a[j++];
        else
            a[k++] = ext[i++];
    }
    while(i < n / 2)
        a[k++] = ext[i++];
    while(j < n)
        a[k++] = a[j++];
    free(ext);
}
 
/***********************Shell Sort**********************/
void
shell_sort(int * a, int n)
{
    int step = n / 2;
    while(step > 0)
    {
        for(int i = step; i < n; ++i)
        {
            int tmp = *(a + i);
            int j = i - step;
            while(j >= 0 && tmp < *(a + j))
            {
                *(a + j + step) = *(a + j);
                j -= step;
            }
            *(a + j + step) = tmp;
        }
        if(step == 2)
            step = 1;
        else
            step = step * 11 / 5; //~ integer is better
    }
}

    　　对测试结果做一下简要的总结：

    • 快排不是盖的，在我有限的随机测试中，它始终是最快的；
    • 这里的归并排序由于堆内存的频繁申请与释放，相比同量级的其它算法，是最慢的；
    • 希尔排序相当给力，尽管步长因子选择很粗糙，但在我的测试中，还是超过了堆排序。这从侧面证明了，在接近有序时插入排序是很快的。事实上，插入排序，由于其简洁性，常常做为高级排序算法的末级算法（局部算法）。
    ]]>     http://www.dutor.net/index.php/2010/10/sorts-of-sort-methods/feed/ 0     qsort http://www.dutor.net/index.php/2010/07/qsort/ http://www.dutor.net/index.php/2010/07/qsort/#comments Tue, 06 Jul 2010 12:57:10 +0000 dutor http://www.dutor.net/?p=2347
  • qsort中第一个参数是待排序数组的开始地址，既然是数组，各元素就是同类型、同大小的对象，且数组是“一维数组”（即地址是连续的）；
  • qsort用以区分对象的依据是第二和第三个参数，分别表示对象个数和每个对象的大小（字节）；
  • qsort并不知道每个对象的类型和结构，排序准则由用户在第四个参数（比较函数）中指出，qsort按该比较函数准则的“升序”对数组进行排序；
  • 标准C不支持运算符重载，各对象的交换（因为这是qsort）靠的是逐字节的拷贝（memcpy?）。
    • 　　在上面的两片代码中，待排序的对象一个是字符型指针，一个是char (*)[10]型数组。然后，就没有然后了。]]>     　　Felix那里看到的，关于用qsort对指针式字符串数组和二维型字符串数组的排序的，觉得值得贴出来。注意下下面两片代码的区别。

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

    const int N = 4;
char *str[N] = { "xyz", "cdef", "abcd", "caaa"};
 
int cmp(const void *l, const void *r)
{
    const char *a = *((char**)l);
    const char *b = *((char**)r);
    return strcmp(a, b);
}
int
main(int argc, char **argv)
{
    qsort( (void*)str, N, sizeof(int*), cmp );
    for(int i = 0; i < N; ++i)
    {
        printf("%s\n", str[i]);
    }
    return 0;
}
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

    const int N = 4;
char str[N][10] = { "xyz", "cdef", "abcd", "caaa"};
 
int
main(int argc, char **argv)
{
    qsort( (void*)str, N,
            sizeof(char)*10,
            ( int(*)(const void*, const void*) )strcmp );
    for(int i = 0; i < N; ++i)
    {
        printf("%s\n", str[i]);
    }
    return 0;
}

    　　对qsort需要注意几点：

    • qsort中第一个参数是待排序数组的开始地址，既然是数组，各元素就是同类型、同大小的对象，且数组是“一维数组”（即地址是连续的）；
    • qsort用以区分对象的依据是第二和第三个参数，分别表示对象个数和每个对象的大小（字节）；
    • qsort并不知道每个对象的类型和结构，排序准则由用户在第四个参数（比较函数）中指出，qsort按该比较函数准则的“升序”对数组进行排序；
    • 标准C不支持运算符重载，各对象的交换（因为这是qsort）靠的是逐字节的拷贝（memcpy?）。

    　　在上面的两片代码中，待排序的对象一个是字符型指针，一个是char (*)[10]型数组。然后，就没有然后了。
    　　
    　　然后，上面代码，gcc编译出错，g++却可以。
    　　const int N = 4; char *str[N];可以。
    　　const int N = 4; char *str[N] = {“a”,”b”,”c”,”d”};却不可，何解？

    ]]>     http://www.dutor.net/index.php/2010/07/qsort/feed/ 2     Shell 排序 http://www.dutor.net/index.php/2009/11/shell-sort/ http://www.dutor.net/index.php/2009/11/shell-sort/#comments Sun, 15 Nov 2009 23:10:31 +0000 dutor http://www.dutor.net/?p=1658 0)写成了while(size > 0)，纯属自作自受。]]> 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

    void
shell_sort(int * a, int n)
{
    int step = n / 2;
    while(step > 0)
    {
        for(int i = step; i < n; ++i)
        {
            int tmp = *(a + i);
            int j = i - step;
            while(j >= 0 && tmp < *(a + j))
            {
                *(a + j + step) = *(a + j);
                j -= step;
            }
            *(a + j + step) = tmp;
        }
        if(step == 2)
            step = 1;
        else
            step = (int)step / 2.2;
    }
}

    　　这个排序算法为什么被命名为Shell排序，我一直幻想着它可能最早被用以Shell脚本吧，Just Now我才知道，发明人叫做Donald Shell，居然有人叫自己壳？
    　　以前从来没有写过这个排序，事实证明，没写过基本等于没听说过、没学过。
    　　21行的小程序花了我将近一个小时来调试，对一个大小为9的逆序用gdb跟踪了程序整个的执行过程，发现两处错误，迭代变量j的类型习惯性地写成了size_t，导致死循环，以后凡是这种i,j,k，一律int。还有就是把最外层的while(step > 0)写成了while(size > 0)，纯属自作自受。

    ]]>     http://www.dutor.net/index.php/2009/11/shell-sort/feed/ 2     最小堆 http://www.dutor.net/index.php/2009/10/minimum-heap/ http://www.dutor.net/index.php/2009/10/minimum-heap/#comments Sun, 04 Oct 2009 13:48:23 +0000 dutor http://www.dutor.net/?p=1396 　　一个最小堆的C++模板。什么东西都想封装成类，做成模板，即使它仅仅就是一个普通的函数，尤其是用到一些全局的对象时，觉得封装成类看起来更紧凑一点，使用起来也更方便更顺手一些。这个最小堆模板实现了以下几个小特性：
    　　容量不足时，能够动态地调整大小；
    　　可以用一个数组来初始化，并建立最小堆；
    　　没有复制构造，^*^.

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

    template <class T>
class Heap
{
    public:
        //~ 构造容量n的堆
        Heap(size_t n = 64);
        //~ 以数组构造
        Heap(const T* beg, const T* end);
        ~Heap(){delete [] pHeap;}
        //~ 添加元素
        void push(const T& item);
        //~ 返回并删除堆顶元素
        T pop();
        //~ 返回堆顶元素的引用
        T& top()const;//! 不允许修改！
        size_t size() const;//~ 当前元素个数
        size_t capacity() const;//~ 当前容量
    private:
        void resize();//~ 重新调整堆容量
        void adjust(int i);//~ 调整以i为根的子树为最小堆
        T * pHeap;
        size_t _size;
        size_t _capacity;
};
 
template <class T>
Heap<T>::Heap(size_t n): pHeap(new T[n])
{
    _size = 0;
    _capacity = n;
}
template <class T>
Heap<T>::Heap(const T* beg,const T* end)
{
    _capacity = _size = end - beg;
    pHeap = new T[_size];
    for(int i = 0; i < _size; ++i)
    {
        pHeap[i] = *beg++;
    }
    int i = _size - 1;
    //~ 调用adjust(int)构造最小堆
    for( ; i >= 0; --i)
        adjust(i);
}
template <class T>
void Heap<T>::push(const T& item)
{
    //~ 容量不足时重新分配空间
    if(_size == _capacity)
        resize();
    _size++;
    int i = _size - 1;
    //~ 通过上溯寻找合适的插入位置
    while(i && pHeap[(i-1)/2] > item)
    {
        pHeap[i] = pHeap[(i-1)/2];
        i = (i-1) / 2;
    }
    pHeap[i] = item;
}
template <class T>
T Heap<T>::pop()
{
    //~ assert(_size);
    if(_size <= 0)exit(1);
    T rt = pHeap[0];
    //~ 先将堆尾元素置顶，然后重建
    pHeap[0] = pHeap[--_size];
    if(_size)
        adjust(0);
    return rt;
}
template <class T>
T& Heap<T>::top()const
{
    // assert(_size);
    if(_size <= 0)exit(1);
    return pHeap[0];
}
template <class T>
size_t Heap<T>::size()const
{
    return _size;
}
template <class T>
size_t Heap<T>::capacity()const
{
    return _capacity;
}
template <class T>
void Heap<T>::resize()
{
    T * org = pHeap;
    //~ 调整容量
    _capacity = 2*_capacity + 1;
    pHeap = new T[_capacity];
    //~ 复制堆
    for(int i = 0; i < _size; ++i)
    {
        pHeap[i] = org[i];
    }
    delete [] org;
}
template <class T>
void Heap<T>::adjust(int i)
{
    //~ 重建以i为根的最小堆，假定其左右子树已是最小堆
    size_t minpos;
    while(2 * i + 1 < _size)
    {
        minpos = i;
        if(2 * i + 2 < _size && pHeap[2*i+2] < pHeap[i])
            minpos = 2 * i + 2;
        if(pHeap[2*i+1] < pHeap[minpos])
            minpos = 2 * i + 1;
        if(minpos == i)
            break;
        swap(pHeap[i], pHeap[minpos]);
        i = minpos;
    }
}
    ]]>     http://www.dutor.net/index.php/2009/10/minimum-heap/feed/ 1     二分查找 http://www.dutor.net/index.php/2009/08/binary-search/ http://www.dutor.net/index.php/2009/08/binary-search/#comments Mon, 24 Aug 2009 11:10:02 +0000 dutor http://www.dutor.net/?p=1174 template int BSearch(T *a, size_t n, T v) { assert(a != NULL && n > 0); //! a == NULL || n <= 0 就坏了:-( size_t l = 0, r = n -1, m = l + (r - l) / 2; //! 勿用m=(l+r)/2; while(l <= r) { if(a[m] == v) return (int)m; else if(a[m] < v) l = m + 1; else r = m - 1; } return -1; } ]]> 没啥好说的，只是要注意防止m = (r + l) / 2;时m会发生上溢。

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

    template <class T>
int BSearch(T *a, size_t n, T v)
{
    assert(a != NULL && n > 0); //! a == NULL || n <= 0 就坏了:-(
    size_t l = 0,
           r = n -1,
           m = l + (r - l) / 2; //! 勿用m=(l+r)/2;
    while(l <= r)
    {
        if(a[m] == v) 
            return (int)m;
        else if(a[m] < v)
            l = m + 1;
        else
            r = m - 1;
    }
    return -1;
}
    ]]>     http://www.dutor.net/index.php/2009/08/binary-search/feed/ 4     原地归并算法一例 http://www.dutor.net/index.php/2009/08/merge-sort-2/ http://www.dutor.net/index.php/2009/08/merge-sort-2/#comments Sun, 23 Aug 2009 13:36:38 +0000 dutor http://www.dutor.net/?p=1161 //~ 原地归并 while(l < r && r < size) //~ 核心算法 { while(v[l] <= v[r] && l < r) ++l; //~ 找到左面第一个比v[r]大的v[l] size_t to_mv = 0; //~ 计数器 while(v[r] < v[l] && r < size) ++r, ++to_mv; //~ 右侧找到to_mv个比v[l]小的数 Exchange(v+l, r-l-to_mv, r-l);//~ 将此to_mv个数移到v[l]前面 l += to_mv; //~ 改变l，继续下一轮循环 }//~ l >-r 或者 r >= size时归并结束 ]]> 归并排序算法(mergesort)是将一个序列划分为同样大小的两个子序列，然后对两个子序列分别进行排序，最后进行合并操作，将两个子序列合成有序的序列。在合成的过程中，一般的实现都需要开辟一块与原序列大小相同的空间，以进行合并操作。这里介绍一种不需要开辟新的空间就可以进行归并操作的原地归并算法。代码来说事儿：

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

     
template <class T>
void Swap(T& l, T& r) //~ 交换
{
	T t = l; l = r; r = t;
}
 
template <class T>
void Reverse(T* v, size_t size) //~ 反序
{
	size--;
	size_t l = 0;
	while(l < size)
	{
		Swap(v[l++], v[size--]);
	}
}
 
template <class T>
void Exchange(T* v, size_t l, size_t s) //~ 分块交换：前l个与s-l交换
{	//~ 据说叫手摇算法？
	if(l == 0 || s == 0) return ;
	Reverse(v, l);
	Reverse(v+l, s - l);
	Reverse(v, s); 
}
 
template <class T>
void merge(T* v, size_t size)
{
	if(size == 1) //~ 递归终结点1
		return ;
	else if(size == 2) //~ 递归终结点2
	{
		if(v[0] > v[1])
			Swap(v[0], v[1]);
	}
	else
	{
		//~ 分别排序
		merge(v, size/2);
		merge(v+size/2, size-size/2);
		size_t l = 0, r = size/2;
		//~ 原地归并
		while(l < r && r < size) //~ 核心算法
		{
			while(v[l] <= v[r] && l < r) ++l; //~ 找到左面第一个比v[r]大的v[l]
			size_t to_mv = 0; //~ 计数器
			while(v[r] < v[l] && r < size) ++r, ++to_mv; //~ 右侧找到to_mv个比v[l]小的数
			Exchange(v+l, r-l-to_mv, r-l);//~ 将此to_mv个数移到v[l]前面
			l += to_mv; //~ 改变l，继续下一轮循环
		}//~ l >-r 或者 r >= size时归并结束
	}
}
    ]]>     http://www.dutor.net/index.php/2009/08/merge-sort-2/feed/ 1     整数拼数 http://www.dutor.net/index.php/2009/07/integrade/ http://www.dutor.net/index.php/2009/07/integrade/#comments Mon, 20 Jul 2009 02:22:37 +0000 dutor http://www.dutor.net/?p=914 题目描述： 给你n个整数，用这n个拼成一个超长的整数，要令这个新的整数最小
    输入：
    多组测试数据，每组第一行为n(1<=n<=1000)，接下来是n个正整数，使用空格或者换行分开; 每个数字的长度不会超过1000，不存在前导0; 当n为0时结束程序.
    输出：
    对于每组输入，输出拼成的新的整数的结果]]>     题目描述：

    给你n个整数，用这n个拼成一个超长的整数，要令这个新的整数最小

    输入：

    多组测试数据，每组第一行为n(1<=n<=1000)，接下来是n个正整数，使用空格或者换行分开;
    每个数字的长度不会超过1000，不存在前导0;
    当n为0时结束程序.

    输出：

    对于每组输入，输出拼成的新的整数的结果

    代码一：
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

    //~ set实现
#include <iostream>
#include <string>
#include <set>
 
using namespace std;
template<class T>
class my_strcmp
{
    public:
        bool operator ()(const T& lft, const T& rt)
        {
 
            sum1 = lft + rt;
            sum2 = rt + lft;
            return sum1 < sum2;
        }
    private:
        T sum1, sum2;
};
 
int
main()
{
    multiset<string, my_strcmp<string> > strSet;
    string tmp;
    size_t n;
    while(cin>>n && n)
    {
        strSet.clear();
        while(n--)
        {
            cin>>tmp;
            strSet.insert(tmp);
        }
        for(multiset<string, my_strcmp<string> >::iterator itr = strSet.begin(); 
                itr != strSet.end(); ++itr)
        {
            cout<<*itr<<flush;
        }
        cout<<endl;
 
    }
    return 0;
}
    代码二：
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

    //~ sort实现
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
 
using namespace std;
template<class T>
class my_strcmp
{
    public:
        bool operator ()(const T& lft, const T& rt)
        {
            sum1 = lft + rt;
            sum2 = rt + lft;
            return sum1 < sum2;
        }
    private:
        T sum1, sum2;
};
 
int
main()
{
    vector<string> strVec;
    strVec.reserve(1000);
    string tmp;
    size_t n;
    while(cin>>n && n)
    {
        strVec.clear();
        while(n--)
        {
            cin>>tmp;
            strVec.push_back(tmp);
        }
        sort(strVec.begin(), strVec.end(), my_strcmp<string>() );
        for(vector<string>::iterator itr = strVec.begin(); 
                itr != strVec.end(); ++itr)
        {
            cout<<*itr<<flush;
        }
        cout<<endl;
 
    }
    return 0;
}
    ]]>     http://www.dutor.net/index.php/2009/07/integrade/feed/ 0     归并排序一个 http://www.dutor.net/index.php/2009/07/merge-sort/ http://www.dutor.net/index.php/2009/07/merge-sort/#comments Wed, 08 Jul 2009 23:22:30 +0000 dutor http://www.dutor.net/?p=882 template class Merger { public: Merger(T* array, size_t n):extra(new T[n/2]) //~ 归并需要O(n)的额外空间 { sub_Merger(array, n); //~ 调用递归子函数 } ~Merger() { delete [] extra; //~ 释放内存 } private: T* extra; Merger(); void sub_Merger(T* array, size_t n); }; 如果你有什么好的建议的话，敬请赐教，不胜感激涕零！:)]]> 由于归并排序需要O(n)的额外空间，在普通函数中，我实在想不出好的办法来申请这块内存。于是只好把他写成一个模板类：

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

    #include <iostream>
#include <ctime>
 
using namespace std;
 
template <class T>
class Merger
{
public:
	Merger(T* array, size_t n):extra(new T[n/2]) //~ 归并需要O(n)的额外空间
	{
		sub_Merger(array, n); //~ 调用递归子函数
	}
	~Merger()
	{
		delete [] extra; //~ 释放内存
	}
private:
	T* extra;
	Merger();
	void sub_Merger(T* array, size_t n);
};
 
template <class T>
void Merger<T>::sub_Merger(T * array, size_t n)
{
	if(n == 1) //~ 递归终止
		return ;
	else if(n == 2)  //~ 递归终止
	{
		if( array[0] > array[1] )
		{
			T tmp = array[0];
			array[0] = array[1];
			array[1] = tmp;
		}
	}
	else
	{
		/* 将数组均分为两部分，分别排好，然后归并*/
		size_t m = n / 2;
		//~ 分别排序
		sub_Merger(array, m + 1);
		sub_Merger(array + m + 1, n - m - 1);
		//~ 归并
		size_t i = 0, j = m + 1, k = 0;
		memcpy(extra, array, (m + 1)* sizeof(T));
		while( i <= m && j < n)
		{
			array[k++] = extra[i] < array[j] ? extra[i++]:array[j++];
		}
		while(i <= m)
		{
			array[k++] = extra[i++];
		}
	}
}
 
int main()
{
	srand((unsigned)time(0));
	const int N(100);
	int demo[N];
	for(int i = 0; i < N; ++i)
	{
		demo[i] = rand()%N;
	}
	Merger<int>(demo, N);
	for(int i = 0; i < N; ++i)
		cout<<demo[i]<<endl;
    return 0;
}

    如果你有什么好的建议的话，敬请赐教，不胜感激涕零！:)

    ]]>     http://www.dutor.net/index.php/2009/07/merge-sort/feed/ 0     插入法排序 http://www.dutor.net/index.php/2009/05/insertion-sorting/ http://www.dutor.net/index.php/2009/05/insertion-sorting/#comments Thu, 30 Apr 2009 23:16:16 +0000 dutor http://www.dutor.net/?p=326 算法： 
    for i = 2:n,
    for (k = i; k > 1 and a[k] < a[k-1]; k--) 
        swap a[k,k-1]
    → invariant: a[1..i] is sorted
end
    算法性质：
    • 稳定
    • 需要O(1)的额外空间开销
    • 需要O(n2)复杂度的比较和交换。
    • 具有自适应性：当待排序序列接近有序时，复杂度为O(n)。
    • 开销较低
    讨论：
    虽然在最坏情况下，插入法排序的复杂度为O(n2)，但当序列已经接近有序(算法具有自适应性)或者问题规模比较小(空间开销很小)时，插入法排序还是一种比较好的选择。所以，插入法排序，通常可以作为其他诸如归并排序、快速排序等递归递归排序的基础。
    ]]>     算法：

    1
2
3
4
5

    for i = 2:n,
    for (k = i; k > 1 and a[k] < a[k-1]; k--) 
        swap a[k,k-1]
    → invariant: a[1..i] is sorted
end

    算法性质：

    • 稳定
    • 需要O(1)的额外空间开销
    • 需要O(n2)复杂度的比较和交换。
    • 具有自适应性：当待排序序列接近有序时，复杂度为O(n)。
    • 开销较低

    讨论：

    虽然在最坏情况下，插入法排序的复杂度为O(n2)，但当序列已经接近有序(算法具有自适应性)或者问题规模比较小(空间开销很小)时，插入法排序还是一种比较好的选择。所以，插入法排序，通常可以作为其他诸如归并排序、快速排序等递归递归排序的基础。

    [tip]
    关于自适应性的一种解释：自适应性是指特定条件下形状结构及过程自身的趋向性.
    [/tip]

    ]]>     http://www.dutor.net/index.php/2009/05/insertion-sorting/feed/ 1