MyException - 我的异常网
当前位置:我的异常网» C语言 » C基础 算法实现层面套数

C基础 算法实现层面套数

www.MyException.Cn  网友分享于:2013-10-11  浏览:0次
C基础 算法实现层面套路

引言 - 从实践狗讲起

  理论到实践(有了算法到实现) 中间有很多过程. 算法方面本人啥也不懂, 只能说说实现方面. 例如下面

一个普通的插入排序.

//
// 插入排序默认从大到小
//
extern void sort_insert_int(int a[], int len) {
    int i, j;
    for (i = 1; i < len; ++i) {
        int key = a[j = i];
        // 从小到大
        while (j > 0 && a[j - 1] < key) {
            a[j] = a[j - 1];
            --j;
        }
        a[j] = key;
    }
}

 

这时候有人就想了, 那数组是 double 的, 那怎么弄了. 也有一种解决方案

#define sort_insert(a, len) \
    _Generic(a
            , int *     : sort_insert_int
            , double *  : sort_insert_double
            , default   : sort_insert_default) (a, len)

 

是不是有所启发. 当然了. 对于上面是使用从大到小封装. 那如果需要从小到大呢. 可以这么做

static inline int _compare_2(const int left, const int key) {
    return left - key;
} 

extern void sort_insert_2(int a[], int len,
    int compare(const int left, const int key)) {
    int i, j;
    for (i = 1; i < len; ++i) {
        int key = a[j = i];
        while (j > 0 && compare(a[j - 1], key) < 0) {
            a[j] = a[j - 1];
            --j;
        }
        a[j] = key;
    }
}

单独把比较的行为抽象出来, 注册进去. 是不是很开心.

 

前言 - 细致一点封装

  也许到这里会更开心. 既然能通过高科技泛型模拟出来. 那我们不也可以使用旧科技弄弄.

typedef int (* compare_f)(const void * left, const void * key);

static inline int _compare_3(const void * left, const void * key) {
    return *(int *)left - *(int *)key;
}

extern void sort_insert_3_(void * data, size_t ez, int len, compare_f compare) {
    char * a = data;
    void * key;
    int i, j;

    if ((key = malloc(ez)) == NULL)
        return;

    for (i = 1; i < len; ++i) {
        memcpy(key, &a[i * ez], ez);
        for (j = i; j > 0 && compare(&a[(j - 1) * ez], key) < 0; --j)
            memcpy(&a[j * ez], &a[(j - 1) * ez], ez);
        if (j != i)
            memcpy(&a[j * ez], key, ez);
    }

    free(key);
}

#define sort_insert_3(a, len, compare) \
    sort_insert_3_(a, sizeof(*(a)), len, (compare_f)compare)

是不是很巧妙, 一切都编程 void * 了.  当然了如果使用 C99 版本以上, 或者说用高版本的 GCC.

可以写的更好.

extern void sort_insert_4_(void * data, size_t ez, int len, compare_f compare) {
    char * a = data;
    char key[ez];
    int i, j;

    for (i = 1; i < len; ++i) {
        memcpy(key, &a[i * ez], ez);
        for (j = i; j > 0 && compare(&a[(j - 1) * ez], key) < 0; --j)
            memcpy(&a[j * ez], &a[(j - 1) * ez], ez);
        if (j != i)
            memcpy(&a[j * ez], key, ez);
    }
}

 

这里用了 C99 的 VLA 特性. 不知道细心的同学是否和思考. GCC 是怎么实现 VLA 可变长数组呢.

拨开云雾见青天, 我们不妨来个实验验证一哈. 看下面测试代码

#include <stdio.h>
#include <stdlib.h>

/*
 * file : vla.c
 * make : gcc -g -Wall -O2 -o vla.exe vla.c
 * 
 */
int main(int argc, char * argv[]) {
    char a[10];
    int b = 7;
    char c[b];
    int * d = malloc(sizeof(int));
    if (d == NULL)
        exit(EXIT_FAILURE);
    *d = 1000;
    char e[*d];

    printf("%p : char a[10]\n", a);
    printf("%p : int b\n", &b);
    printf("%p : char c[b]\n", c);
    printf("%p : int * d\n", d);
    printf("%p : char e[*d]\n", e);

    free(d);
    return EXIT_SUCCESS;
}

最终输出结果是

通过地址匹配对于 vla 可变数组, GCC是放在栈上的. 所有可以预测, 当可变数组大小太大. 函数栈会直接崩溃.

如果你有想法, 那么就去实现它, 多数简单我们还是能独立捉出来滴~~

 

正文 - 通用套路

  还有一种套路, 采用宏模板去实现, 简单提一下这个思路. 看下面代码

#if defined(__T)

#define __f(type) sort_insert_##type
#define __F(type) __f(type)

static void __F(__T) (__T a[], int len, int compare(const __T left, const __T key)) {
    int i, j;
    for (i = 1; i < (int)len; ++i) {
        __T key = a[j = i];
        while (j > 0 && compare(a[j - 1], key) < 0) {
            a[j] = a[j - 1];
            --j;
        }
        a[j] = key;
    }
}

#endif

一般而言上面模板函数都会封装在一个局部文件中使用的时候也很方便, 例如下面这样

// 定义部分, 声明和定义分离可以自己搞
#undef  __T
#define __T int
#include "sort_insert.c"

// 使用部分和普通函数无异
sort_insert_int(a, LEN(a), _compare_2);

 

当然除了上面一种基于文件的函数模板. 还用一种纯基于函数宏的函数模板实现.

#define sort_insert_definition(T) \
    static void sort_insert_##T (T a[], int len, int compare(const T left, const T key)) { \
        int i, j; \
        for (i = 1; i < len; ++i) { \
            T key = a[j = i]; \
            while (j > 0 && compare(a[j - 1], key) < 0) { \
                a[j] = a[j - 1]; \
                --j; \
            } \
            a[j] = key; \
        } \
    }

sort_insert_definition(int)

使用还是一样  sort_insert_int(a, LEN(a), _compare_2); 跑起来. 第一种函数模板, 在嵌入式用的多.

第二种在实战中用的多, 对于处理各种算法相关的代码很普遍. 到这里应该可以理解上面那些

C 封装中一个小函数存在的套路.

 

后记 - 路越来越窄, 越来越清晰

      错误是可以纠正的, 欢迎指正 ~ 表示感谢哈哈

      <<啥时候成为津门第一呀>> : http://music.163.com/#/mv?id=197148

     

      对不起 ~ 什么都明白的好晚 ~

文章评论

10个调试和排错的小建议
10个调试和排错的小建议
程序员眼里IE浏览器是什么样的
程序员眼里IE浏览器是什么样的
每天工作4小时的程序员
每天工作4小时的程序员
我的丈夫是个程序员
我的丈夫是个程序员
那些争议最大的编程观点
那些争议最大的编程观点
如何成为一名黑客
如何成为一名黑客
Google伦敦新总部 犹如星级庄园
Google伦敦新总部 犹如星级庄园
老程序员的下场
老程序员的下场
2013年美国开发者薪资调查报告
2013年美国开发者薪资调查报告
为啥Android手机总会越用越慢?
为啥Android手机总会越用越慢?
写给自己也写给你 自己到底该何去何从
写给自己也写给你 自己到底该何去何从
Web开发者需具备的8个好习惯
Web开发者需具备的8个好习惯
编程语言是女人
编程语言是女人
那些性感的让人尖叫的程序员
那些性感的让人尖叫的程序员
10个帮程序员减压放松的网站
10个帮程序员减压放松的网站
“肮脏的”IT工作排行榜
“肮脏的”IT工作排行榜
聊聊HTTPS和SSL/TLS协议
聊聊HTTPS和SSL/TLS协议
初级 vs 高级开发者 哪个性价比更高?
初级 vs 高级开发者 哪个性价比更高?
Java程序员必看电影
Java程序员必看电影
2013年中国软件开发者薪资调查报告
2013年中国软件开发者薪资调查报告
程序猿的崛起——Growth Hacker
程序猿的崛起——Growth Hacker
60个开发者不容错过的免费资源库
60个开发者不容错过的免费资源库
老美怎么看待阿里赴美上市
老美怎么看待阿里赴美上市
当下全球最炙手可热的八位少年创业者
当下全球最炙手可热的八位少年创业者
不懂技术不要对懂技术的人说这很容易实现
不懂技术不要对懂技术的人说这很容易实现
团队中“技术大拿”并非越多越好
团队中“技术大拿”并非越多越好
我跳槽是因为他们的显示器更大
我跳槽是因为他们的显示器更大
程序员必看的十大电影
程序员必看的十大电影
程序员应该关注的一些事儿
程序员应该关注的一些事儿
做程序猿的老婆应该注意的一些事情
做程序猿的老婆应该注意的一些事情
Java 与 .NET 的平台发展之争
Java 与 .NET 的平台发展之争
十大编程算法助程序员走上高手之路
十大编程算法助程序员走上高手之路
我是如何打败拖延症的
我是如何打败拖延症的
程序员最害怕的5件事 你中招了吗?
程序员最害怕的5件事 你中招了吗?
总结2014中国互联网十大段子
总结2014中国互联网十大段子
看13位CEO、创始人和高管如何提高工作效率
看13位CEO、创始人和高管如何提高工作效率
程序员周末都喜欢做什么?
程序员周末都喜欢做什么?
如何区分一个程序员是“老手“还是“新手“?
如何区分一个程序员是“老手“还是“新手“?
程序员和编码员之间的区别
程序员和编码员之间的区别
程序员的一天:一寸光阴一寸金
程序员的一天:一寸光阴一寸金
Web开发人员为什么越来越懒了?
Web开发人员为什么越来越懒了?
亲爱的项目经理,我恨你
亲爱的项目经理,我恨你
科技史上最臭名昭著的13大罪犯
科技史上最臭名昭著的13大罪犯
鲜为人知的编程真相
鲜为人知的编程真相
什么才是优秀的用户界面设计
什么才是优秀的用户界面设计
 程序员的样子
程序员的样子
5款最佳正则表达式编辑调试器
5款最佳正则表达式编辑调试器
代码女神横空出世
代码女神横空出世
中美印日四国程序员比较
中美印日四国程序员比较
软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有