C++博客-死神永生-文章分类-litter program

【litter program】二分搜索、左右循环移位、交换等等工具函数

knzeus — Wed, 14 Dec 2011 07:07:00 GMT

/**
* @file tools.h
* @date 2011/12/01 16:44:17
* @version $Revision$
* @brief
*
**/

#ifndef  _KNZEUS_TOOLS_H_
#define  _KNZEUS_TOOLS_H_

#include "stdlibinc.h"

void dumpList(int* al, int num, int no = 0)
{
    if (NULL == al || 1 > num) return ;
    printf("%d : ", no);
    for (int i=0; i        printf("%d ", al[i]);
    }
    printf("\n");
    return ;
}

void dumpList(int* al, int num, char* des)
{
    if (NULL == al || 1 > num) return ;
    if (NULL != des) {
        printf("%s : ", des);
    }
    for (int i=0; i        printf("%d ", al[i]);
    }
    printf("\n");
    return ;
}

template
T min(T t1, T t2)
{
    return ( (t1 > t2) ? t2 : t1 );
}

template
T max(T t1, T t2)
{
    return ( (t1 < t2) ? t2 : t1 );
}

bool isSorted(int* al, int num)
{
    if (NULL == al) return false;
    for (int i=0; i    {
        if (al[i]>al[i+1]) return false;
    }
    return true;
}

void buildRandomList(int* al, int num, unsigned seed = 0)
{
    if (NULL == al) return ;
    if (seed != 0) srand(seed);
    for (int i=0; i        al[i] = rand() % 101;
    }
    return ;
}

void copyList(int* al, int* bl, int num)
{
    if (NULL == al || NULL == bl || 1 > num) {
        return ;
    }
    for (int i=0; i        al[i] = bl[i];
    }
    return ;
}

void swap(int * const al, int i, int j)
{
    if (NULL == al) return ;
    al[i] ^= al[j];
    al[j] ^= al[i];
    al[i] ^= al[j];
    return ;
}

/**
* @brief 对数组al[s, e-1]进行反转
*
* */
void reverse(int *al, int s, int e)
{
    if (NULL == al || s > e-1) return ;
    --e;
    while (s < e) {
        swap(al, s++, e--);
    }
    return ;
}

/**
* @brief 对al[s, e-1]进行循环右移step位
* */
void rotateRight(int * al, int s, int e, int step)
{
    if (NULL == al || s > e-1) return ;
    step %= e - s;
    if (step == 0) return ;
    reverse(al, s, e - step);
    reverse(al, e - step, e);
    reverse(al, s, e);
    return ;
}

void rotateLeft(int * al, int s, int e, int step)
{
    if (NULL == al || s > e-1) return ;
    step %= e - s;
    if (step == 0) return ;
    reverse(al, s, s + step);
    reverse(al, s + step, e);
    reverse(al, s, e);
    return ;
}

/**
* @brief 在有序数组al[0, num-1]中查找值为sv所在的位置，并将下标通过idx返回。
*            查找成功返回0，不存在返回1，idx设置为第一个大于sv的数的下标。
*
* */
int binarySearch(int * al, int num, int &idx, int sv)
{
    idx = -1;
    if (al == NULL || num < 1) return -1;
    int l = 0;
    int h = num - 1;
    while (l < h) {
        int mid = l + (h - l) / 2;
        if (al[mid] > sv) {
            h = mid - 1;
        } else if (al[mid] < sv){
            l = mid + 1;
        } else {
            idx = mid;
            return 0;
        }
    }
    return -1;
}

#endif  //__TOOLS_H_

knzeus 2011-12-14 15:07 发表评论

【litter program】蹩脚的堆排序

knzeus — Wed, 14 Dec 2011 06:48:00 GMT

/**
* @brief al[0 ~ num-1]为大顶堆，将al[num]插入堆中并保持堆性质
*
* */
int adjustHeap(int * al, int num)
{
    if (NULL == al || 0 > num) return -1;
    if (0 == num) return 0;
    int i = num - 1;
    int p = (i-1)/2;
    while (i != 0) {
        if (al[i] > al[p]) {
            swap(al, i, p);
            i = p;
            p = i / 2;
            continue;
        } else {
            break;
        }
    }
    return 0;
}

/**
* @brief 对长度为num的无序整数数组al建立为大顶堆
*
* */
int createHeap(int * al, int num)
{
    if (NULL == al || 0 > num) return -1;
    if (2 > num) return 0;
    for (int i=1; i
    {
        adjustHeap(al, i + 1);
    }
    dumpList(al, num, "heap: ");
    return 0;
}

/**

* @brief 对al[0, num-1]的堆调整，调整前al[0]不符合规则

int adjustHeap2(int * al, int num)
{
    int i = 0;
    int lc = i * 2 + 1;
    while (lc < num) {
        int rc = lc + 1;
        int maxc = lc;
        if (rc < num && al[rc] > al[lc]) {
                maxc = rc;
        }
        if (al[i] < al[maxc]) {
            swap(al, i, maxc);
            i = maxc;
            lc = i * 2 + 1;
        } else {
            break;
        }
    }
    return 0;
}

/**
* @breif 对长度为num的al整数数组进行堆排序，排序后的结果覆盖在al数组上
*
* */
int heapSort(int * al, int num)
{
    if (NULL == al || 0 > num) return -1;
    if (2 > num) return 0;
    createHeap(al, num);
    for (int i=num-1; i>0; --i) {
        swap(al, i, 0);
        adjustHeap2(al, i);
    }
    return 0;
}

knzeus 2011-12-14 14:48 发表评论

【litter program】最大回文子串

knzeus — Thu, 08 Dec 2011 12:00:00 GMT

/**
* @file maxPalindrome.cpp
* @date 2011/12/07 19:40:29
* @version $Revision$
* @brief
*
**/

#include "../common/inc.h"

/**
* @brief
*    在字符串str中找出最大回文子串
*    通过参数pSubPal和subPalLen返回此子串在str的偏移，以及子串的长度
* @return 0-sucess， else fail.
*
* @algorithm
*        From hongcheng's blog
*        http://zhuhongcheng.wordpress.com/2009/08/02/a-simple-linear-time-algorithm-for-finding-longest-palindrome-sub-string/?like=1&_wpnonce=6ca936a13a
*
*        Given a string S, we are to find the longest sub-string s of S such that the reverse of s is
*        exactly the same as s.
*        First insert a special character ‘#’ between each pair of adjacent characters of S, in
*        front of S and at the back of S. After that, we only need to check palindrome sub-strings of
*        odd length.
*        Let P[i] be the largest integer d such that S[i-d,,i+d] is a palindrome.  We calculate
*        all P[i]s from left to right. When calculating P[i], we have to compare S[i+1] with S[i-1],
*        S[i+2] with S[i-2] and so on. A comparison is successful if two characters are the same,
*        otherwise it is unsuccessful. In fact, we can possibly skip some unnecessary comparisons
*        utilizing the previously calculated P[i]s.
*        Assume P[a]+a=max{ P[j]+j :  j= i, then we have
*        P[i] >= min{ P[2*a-i],  2*a-i-(a- P[a])}.
*        Is it the algorithm linear time? The answer is yes.
*        First the overall number of unsuccessful comparisons is obviously at most N.
*        A more careful analysis show that S[i] would never be compared successfully with any
*        S[j](j *        So the number of overall comparisons is a most 2N.
*
*
* */
enum{
    MaxP = 1024*1024,
};
int p[MaxP];
char s[MaxP];
int n = 0;

char str[MaxP/2 - 10];

int pre(const char *str)
{
    n = 0;
    if (NULL == str) return -1;
    int i = 0;
    p[i] = 0;
    s[i++] = '\1';
    while (*str) {
        p[i] = 0;
        s[i++] = *str;
        p[i] = 0;
        s[i++] = '\1';
        ++str;
    }
    s[i++] = '\0';
    n = i;
    return 0;
}

int kp()
{
    int i = 0;
    int m = 0;
    int a = 0;
    for (i=1; i<n; ++i) {
        if (m > i) {
            p[i] = min(p[2*a-i], p[a]+a-i);
        } else {
            p[i] = 1;
        }
        for (; i>=p[i] && s[i+p[i]] != '\0' && s[i+p[i]] == s[i-p[i]]; p[i]++);
        if (p[i]+i > m) {
            m = p[i]+i;
            a = i;
        }
    }
    return 0;
}

int out()
{
    int m = 0;
    int o = 0;
    for (int i=0; i<n; ++i) {
        if (p[i] > m) {
            o = i;
            m = p[i];
        }
    }
    char ch = s[0];
    o = (o -m + 1)/2;
    if (ch == '\1') m--;
    str[o+m] = 0;
    printf("off:%d, len:%d, palindrome:%s\n\n", o, m, str + o);

}

int maxPalindrome(const char * str)
{
    if (NULL == str) return -1;
    pre(str);
    kp();
    out();
    return 0;
}

int main(int argc, char ** argv)
{
    printf("input the string, while given the max palindrome.\n");
    printf("string: ");
    while (EOF != scanf("%s", str)) {
        maxPalindrome(str);
        printf("string: ");
    }
    return 0;
}

/* vim: set ts=4 sw=4 sts=4 tw=100 noet: */

knzeus 2011-12-08 20:00 发表评论

【litter program】O（1）空间的归并排序

knzeus — Mon, 05 Dec 2011 13:47:00 GMT

基于对merge操作的原地归并使得mergeSort空间复杂度为O（1）

/**
* @brief 数组al[0, mid-1] 和 al[mid, num-1]是各自有序的，对两个子段进行Merge得到al[0,
* num-1]的有序数组。要求空间复杂度为O(1)
*
* 方案：
*    1. 两个有序段位A和B，A在前，B紧接在A后面。找到A的第一个大于B[0]的数A[i]. A[0,
*    i-1]相当于merge后的有效段。在B中找到第一个大于A[i]的数B[j]。对数组A[i, lenA+j]循环右移j位.
*    2. 如此循环merge
*    3. 循环右移通过先子段反转再整体反转的方式进行，复杂度是O(L), L是需要循环移动的子段的长度
*
* */
void sortedListMergeO1(int *al, int num, int mid)
{
    if (NULL == al || mid >= num || 0 >= mid) return ;
    int i = 0;
    int j = mid;
    while (i < num) {
        while (al[i] < al[j]) ++i;
        int step = j;
        while(al[j] < al[i]) ++j;
        step = j - step;
        rotateRight(al, i, j, j - step);
        i += step;
    }
    return ;
}

knzeus 2011-12-05 21:47 发表评论

【litter program】原地交换、反转、循环移位

knzeus — Mon, 05 Dec 2011 13:45:00 GMT

void swap(int * const al, int i, int j)
{
    if (NULL == al) return ;
    al[i] ^= al[j];
    al[j] ^= al[i];
    al[i] ^= al[j];
    return ;
}

/**
* @brief 对数组al[s, e-1]进行反转
*
* */
void reverse(int *al, int s, int e)
{
    if (NULL == al || s > e-1) return ;
    --e;
    while (s < e) {
        swap(al, s++, e--);
    }
    return ;
}

/**
* @brief 对al[s, e-1]进行循环右移step位
* */
void rotateRight(int * al, int s, int e, int step)
{
    if (NULL == al || s > e-1) return ;
    step %= e - s;
    if (step == 0) return ;
    reverse(al, s, e - step);
    reverse(al, e - step, e);
    reverse(al, s, e);
    return ;
}

void rotateLeft(int * al, int s, int e, int step)
{
    if (NULL == al || s > e-1) return ;
    step %= e - s;
    if (step == 0) return ;
    reverse(al, s, s + step);
    reverse(al, s + step, e);
    reverse(al, s, e);
    return ;
}

knzeus 2011-12-05 21:45 发表评论

【litter program】非递归归并排序

knzeus — Sun, 04 Dec 2011 11:56:00 GMT

void sortedListMerge(int* al1, int an1, int* al2, int an2, int* bl)
{
    if (NULL == al1 || NULL == al2 || NULL == bl) {
        return ;
    }
    int i1 = 0;
    int i2 = 0;
    int i3 = 0;
    while (i1<an1 && i2<an2)
    {
        if (al1[i1] < al2[i2]) {
            bl[i3++] = al1[i1++];
        } else {
            bl[i3++] = al2[i2++];
        }
    }
    while (i1<an1) {
        bl[i3++] = al1[i1++];
    }
    while (i2<an2) {
        bl[i3++] = al2[i2++];
    }
    return ;
}

int mergeSort(int * aList, const int num)
{
    if (NULL == aList) {
        return -1;
    }
    if (2 > num) {
        return 0;
    }

    int * bList = new (std::nothrow) int[num];
    assert(NULL != bList);

    int* al = aList;
    int* bl = bList;
    for (int step=1; step<num; step*=2) {
        for (int i=0; i<num; i+=step*2) {
            sortedListMerge(al+i, min(step, num - i), al+i+step, min(step, num - i - step), bl+i);
        }
        int* tmp = al;
        al = bl;
        bl = tmp;
    }
    if (al != aList) {
        copyList(aList, al, num);
    }
    if (NULL != bList) {
        delete [] bList;
        bList = NULL;
    }
    return 0;
}

knzeus 2011-12-04 19:56 发表评论

【litter program】递归和非递归快排

knzeus — Sun, 04 Dec 2011 11:55:00 GMT

1 int partition(int * const al, int low, int high, int &mid)
2 {
3     if (NULL == al) return -1;
4     if (low >= high) return 0;
5     int pivo = low;
6     int midV = al[pivo];
7     ++low;
8     while (low <= high) {
9         while (low <= high && al[low] <= midV) ++low;
10         while (low <= high && al[high] > midV) --high;
11         if (low < high) {
12             swap (al, low, high);
13             ++low;
14             --high;
15         }
16     }
17     al[pivo] = al[high];
18     al[high] = midV;
19     mid = high;
20     return 0;
21 }
22
23 int quickSort2(int * const al, int num)
24 {
25     // not recurrence
26     if (NULL == al) return -1;
27     if (2 > num) return 0;
28     SimpleQueue queue(num*2);
29     queue.push(0);
30     queue.push(num-1);
31     while (!queue.empty()) {
32         int low = 0;
33         int high = 0;
34         if (0 != queue.pop(&low) || 0 != queue.pop(&high)) {
35             return -1;
36         }
37         int mid = 0;
38         if (0 != partition(al, low, high, mid)) return -1;
39         /*/
40         printf("low:%d, high:%d, mid:%d, ", low, high, mid);
41         dumpList(al, num, "[inDBG]");
42         /*/
43         if (low < mid - 1) {
44             queue.push(low);
45             queue.push(mid-1);
46         }
47         if (mid + 1 < high) {
48             queue.push(mid+1);
49             queue.push(high);
50         }
51     }
52     return 0;
53 }
54
55 int quickSort(int * const  al, int low, int high)
56 {
57     if (NULL == al) return -1;
58     if (low >= high) return 0;
59
60     int L = low;
61     int H = high;
62     int midV = al[L];
63     ++low;
64     while (low <= high) {
65         while (low <= high && al[low] <= midV) ++low;
66         while (low <= high && al[high] > midV) --high;
67         if (low < high) {
68             swap (al, low, high);
69             ++low;
70             --high;
71         }
72     }
73     al[L] = al[high];
74     al[high] = midV;
75     quickSort(al, L, high - 1);
76     quickSort(al, high + 1, H);
77     return 0;
78 }
79
80 int quickSort(int * const al, const int num)
81 {
82     return quickSort(al, 0, num-1);
83 }

knzeus 2011-12-04 19:55 发表评论

【litter program】简单整数循环队列

knzeus — Sun, 04 Dec 2011 11:53:00 GMT

1 #ifndef  __QUEUE_H_
2 #define  __QUEUE_H_
3
4 template<typename T>
5 class IQueue
6 {
7     public:
8         virtual ~IQueue(){}
9         virtual int push(const T &t) = 0;
10         virtual int front(const T **pt) = 0;
11         virtual int pop(T *t) = 0;
12         virtual bool empty() = 0;
13 };
14
15 class SimpleQueue : public IQueue<int>
16 {
17 public:
18     SimpleQueue(const int maxSize = 1024*1024)
19         : _queue(NULL), _size(maxSize), _head(0), _tail(0), _full(false), _valid(false)
20     {
21         if (0 >= _size) return ;
22         _queue = new (std::nothrow) int[_size];
23         if (NULL == _queue) return ;
24         _valid = true;
25     }
26
27     ~SimpleQueue()
28     {
29         if (NULL != _queue) {
30             delete [] _queue;
31             _queue = NULL;
32         }
33     }
34
35     int push(const int &a)
36     {
37         if (!_valid || _full) return -1;
38         _queue[_tail] = a;
39         ++_tail;
40         if (_tail >= _size) _tail = 0;
41         if (_head == _tail) _full = true;
42         return 0;
43     }
44
45     int front(const int ** ppa)
46     {
47         if (!_valid || NULL == ppa || _head == _tail) return -1;
48         *ppa = &_queue[_head];
49         return 0;
50     }
51
52     int pop(int * pa)
53     {
54         if (!_valid || NULL == pa || (_head == _tail && !_full) )  return -1;
55         *pa = _queue[_head++];
56         if (_head >= _size) _head = 0;
57         return 0;
58     }
59
60     bool empty()
61     {
62         return (!_valid || _head == _tail);
63     }
64
65 private:
66     int * _queue;
67     int _size;
68     int _head;
69     int _tail;
70     bool _full;
71     bool _valid;
72 };

knzeus 2011-12-04 19:53 发表评论