C++博客-
一年十二月谁主春秋
关注：基础系统工程密码学人工智能
-随笔分类-Algorithm

基于list_head实现的通用内核Hash表

春秋十二月 — Tue, 15 Sep 2015 09:18:00 GMT

摘要: 由于linux内核中的struct list_head已经定义了指向前驱的prev指针和指向后继的next指针，并且提供了相关的链表操作方法，因此为方便复用，本文在它的基础上封装实现了一种使用开链法解决冲突的通用内核Hash表glib_htable，提供了初始化、增加、查找、删除、清空和销毁6种操作，除初始化和销毁外，其它操作都做了同步，适用于中断和进程上下文。... 阅读全文

春秋十二月 2015-09-15 17:18 发表评论

基于特定小范围关键字的原位统计排序

春秋十二月 — Thu, 31 May 2012 04:11:00 GMT

摘要: 基本原理在数据输入随机分布的情况下，快速排序具有较好的性能表现，但当元素个数比其关键字的取值范围大，而这个范围相对较小时，使用一种关键字索引统计排序会快很多，因为它的时间复杂度是线性的，基本原理是使用数组（为描述方便，特称统计数组），其下标对应关键字的值，存储元素按待排序关键字的值统计的出现次数，然后再按元素关键字的值，结合统计数组，放回到最终位置上。常规的实现... 阅读全文

春秋十二月 2012-05-31 12:11 发表评论

三路划分快速排序--针对重复关键字的改进

春秋十二月 — Sat, 19 May 2012 06:48:00 GMT

基本原理
   快速排序算法是一种分治排序算法，影响其性能的因素有划分元素的选择、小的子文件的处理、重复关键字等，本文论述针对重复关键字的改进实现。首先来回顾下一般的算法实现，其流程如下：
   a. 选择一个划分元素，这个元素在划分后将在最终的位置上，通常是选择最右端元素作为划分点。
   b. 从左端开始扫描，直到找到大于划分元素的元素；同时从右端开始扫描，直到找到小于划分元素的元素，再交换使扫描停止的这两个元素。
   c. 继续步骤b，直到左指针不小于右指针，最后再交换左指针元素和划分元素。
   d. 在左指针左侧和右侧区间(区间不包括左指针元素)重复以上过程，直至元素个数为0或1。
   在划分的过程中，位于左指针左侧的元素都比划分元素小，右侧的元素都比划分元素大，如下图所示

   由上述可见，一般的算法实现针对大量重复关键字的输入情况，其性能表现很差，例如如果一个文件完全由相等的值(只有一个值)组成，那么它就不需要再进行任何排序，但前面的算法依然划分直至得到小的子文件，无论文件有多大。针对这一情况，可以作实质性的改进，从而避免处理元素相同的子区间，提高效率。改进的算法实现主要问题在于如何处理与划分元素相等的情况，这里的基本思想是将区间划分为三个部分，左部分小于划分元素，中间部分等于划分元素，右部分大于划分元素，然后再在左右两部分进行子处理，具体的流程如下：
   a'. 选择左端元素、中间元素和右端元素的中值作为划分元素，也就是三者取中划分，这样能有效避免划分区间的最坏情况。
   b'. 从左端开始扫描，直到找到不小于划分元素的元素；同时从右端开始扫描，直到找到不大于划分元素的元素，再交换使扫描停止的这两个元素。如果左指针元素等于划分元素，那么与左端的元素交换，并递增左端位置(初始化为文件最左位置)；如果右指针元素等于划分元素，那么与右端元素交换，并递减右端位置(初始化为文件最右位置)。
   c'. 继续步骤b'，直到左指针不小于右指针。
   d'. 交换最左端区间和左指针左侧区间(不包括左指针元素)，这一过程会递减左端位置；交换最右端区间和左指针右侧区间(包括左指针元素)，这一过程会递增右端位置。
   e'. 在最左端和最右端区间重复以上过程，直至元素个数为0或1。
   在划分的过程中，与划分元素相等的元素分布在最左端和最右端，如下图所示

在划分完成后处理子文件前，需要对调区间，如步骤d'所述，结果如下图所示

代码实现
上面所有图中的v代表划分元素，最后列出代码清单，函数quick_sort有两个版本，一个是支持operator < 的默认实现，另一个是支持带谓词的自定义比较实现。在其中用到了实现三者取中值的__median函数，对应的也有两个版本实现，如下所示

1template<class _RandIt>
2void quick_sort(_RandIt _first,_RandIt _last)
3{
4    typedef typename std::iterator_traits<_RandIt>::value_type _ValType;
5    if (!(_first<_last-1)) return;
6
7    _RandIt i = _first,j = _last-1,p = i,q = j,k;
8    _ValType pivot = __median(*_first,*(_last-1),*(_first+(_last-_first)/2));
9
10    while(true)
11    {
12        while(*i < pivot) ++i;
13        while(pivot < *j) --j;
14        if (!(i < j)) break;
15        std::iter_swap(i,j);
16
17        if (!(*i < pivot) && !(pivot < *i))
18            std::iter_swap(p++,i);
19        if (!(*j < pivot) && !(pivot < *j))
20            std::iter_swap(q--,j);
21        ++i; --j;
22    }
23
24    j = i - 1;
25    for(k = _first;k<p;--j,++k) std::iter_swap(k,j);
26    for(k = _last-1;k>q;++i,--k) std::iter_swap(k,i);
27
28    quick_sort(_first,j+1);
29    quick_sort(i,_last);
30}
31
32template<class _RandIt,class _Compare>
33void quick_sort(_RandIt _first,_RandIt _last,_Compare _comp)
34{
35    typedef typename std::iterator_traits<_RandIt>::value_type _ValType;
36    if (!(_first < _last - 1)) return;
37
38    _RandIt i = _first,j = _last-1,p = i, q = j, k;
39    _ValType pivot = __median(*_first,*(_last-1),*(_first+(_last-_first)/2),_comp);
40
41    while(true)
42    {
43        while(_comp(*i,pivot)) ++i;
44        while(_comp(pivot,*j)) --j;
45        if (!(i < j)) break;
46        std::iter_swap(i,j);
47
48        if (!_comp(*i,pivot) && !_comp(pivot,*i))
49            std::iter_swap(p++,i);
50        if (!_comp(*j,pivot) && !_comp(pivot,*j))
51            std::iter_swap(q--,j);
52        ++i; --j;
53    }
54    j = i - 1;
55    for(k = _first;k < p;++k,--j)
56        std::iter_swap(k,j);
57    for(k = _last - 1;k > q;--k,++i)
58        std::iter_swap(k,i);
59
60    quick_sort(_first,j+1,_comp);
61    quick_sort(i,_last,_comp);
62}

从上面实现可看出，与一般的实现相比，划分过程多了两个if及for循环，if测试用来将找到的重复元素放在左右两端；for循环用来交换区间，将重复元素再放在中间，这额外的工作量只与找到的重复关键字的个数成线性，因此，即使在没有重复关键字的情况下，它也运行得很好，平均时间复杂度为O(NlgN)。

春秋十二月 2012-05-19 14:48 发表评论

基于双端堆实现的优先级队列（3）：外观

春秋十二月 — Wed, 05 Oct 2011 05:24:00 GMT

摘要: 本文讲述双端堆的5个公开泛型操作算法：make_dheap（原位构造双端堆）、push_dheap（插入元素）、pop_max_dheap（删除最大元素）、pop_min_dheap（删除最小元素），is_dheap（堆验证），每个算法都提供<小于运算符和仿函数比较2个版本，要注意的是比较必须是严格弱序的，即对于<版本存在a阅读全文

春秋十二月 2011-10-05 13:24 发表评论

基于双端堆实现的优先级队列（2）：内幕

春秋十二月 — Mon, 03 Oct 2011 09:54:00 GMT

摘要: 在《基于双端堆实现的优先级队列（1）：原理》一文中讲述了双端堆的相关原理，本文则详细讲述具体的内部实现，便于区分，内部函数名称都以双下划线作为前缀，在这里，有几个关键问题需要说明 1）怎么求一个结点的对称结点：如果完全二叉树根结点从索引1开始但不存储元素，那么最小堆根结点则在索引2，最大堆根结点则在索引3，4和5为2的左右孩... 阅读全文

春秋十二月 2011-10-03 17:54 发表评论

基于双端堆实现的优先级队列（1）：原理

春秋十二月 — Mon, 03 Oct 2011 09:53:00 GMT

前言
   众所周知，stl中的优先级队列是基于最大堆实现的，能够在对数时间内插入元素和获取优先级最高的元素，但如果要求在对数时间内还能获取优先级最低的元素，而不只是获取优先级最高的元素，该怎么实现呢？可以用最大堆-最小堆或双端堆数据结构来实现，最大堆-最小堆和双端堆都是支持双端优先队列的插入、删除最小元素和最大元素等操作的堆，在这些操作上，时间复杂度都是对数时间，但是双端堆的操作比最大堆-最小堆的相应操作还要快一个常数因子，而且算法更加简单，因此本文讲述选择使用双端堆实现优先级队列的原理。

定义与性质
   双端堆是一颗完全二叉树，该完全二叉树要么为空，要么满足以下性质：
（1）根结点不包含元素
（2）左子树是一个最小堆
（3）右子树是一个最大堆
（4）如果右子树不为空，则令i是左子树中任一结点，j是i在右子树中的对应结点，如果i在右子树中的对应结点不存在，则j为i的父结点在右子树中的对应结点，对于结点i和j，i的关键字值小于等于j的关键字值。
   从以上性质可以推出：对于左子结中的任一结点i，设j为i的对称结点，则由最小元素到i，i到j，j到最大元素的路径上元素是非递减有序的。在双端堆上的操作算法核心就是为了保证这样的单向路径上元素必须是非递减有序的。
   例如下图所示，就是一个双端堆

操作算法
（1）插入元素：设所插结点为i，其对称结点为j，要分2种情况 a）当i处于最小堆时，则j处于最大堆中，如果KeyValue(i)>KeyValue(j)，则设置value= KeyValue(i)，KeyValue(i)=KeyValue(j)，并执行在最大堆中位置j处插入值value的操作；否则执行在最小堆中位置i处插入值KeyValue(i)的操作。b）当i处于最大堆时，则j处于最小堆中，如果KeyValue(i)
（2）删除最小元素：首先在最小堆中执行一个向下回溯过程，这个过程执行的堆大小要比原来的堆小1，从最小元素结点开始，每次选取关键字值较小的孩子结点，并用其值更新父结点值，直到底部没有孩子结点，执行的结果是在底部某叶子结点i处形成一个空洞（形象说法，这个空洞需要后续操作来调整填补，下同），i的对称结点j在最大堆中，设最末元素结点为e，如果KeyValue(e)>KeyValue(j)，则设置KeyValue(i)=KeyValue(j)，并执行在最大堆中位置j处插入值KeyValue(e)的操作；否则执行在最小堆中位置i处插入值KeyValue(e)的操作。

（3）删除最大元素：这个操作比删除最小元素要麻烦一点，和删除最小元素类似，先执行一个向下回溯过程得到空洞结点i，其对称结点为j，为了保证能满足双端堆的性质，需要考虑以下几种情况：a）j只存在一个孩子，如下图第1个所示。 b）j存在两个孩子，如下图第2个所示。 c）j不存在孩子，但存在左兄弟（可能存在孩子），如下图第3个所示。 d）j不存在孩子，但存在右兄弟，如下图最后一个所示。

令min为具有较小值的结点，max为具有较大值的结点，最末元素结点为e，value=KeyValue(e)，如果j存在孩子结点，则 min为孩子中关键字值较小的结点，max为关键字值较大的结点；否则min为j和其兄弟结点中关键字值较小的结点，max为关键字值较大的结点。如果KeyValue(min)
（4）构造堆：给定一个元素大小为N的序列S，在这个序列空间上构造堆，一般有两种实现方法，一是循环N-1次，每次插入元素S[i]，也就是自顶向下构建堆，时间复杂度为O(NlgN)。另一种是从最后一个内部结点N/2左右开始，执行调整堆操作，直到第一个元素，也就是自底向上构建堆，时间复杂度为O(N)。

（5）最大堆（最小堆）插入：这是一个向上回溯过程，和单个最大堆（最小堆）操作是一样的，从底部某处开始，比较待插元素和结点关键字值大小，直到前者不大于（不小于）后者时或碰到最大堆（最小堆）顶部为止，这时就找到了插入位置，将待插元素放到这个位置即可。

设双端堆元素个数为N，由于完全二叉树高度为O(lgN)，则插入元素操作时间复杂度为O(lgN)，删除最小元素和最大元素为不超过2O(lgN)，实现这些操作最重要的一点就是要保证性质4，只有当性质4满足时，双端堆才有意义，才能保证获取最大元素和最小元素操作的对数时间，具体的实现详见下文。

春秋十二月 2011-10-03 17:53 发表评论

基于顺序存储实现的多叉树（7）：深度遍历

春秋十二月 — Mon, 03 Oct 2011 09:52:00 GMT

摘要: 类型定义在多叉树中，深度遍历迭代器有只读、读写、只读反转、读写反转4种，在mtree容器中的定义如下： Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ -->1&n... 阅读全文

春秋十二月 2011-10-03 17:52 发表评论

基于顺序存储实现的多叉树（6）：叶子遍历

春秋十二月 — Thu, 25 Aug 2011 02:35:00 GMT

摘要: 类型定义在多叉树中，叶子遍历迭代器有只读、读写、只读反转、读写反转4种，在mtree容器中的定义如下： Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->1 &nb... 阅读全文

春秋十二月 2011-08-25 10:35 发表评论

基于顺序存储实现的多叉树（5）：兄弟遍历

春秋十二月 — Sat, 20 Aug 2011 13:06:00 GMT

摘要: 类型定义在多叉树中，兄弟遍历迭代器有只读、读写、只读反转、读写反转4种，在mtree容器中的定义如下： Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->1 ... 阅读全文

春秋十二月 2011-08-20 21:06 发表评论

基于顺序存储实现的多叉树（4）：后序遍历

春秋十二月 — Mon, 15 Aug 2011 04:51:00 GMT

摘要: 类型定义在多叉树中，后序遍历迭代器有只读、读写、只读反转、读写反转4种，在mtree容器中的定义如下： Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ -->1 &nb... 阅读全文

春秋十二月 2011-08-15 12:51 发表评论

基于顺序存储实现的多叉树（3）：前序遍历

春秋十二月 — Sun, 14 Aug 2011 05:30:00 GMT

摘要: 类型定义在多叉树中，前序遍历迭代器有只读、读写、只读反转、读写反转4种，在mtree容器中的定义如下： Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ -->1 &n... 阅读全文

春秋十二月 2011-08-14 13:30 发表评论

基于顺序存储实现的多叉树（2）：迭代器的设计

春秋十二月 — Sat, 30 Jul 2011 23:55:00 GMT

摘要: 迭代器的分类与框架迭代器是一种设计模式，用来访问容器对象的内容而无须暴露容器的内部实现，而多叉树是一种具有递归性质的复合对象，因此它的迭代器是一种复合迭代器，且存在多种遍历顺序和策略，如前序、后序、广度、叶子、兄弟等，为了支持实现这种复合迭代器，就需要设计不同的迭代器类，由于迭代器封装了对多叉树的访问，而这种访问又可分为只读和读写两类，它们在stl中的实现就... 阅读全文

春秋十二月 2011-07-31 07:55 发表评论

基于顺序存储实现的多叉树（1）：深度优先存储

春秋十二月 — Wed, 13 Jul 2011 07:10:00 GMT

摘要: 需求分析在数据结构中，树有两种存储方式，一种是链式存储，另一种是顺序存储。前者就是使用指针来记录树结点间的关系，在新增结点或删除结点时，只需改变与父结点或兄弟结点的指针值即可，实现较为简单；后者就是使用数组来存储，可以用相对偏移量来记录树结点间的关系，在新增结点或删除结点时，则不仅是改变与父结点或兄弟结点的相对偏移量，还需要改变其它结点的相对偏移量，实现较为... 阅读全文

春秋十二月 2011-07-13 15:10 发表评论

查找序列中的最大数和最小数

春秋十二月 — Sun, 03 Jul 2011 10:05:00 GMT

这个问题，解法比较多，假设序列X大小为N，一种普通的做法是先设定最大值和最小值都为序列中第一个元素值，在一个循环内，每次循环都和当前最大值和最小值来比较更新，这样就需要2N-2次比较了；再进一步，如果先查找最大值，则需N-1次比较，再查找最小值，则需N-2次比较，总共是2N-3次比较，比上一方法少了1次。这些做法都是每次取1个数来比较，比较次数为O(2N)。接下来，我们把情况扩展到每次取多于1个数，先试试看每次取2个数，即N-2个数的解，对N个数求解。当N=1时，最大值和最小值就是第1个元素值；当N=2时，最大值和最小值就是第1个元素和第2个元素的最大值和最小值；考察X[N-2]和X[N-1]，同时令前N-2个数的解是MAX和MIN，易见，做3次比较便能得出新的最大值和最小值，首先比较X[N-2]和X[N-1]，然后将其中大数同MAX比较，小数同MIN比较，这样一来，大约需O(3N/2)次比较即可，而不是先前的O(2N)次。那么，是不是每次取3个或4个数能更进一步减少总共的比较次数呢？有趣地是，可以证明，每次取多于2个数来比较时，总共所需次数和取2个元素来比较是一样的。本文示例的是每次取2个数比较的实现，C++代码描述如下

1//动态数组版本1，T须支持operator < 运算
2template<typename T>
3void get_max_min(const T* p, size_t n, T& max, T& min)
4{
5    assert(n);
6
7    T t_max, t_min, p_min, p_max;
8    p_min = p_max = p[0];
9
10    size_t i;
11    for(i = 1;i < n-1; i+=2)
12    {
13        if (p[i+1] < p[i])
14            t_max = p[i], t_min = p[i+1];
15        else
16            t_max = p[i+1],t_min = p[i];
17
18        if (p_max < t_max)
19            p_max = t_max;
20
21        if (t_min < p_min)
22            p_min = t_min;
23    }
24    if (i == n-1)
25    {
26        if (p_max < p[n-1])
27            p_max = p[n-1];
28        else if (p[n-1] < p_min)
29            p_min = p[n-1];
30    }
31    min = p_min;max = p_max;
32}
33
34//静态数组版本2, T须支持operator < 运算
35template<typename T,size_t N>
36void get_max_min(const T (&p)[N],T& max, T& min)
37{
38    get_max_min(p,N,max,min);
39}

对于以上代码的实现，由前面分析可知，当N为奇数时，总共比较次数为3/2*(N-1)；当N为偶数时，总共比较次数为3N/2-1，时间复杂度为0(3N/2)。

春秋十二月 2011-07-03 18:05 发表评论

字符大小写转换

春秋十二月 — Sat, 25 Jun 2011 04:13:00 GMT

原为某著名软件公司试题，大意如下：请实现以下两个函数：char toupper(char c); char tolower(char c); 分别用于将传入的字母转为大写和小写。两个函数传入的参数取值范围都是[a-zA-Z]，并且为ASCII编码，实现时不用检查参数合法性。两个函数的实现不能使用任何形式的分支、跳转等类型的语句或指令（特别说明：C/C++的条件操作符?:也是分支指令的一种形式，故而不能使用）。请尽可能多的写出你知道的办法。

分析解决：此题比较特别，限制严格，根据题目要求，排除if else、for、while、do while、switch case、?:外，能使用的语句就只有 =、+=、-=、&、|、^、++、--这些了，想要实现大小写转换，只能从这些语句中进行选择思考，由于字符集为ASCII编码，且范围明确为[a-zA-Z]，我们知道，a-z对应ASCII值为97-122，A-Z对应ASCII为65-90，观察这些数字，可以发现97-122都大于96 ，65-90都大于64且小于96，进一步从二进制上考虑，则发现所有小写字母对应的二进制形式为011XXXXX，大写字母对应的二进制形式为010XXXXX，一到这里，哈哈，答案就出来了，通过位运算&和|就可实现了。代码描述如下

1 char toupper(char c)
2 {
3     return c & 0x5F;
4 }
5
6 char tolower(char c)
7 {
8     //c | 0x60也行,但不太好,因为0x60会改变结果的第7位值,根据题目意思,改变第6位值为1,而其它位保持不变就够了。
9     return c | 0x20;
10}

至于其它方法，我就没多想了，还希望各位大侠多多分享一下哈。

春秋十二月 2011-06-25 12:13 发表评论

求单向链表倒序第m个元素

春秋十二月 — Fri, 24 Jun 2011 03:40:00 GMT

原题为某游戏公司试题，大意如下：对于一个单向链表，试写出找到它的倒序第m个元素(m >= 1)的函数，注意变量命名、注释、时间复杂度、空间复杂度。注：要求写出可编译并可以运行通过的程序代码。

这道题的常规做法或者说首先想到直觉的方法M1是先求得链表的长度，即元素总个数n，然后问题转化为求顺序第n-m+1个元素。下面给出第2种方法M2：先求得顺序第m个元素，用一指针P指向这个元素，用另一指针PR指向链表的头部，现在好了，P和PR同时向右移动，直到P为空，则PR就是要求的倒序第m个元素，如果因m超越界限，则PR为空，表示没找到，这样一来，只需一次循环就够了。C++代码描述如下

1 template<typename T>
2 struct Node
3 {
4     T  data;    /**////< 数据
5     Node* next;  ///< 指向下一结点的指针
6 } ;
7
8 template<typename T>
9 Node<T>* ReverseFind(Node<T>* head, size_t m)
10{
11    size_t  n = 0;
12    Node<T> *p, *pR = NULL;
13    for (p = head;p;p = p->next)
14    {
15        if (++n == m)
16        {
17            pR = head;
18            continue;
19        }
20        if (pR)
21        {
22            pR = pR->next;
23        }
24    }
25    return pR;
26}

现在分析这2种方法的时间复杂度，假设链表元素个数为N，所求倒序为第M元素，N>=M，则M1方法为0(N)+0(N-M)=0(2N-M)，M2方法为O(M)+O(N-M)=0(N)，因此M2快于M1。

春秋十二月 2011-06-24 11:40 发表评论

十进制整数千位分隔符

春秋十二月 — Fri, 24 Jun 2011 02:55:00 GMT

   原题为某游戏公司的试题，大意如下：写一个千位分隔符算法，函数原型是 char * format_thousands_separator(unsigned long val); 要求实现效果是 1.使用者不需要释放返回的字符串指针 2.支持最多调用16次而不返回相同指针地址。可以用以下方法测试
    printf("num1(%s), num2(%s), num3(%s)\n", format_thousands_separator(0),format_thousands_separator(123456),format_thousands_separator(23456789));
   注：要求写出可编译并可以运行通过的程序代码。

   经过修改后，我目前最简洁的C代码描述如下

1 char* format_thousands_separator(unsigned long  val)
2 {
3     static char buf[16][16];
4     static int  c = 0;
5
6     long m, n = 0;
7     char* p = &buf[c++ % 16][15];
8     *p = '\0';
9
10    do
11    {
12        m = val % 10;
13        val = val / 10;
14        *--p = '0' + m;
15
16        if (val && !(++n % 3))
17            *--p = ',';
18
19    } while(val);
20
21    return p;
22}

这里再稍作一下扩展，使之能支持负数，代码描述如下

1char* format_thousands_separator(long  val)
2 {
3     static char buf[16][16];
4     static int  c = 0;
5
6     long m, n = 0;
7     char* p = &buf[c++ % 16][15];
8     *p = '\0';
9
10    do
11    {
12        m = val % 10;
13        val = val / 10;
14        *--p = '0' + (m < 0 ? -m : m);
15
16        if (!val && m < 0)
17            *--p = '-';
18
19        if (val && !(++n % 3))
20            *--p = ',';
21
22    } while(val);
23
24    return p;
25}

如果哪位大侠有更简洁高效的代码，还望留言或Email我，谢谢哈

春秋十二月 2011-06-24 10:55 发表评论

判断整数的正负零特性

春秋十二月 — Sat, 18 Jun 2011 15:50:00 GMT

原为某软件公司试题，大意如下：对于给定的有符号32位整数，写一个函数，当该数为正数时返回1，为负数时返回-1，为零时返回零，要求不能使用任何的条件判断分支跳转语句。在这里，稍微扩展了一下，给出了对应无符号32位整数的情形。解决思路是符号位和值分开处理，对于有符号32位整数，符号位右移31位即得a，若为非负数则a=0x00000000，否则a=0xFFFFFFFF；然后将值部分各位的值（0或1）不断缩小合并到一位中去得到b，这是针对0和正数的情况处理，再将a和b位或即可。C++代码描述如下

1//若val为0则返回0, val为负数则返回-1, 为正数返回1
2int32_t check32(int32_t val)
3{
4    int32_t a = val >> 31;
5    int32_t b = (val & 0x0000FFFF) | ((val >> 16)&0x0000FFFF);
6    b = (b & 0x000000FF) | ((b >> 8)&0x000000FF);
7    b = (b & 0x0000000F) | ((b >> 4)&0x0000000F);
8    b = (b & 0x00000003) | ((b >> 2)&0x00000003);
9    b = (b & 0x00000001) | ((b >> 1)&0x00000001);
10   return a|b;
11}
12
13//若val为0则返回0, 否则返回1
14uint32_t check32(uint32_t val)
15{
16    uint32_t a = (val & 0x0000FFFF) | ((val >> 16)&0x0000FFFF);
17    a = (a & 0x000000FF) | ((a >> 8)&0x000000FF);
18    a = (a & 0x0000000F) | ((a >> 4)&0x0000000F);
19    a = (a & 0x00000003) | ((a >> 2)&0x00000003);
20    a = (a & 0x00000001) | ((a >> 1)&0x00000001);
21    return a;
22}

若哪位有更好的解法，还望多多分享

春秋十二月 2011-06-18 23:50 发表评论

字符串16进制存储

春秋十二月 — Sun, 12 Jul 2009 08:58:00 GMT

上次介绍了一种字符串转化为16进制显示的算法，并封装成了API，这个API可用于串口收到数据后按16进制显示字符串，这次介绍串口按16进制发送字符串的算法，使用基于字符类型参数的模板函数实现。算法原理是遍历字符串，将在区间'0'--'9','A'--'F','a'--'f'的字符转化成对应的16进制整数(范围为闭区间0-15)，如遇到连续2个可以转换的字符，则将它们存储在一个无符号字节内，如遇到不能转化的字符，则略过继续。代码如下:

1/**
2    @brief 将字符转化为对应的10进制数整数 ASCII版本
3    * 若字符不能转化则返回-1
4*/
5template<typename charT>
6inline char ConvertHexChar(charT ch)
7{
8    if(ch>=(charT)'0'&&ch<=(charT)'9')
9        return ch-(charT)'0';
10    else if(ch>=(charT)'A'&&ch<=(charT)'F')
11        return ch-(charT)'A'+10;
12    else if(ch>=(charT)'a'&&ch<=(charT)'f')
13        return ch-(charT)'a'+10;
14    else
15        return -1;
16}
17
18typedef std::vector<unsigned char> CByteArrayEx;
19
20/**
21    @brief 将字符串转化成对应的16进制数形式存储
22    @param template charT 源字符类型
23    @param src 源数据串
24    @param size 要转换的长度,字符数
25    @param ByteArray 存放结果的字节数组
26
27    * 如字符串80 12 34 46 AD FF,对应的就是0x80,0x12,0x34,0x46,0xAD,0xFF
28    该函数会自动过滤不能转换的字符,可转换字符范围在0--9,a--f,A--F区间
29*/
30template<typename charT>
31inline void StrToHex(const charT* src,size_t len,CByteArrayEx& ByteArray)
32{
33    char low = -1, high = -1;
34    for (size_t n = 0; n < len; )
35    {
36        high = ConvertHexChar(src[n++]);
37        if (-1 == high)
38        {
39            continue;
40        }
41        if (n >= len)
42        {
43            ByteArray.push_back(high);
44            break;
45        }
46        low = ConvertHexChar(src[n++]);
47        if (-1 == low)
48        {
49            ByteArray.push_back(high);
50            continue;
51        }
52        ByteArray.push_back(high * 16 + low);
53    }
54}
55
56/**
57    @brief 将字符串转化成对应的16进制数形式存储
58    @param template charT 源字符类型
59    @param src 源数据串
60    @param ByteArray 存放结果的字节数组
61*/
62template<typename charT>
63inline void StrToHex(const charT* src,CByteArrayEx& ByteArray)
64{
65    StrToHex(src,select_variable<is_ansi_char<s_charT>::value>(strlen,wcslen)(src),ByteArray);
66}

春秋十二月 2009-07-12 16:58 发表评论

字符串16进制显示

春秋十二月 — Sat, 27 Jun 2009 05:08:00 GMT

最近在项目中调试串口,,总结封装了字符串转化为16进制显示的算法,串口数据发送一般为ASCII和16进制两种,当收到数据时数据也有ASCII和16进制显示两种方式,下面给出一种转化算法,该算法基于字符类型参数化的模板实现，字符串的转化只是调用其内存版本，算法原理是对字符串内存进行操作转化,以一个字节(unsigned char类型)为单位,分别取其高4位和低4位(范围为0x0--0xF), 转化为对应的目标字符('0'--'F')显示,代码如下

1/**
2    @brief MemToHex
3    @param template charT 字符类型
4    @param src  源缓冲区
5    @param size  lpSrc指向数据的大小,字节数
6    @param tag  显示分隔符,默认为0表示空字符
7    @return       返回转化后16进制字符串
8*/
9template<typename charT>
10inline std::basic_string<charT> MemToHex(const void* src, size_t size, bool upper = true,charT tag = 0)
11{
12    std::basic_string<charT> strDest;
13    strDest.reserve(2*size);
14
15    unsigned char* pSrc = (unsigned char*)src;
16    unsigned char  buf[2];
17
18    for (size_t i = 0; i < size; ++i)
19    {
20        unsigned char c0 = *pSrc >> 4;
21        if ( c0 >= 0x0 && c0 <= 0x9)
22            buf[0] = c0 - 0 + '0';
23        else
24            buf[0] = c0 - 10 + (upper ? 'A' : 'a');
25
26        unsigned char c1 = *pSrc++ & 0x0F;
27        if ( c1 >= 0x0 && c1 <= 0x9)
28            buf[1] = c1 - 0 + '0';
29        else
30            buf[1] = c1 - 10 + (upper ? 'A' : 'a');
31
32        strDest += (charT)buf[0];
33        strDest += (charT)buf[1];
34        if (tag != 0)  strDest += tag;
35    }
36    return strDest;
37}
38
39/**
40    @brief StrToHex
41    @param template d_charT 目标字符类型
42    @param template s_charT 源字符类型
43    @param src  源字符串
44    @param upper  true表示大写,false表示小写
45    @param tag  显示分隔符,默认为0表示空字符
46    @return       返回转化后16进制字符串
47*/
48template<typename d_charT,typename s_charT>
49inline std::basic_string<d_charT> StrToHex(const s_charT* src, bool upper = true,d_charT tag = 0)
50{
51    return MemToHex(src,select_variable<is_ansi_char<s_charT>::value>(strlen,wcslen)(src)*sizeof(s_charT),upper,tag);
52}

在应用中需要转化时, 只需调用StrToHex函数,示例如下:

1    string strDest1 = StrToHex<char>("123456789汉字ABCXYZ");
2    wstring wstrDest1 = StrToHex<wchar_t>("123456789汉字ABCXYZ",true,' ');
3    string strDest2 = StrToHex<char>(L"123456789汉字ABCXYZ");
4    wstring wstrDest2 = StrToHex<wchar_t>(L"123456789汉字ABCXYZ", true,L',');
5
6    TRACE4("%s \n", strDest1.c_str());
7    TRACE4(L"%s \n", wstrDest1.c_str());
8    TRACE4("%s \n", strDest2.c_str());
9    TRACE4(L"%s \n", wstrDest2.c_str());

结果输出如下:

1313233343536373839BABAD7D641424358595A
231 32 33 34 35 36 37 38 39 BA BA D7 D6 41 42 43 58 59 5A
3310032003300340035003600370038003900496C575B410042004300580059005A00
431,00,32,00,33,00,34,00,35,00,36,00,37,00,38,00,39,00,49,6C,57,5B,41,00,42,00,43,00,58,00,59,00,5A,00,

春秋十二月 2009-06-27 13:08 发表评论

C++博客-一年十二月 谁主春秋关注：基础系统工程 密码学 人工智能-随笔分类-Algorithm