Neo

排序(2)冒泡排序

2016-10-01T00:00:00+00:00

排序(2)#

冒泡排序##

冒泡排序实际上是一个非常简单的排序算法，非常容易实现—-遍历文件，如果近邻两个元素大小顺序不对，就将两者交换，重复这样的操作直到整个文件排好序。如下用TypeScript做了一个简单的演示:代码地址。

以下是基于链表的c语言版本实现:

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

const int max = 100;

int get_random(){
        return (rand() % max);
}

void init_list(int a[],int len){
        for (int i = 0; i < len; i++) {
                a[i] = get_random();
        }
}

void swap(int * p1,int * p2){
        int p= *p1;
        *p1 = *p2;
        *p2 = p;
}


void print_list(int a[],int len){
        for (int i = 0; i<len; i++) {
                printf("%d ",a[i]);
        }
        printf("\n");
}

int main(int argc, char *argv[])
{
        int a[20];
        init_list(a,20);
        print_list(a,20);
        for (int i=0 ; i < 19; i++) {
                for (int j=19; j > i; j--) {
                       if(a[j-1] > a[j]){
                               swap(&a[j-1],&a[j]);
                       }
                }
              print_list(a,20);
        }
        return 0;
}

运行环境:ubuntu12.04

排序(1)

2016-05-01T00:00:00+00:00

#排序(1)#

##插入排序## 插入排序是一个对少量数据进行排序的有效算法。现实中最常见的插入排序的例子莫过于打扑克，整理手中的扑克。开始摸牌时，我们左手为空的，牌面朝下放在桌上。接着，一次从桌子上摸起一张牌，并将它插入左手正确的位置，并确保左手的牌从左到右是按照从小到大的顺序排列的。

如下用TypeScript做了一个简单的演示:代码地址。

以下是基于链表的c语言版本实现:

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


const int max = 100;
const int maxnode = 20;

typedef struct node_s{
        int value;
        struct node_s * next;
}node_t;

int get_random(){
        return (rand() % max);
}

int create_new_node_t(int v,node_t ** n){
        node_t * node = calloc(sizeof(node_t),1);
        node->value = v;
        node->next = NULL;
        *n = node;
        return 0;
}


void insert_node(node_t * h,node_t * newnode){
        if(h->next!=NULL){
                node_t * p = h->next;
                h->next = newnode;
                newnode->next = p;
        }else{
                h->next = newnode;
        }
}

void print_node_list(node_t * h){
        node_t * p = h->next;
        printf("list nodes:");
        while(p != NULL){
                printf("%d ",p->value);
                p = p->next;
        }
        printf("\n");
}

void free_node_list(node_t * h){
        node_t * p = h->next;
        node_t * q = NULL;
        while(p != NULL){
                q = p->next;
                free(p);
                p = q;
        }
}

void insertion_sort(node_t * h,node_t * n){
        int ibool = 0;
        node_t * p = h;
        node_t * q = p->next;
        while(q != NULL){
                if(q->value > n->value){
                        insert_node(p,n);
                        ibool = 1;
                        break;
                }
                p=q;
                q = q->next;
        }
        if(ibool < 1){
                p->next = n;
        }
}

int main(int argc, char *argv[])
{
        node_t h;
        node_t * p = NULL;
        node_t * q = NULL;
        int i = 0;
        h.next = NULL;
        while(i< maxnode){
                int r = get_random();
                create_new_node_t(r,&p);
                printf("insert node :% d\n",p->value);
                insertion_sort(&h,p);
                print_node_list(&h);
                i++;
        }
        free_node_list(&h);
        return 0;
}

运行环境:ubuntu12.04

参考文献:

«算法导论» 第二章 2.1节

sqlite嵌入式数据库C语言基本操作(2)

2016-03-10T00:00:00+00:00

事实上对于操作sqlite的其他语言，写一个统一的数据库操作模型是非常容易的，比如java，c#，这些语言支持垃圾回收，支持异常捕获，支持泛型，写起来就很容易。但是对于C语言，就得另当别论了，就拿查询操作来说，c语言没有泛型，不能返回统一的泛型列表，只能返回数据模型的链表结构。

但是得益于前面讲过的通用链表结构,我们可以尽可能的像其他语言一样封装一个通用的数据库操作模型。

回顾前面讲到的sqlite操作基本流程，查询流程是 1.打开数据库 2.准备好SQL语句。 3.绑定SQL语句参数 4.执行SQL语句 5.返回结果集，执行串链操作。 6.释放资源 7.关闭数据库句柄. 整体的流程不变，把不一样的部分抽象出来 —— 绑定参数，执行串链的过程抽象出来。

绑定参数，如

int bind_userinfo_t(sqlite3_stmt * stmt,int index, void * arg )

执行查询建链过程，如

int create_userinfo_T(sqlite3_stmt,void * arg)

然后在通用的数据库操作函数中传入函数指针，尽量的精简代码。下面是的dbhelper.h 和 dbhelper.c 抽象的一般数据库操作函数。

#ifndef _DBHELPER_H_
#define _DBHELPER_H_
#include <sqlite3.h> 

#define DB_SQL_MAX_LEN 1024
//执行没有返回的SQL语句
int db_nonquery_operator(const char *sqlstr,int (*bind)(sqlite3_stmt *,int index,void * arg),void *param);
//执行没有返回的SQL语句的多值传参
int db_nonquery_by_varpara(const char *sql,const char *fmt,...);
//执行没有返回的SQL语句
int db_nonquery_transaction(int (*exec_sqls)(sqlite3 *db,void * arg),void *arg);
//执行多值传参的查询语句
int db_query_by_varpara(const char *sql,int (*create)(sqlite3_stmt *stmt,void *arg),void *arg,const char *fmt,...);
//执行查询并返回查询结果集的条数
int db_query_count_result(const char *sql);
//对sqlite3_column_blob的二次封装
int db_stmt_get_blob(sqlite3_stmt *stmt,int index,unsigned char *out);
//对sqlite3_column_text的二次封装
int db_stmt_get_text(sqlite3_stmt *stmt,int index,char *out);
//对sqlite3_column_int的二次封装
int db_stmt_get_int(sqlite3_stmt *stmt,int index);
//对sqlite3_column_double的二次封装
double db_stmt_get_double(sqlite3_stmt *stmt,int index);

#endif

dbhelper.c:

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include "na_queue.h"
#include "dbhelper.h"

#define DB_NAME "test.db"

static pthread_mutex_t db_mutex_lock = PTHREAD_MUTEX_INITIALIZER;


static int db_bind_by_var(sqlite3_stmt *stmt,const char *fmt,va_list args)
{
	int len,npara=1;
	int ret = SQLITE_OK;
	if(fmt == NULL){
		return ret;
	}

   	for(;*fmt;++fmt){
		if(*fmt != '%')
			continue;
		++fmt;
		//get length
		len = 0;
		while(isdigit(*fmt)){
			len = len * 10 + (*fmt - '0');
			++fmt;
		}
		switch(*fmt){
		case 'd':
			ret = sqlite3_bind_int(stmt,npara,va_arg(args,int));
			break;
		case 's':
			{
			char *str = va_arg(args,char *);
			ret = sqlite3_bind_text(stmt,npara,str,strlen(str),NULL);
			}
			break;
		case 'x':
			{
			unsigned char *pdata;
			pdata = va_arg(args,char *);
			ret = sqlite3_bind_blob(stmt,npara,pdata,len,NULL);
		//	printf_phex("blob",pdata,len);
			}
			break;
		default:
			ret = SQLITE_ERROR;
			break;
		}
		++npara;
		if(ret)
			return ret;
	}	
	return ret;
}

/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  db_query_by_varpara
 *  Description:  数据库查询操作，可以带变参绑定
 *  @sql       :  sql 
 *  @create    :  取得数据并创建节点
 *  @arg       :  用户用于create的参数
 *  @fmt       :  格式字符串，%s string,%d int,%nx 长度为N的二进制串
 *  ...        :  变参
 *  Return     :  查询到数据的条数 
 * =====================================================================================
 */
int db_query_by_varpara(const char *sql,int (*create)(sqlite3_stmt *stmt,void *arg),void *arg,const char *fmt,...)
{
	sqlite3 *db = NULL;
	sqlite3_stmt *stmt = NULL;
	if(sql == NULL){
//		return SQLITE_ERROR;
		return 0;
	}
	pthread_mutex_lock(&db_mutex_lock);
	int rc = sqlite3_open(DB_NAME,&db);
	if(rc != SQLITE_OK){
		printf("open database failed,rc=%d",rc);
		pthread_mutex_unlock(&db_mutex_lock);
		return 0;
	}

	rc = sqlite3_prepare(db,sql,-1,&stmt,NULL);
	if(rc != SQLITE_OK){
		printf("database prepare fail,rc=%d",rc);
		goto DB_EXEC_FAIL;
	}

	if(fmt){
		va_list args;
		va_start(args,fmt);
		rc = db_bind_by_var(stmt,fmt,args);
		va_end(args);
		if(rc){
			printf("database bind fail,rc=%d",rc);
			goto DB_EXEC_FAIL;
		}
	}

	if(create){
		rc = (*create)(stmt,arg);
	}else{
		rc = (sqlite3_step(stmt),0);
	}
	sqlite3_finalize(stmt);
	goto DB_EXEC_OK;
DB_EXEC_FAIL:
	printf("db operator failed,rc=%d",rc);
	rc = 0;
DB_EXEC_OK:
	sqlite3_close(db);
	pthread_mutex_unlock(&db_mutex_lock);
	return rc;
}




/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  db_exec_noquery
 *  Description:  执行非查询操作 
 *  @sqlstr    :  sql,多条语句由';'分开
 *  @bind      :  绑定sql中的未知变量操作 
 *  @param     :  绑定中的参数
 *  @bind.index:  sql语句序号 
 *  Return     :  0 or error
 * =====================================================================================
 */
int db_nonquery_operator(const char *sqlstr,int (*bind)(sqlite3_stmt *,int index,void * arg),void *param)
{
	sqlite3 *db = NULL;
	sqlite3_stmt *stmt = NULL;
//	char *emsg = NULL;
	if(sqlstr == NULL){
		return SQLITE_ERROR;
	}
	pthread_mutex_lock(&db_mutex_lock);
	int rc = sqlite3_open(DB_NAME,&db);
	if(rc != SQLITE_OK){
		printf("open database failed,rc=%d",rc);
		pthread_mutex_unlock(&db_mutex_lock);
		return rc;
	}
	rc = sqlite3_exec(db,"begin transaction",0,0,NULL);
	if(rc != SQLITE_OK){
		printf("begin transaction:ret=%d",rc);
		goto DB_BEGIN_FAIL;
	}
	char sql[DB_SQL_MAX_LEN];
	int index = 0,offset=0,n=0;
	while(sqlstr[index] != 0){
		offset = 0;
		do{
			if(offset >= DB_SQL_MAX_LEN){
				printf("sql is too long,(%d)",offset);
				rc = SQLITE_ERROR;
				goto DB_EXEC_FAIL;
			}
			if((sqlstr[index] != ';') && (sqlstr[index] != 0)){
				sql[offset++] = sqlstr[index++];
			}else{
				sql[offset] = '\0';
				if(sqlstr[index] == ';') index++;
				n++;
				break;
			}
		}while(1);
		printf("sql:%s",sql);
		rc = sqlite3_prepare(db,sql,-1,&stmt,NULL);
		if(rc != SQLITE_OK){
			printf("prepare,error,%d",rc);
			goto DB_EXEC_FAIL;
		}
		if(bind){
			rc = (*bind)(stmt,n,param);
		}else{
			rc = sqlite3_step(stmt);
		}
		sqlite3_finalize(stmt);
		if((rc != SQLITE_OK) && (rc != SQLITE_DONE)){
			printf("bind");
			goto DB_EXEC_FAIL;
		}
	}
	rc = sqlite3_exec(db,"commit transaction",0,0,NULL);
	if(rc){
		printf("commit transaction:%d",rc);
		goto DB_EXEC_FAIL;
	}
	goto DB_EXEC_OK;
DB_EXEC_FAIL:
	if(sqlite3_exec(db,"rollback transaction",0,0,NULL)){
		printf("rollback transaction error");
	}
DB_BEGIN_FAIL:
//	sqlite3_free(emsg);
	printf("db operator failed,rc=%d",rc);
DB_EXEC_OK:
	sqlite3_close(db);
	pthread_mutex_unlock(&db_mutex_lock);
	return rc;
}

int db_nonquery_by_varpara(const char *sql,const char *fmt,...)
{
	sqlite3 *db = NULL;
	sqlite3_stmt *stmt = NULL;
	if(sql == NULL){
		return SQLITE_ERROR;
	}
	pthread_mutex_lock(&db_mutex_lock);
	int rc = sqlite3_open(DB_NAME,&db);
	if(rc != SQLITE_OK){
		printf("open database failed,rc=%d",rc);
		pthread_mutex_unlock(&db_mutex_lock);
		return rc;
	}
	printf("sql:%s",sql);
	rc = sqlite3_prepare(db,sql,-1,&stmt,NULL);
	if(rc != SQLITE_OK){
		printf("prepare,");
		goto DB_EXEC_FAIL;
	}
	if(fmt){
		va_list args;
		va_start(args,fmt);
		rc = db_bind_by_var(stmt,fmt,args);
		va_end(args);
		if(rc){
			goto DB_EXEC_FAIL;
		}
	}
	rc = sqlite3_step(stmt);
	sqlite3_finalize(stmt);
	if((rc != SQLITE_OK) && (rc != SQLITE_DONE)){
		printf("bind");
		goto DB_EXEC_FAIL;
	}
	rc = 0;
	goto DB_EXEC_OK;
DB_EXEC_FAIL:
DB_BEGIN_FAIL:
	printf("db operator failed,rc=%d",rc);
DB_EXEC_OK:
	sqlite3_close(db);
	pthread_mutex_unlock(&db_mutex_lock);
	return rc;
}


int db_nonquery_transaction(int (*exec_sqls)(sqlite3 *db,void * arg),void *arg)
{
	sqlite3 *db = NULL;
	sqlite3_stmt *stmt = NULL;
//	char *emsg = NULL;
	pthread_mutex_lock(&db_mutex_lock);
	int rc = sqlite3_open(DB_NAME,&db);
	if(rc != SQLITE_OK){
		printf("open database failed,rc=%d",rc);
		pthread_mutex_unlock(&db_mutex_lock);
		return rc;
	}
	rc = sqlite3_exec(db,"begin transaction",0,0,NULL);
	if(rc != SQLITE_OK){
		printf("begin transaction:%d",rc);
		goto DB_BEGIN_FAIL;
	}
	
	if(exec_sqls){
		rc = (*exec_sqls)(db,arg);
	}else{
		rc = SQLITE_ERROR;
	}
	if((rc != SQLITE_OK) && (rc != SQLITE_DONE)){
		printf("prepare,error,%d",rc);
		goto DB_EXEC_FAIL;
	}
	
	rc = sqlite3_exec(db,"commit transaction",0,0,NULL);
	if(rc){
		printf("commit transaction:%d",rc);
		goto DB_EXEC_FAIL;
	}
	goto DB_EXEC_OK;
DB_EXEC_FAIL:
	if(sqlite3_exec(db,"rollback transaction",0,0,NULL)){
		printf("rollback transaction:error");
	}
DB_BEGIN_FAIL:
//	sqlite3_free(emsg);
	printf("db operator failed,rc=%d",rc);
DB_EXEC_OK:
	sqlite3_close(db);
	pthread_mutex_unlock(&db_mutex_lock);
	return rc;
}



static int db_get_count(sqlite3_stmt *stmt,void *arg)
{
	int ret,*count=arg;
	ret = sqlite3_step(stmt);
	if(ret != SQLITE_ROW)
		return SQLITE_EMPTY;
	*count = db_stmt_get_int(stmt,0);
	return SQLITE_OK;
}


/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  db_query_count_result
 *  Description:  查询计数结果的第一列第一行，其它忽略
 *  @sql       :  查询计数的SQL语句
 *  Return     :  查询到计数返回计数，否则一律返回0 
 * =====================================================================================
 */
int db_query_count_result(const char *sql)
{
	int ret,count=0;
	ret = db_query_by_varpara(sql,db_get_count,&count,NULL);
	if(ret == SQLITE_OK)
		return count;
	return 0;
}


int db_stmt_get_blob(sqlite3_stmt *stmt,int index,unsigned char *out)
{
	const char *pdata = sqlite3_column_blob(stmt,index);
	int len = sqlite3_column_bytes(stmt,index);
	if(pdata){
		memcpy(out,pdata,len);
		return len;
	}
	return 0;
}

int db_stmt_get_text(sqlite3_stmt *stmt,int index,char *out)
{
	const unsigned char *pdata = sqlite3_column_text(stmt,index);
	if(pdata){
		int len = strlen(pdata);
		strncpy(out,pdata,len);
		return len;
	}
	return 0;
}

int db_stmt_get_int(sqlite3_stmt *stmt,int index)
{
	return sqlite3_column_int(stmt,index);
}

double db_stmt_get_double(sqlite3_stmt *stmt,int index)
{
	return sqlite3_column_double(stmt,index);
}

对以上的代码做一下说明: test.db为数据库文件为了处理多线程，在对数据库进行操作的时候加了锁。

现在按照通用数据库操作方式重写上次的代码，查询和增加操作。

首先重写数据模型：

typedef struct userinfo_s{
	int userid;
    char username[32];
    na_queue_t queue;
}userinfo_t;

释放函数链表函数：

 void free_userinfo_t(na_queue_t *h){
    na_queue_t *head = h,*pos,*n;
    userinfo_t *p = NULL;
    na_queue_for_each_safe(pos,n,head){
        p = na_queue_data(pos,userinfo_t,queue);
        free(p);
    }
    na_queue_init(head);
 }
 

绑定函数，用于绑定insert的插入函数

int bind_userinfo_t(sqlite3_stmt * stmt,int index,void * arg){
        int rc;
        userinfo_t * param = arg;
        sqlite3_bind_int(stmt,1,param->userid);
        sqlite3_bind_text(stmt,2,param->username,strlen(param->username),NULL);
        rc = sqlite3_step(stmt);
        if (rc != SQLITE_DONE)
                return rc;
        return SQLITE_OK;
}

查询操作需要的串链函数：

int create_userinfo_t(sqlite3_stmt * stmt,void * arg){
        na_queue_t * h = arg;
        na_queue_init(h);
        userinfo_t * u;
        int ret,count = 0;
        ret = sqlite3_step(stmt);
        if(ret != SQLITE_ROW){
                return 0;
        }
        do
        {
                u = calloc(sizeof(userinfo_t),1);
                if(!u){
                        goto CREATE_USERINFO_FAIL;
                }
                u->userid = db_stmt_get_int(stmt,0);
                db_stmt_get_text(stmt,1,u->username);
                na_queue_insert_tail(h,&(u->queue));
                count ++;
        } while ((ret = sqlite3_step(stmt)) == SQLITE_ROW);
        return count;
CREATE_USERINFO_FAIL:
        free_userinfo_t(h);
        return 0;
}

基本的对数据表的操作就是按照这种方式来抽象代码,现在我们来按照这种方式来写一段测试代码:

//打印用户信息
void printusers(na_queue_t *h){
        userinfo_t * q=NULL;
        na_queue_foreach(q,h,userinfo_t,queue){
                printf("userid:%d username:%s\n",q->userid,q->username);
        }
}

//得到所以用户信息
int get_all_userinfo(na_queue_t * h){
        return db_query_by_varpara("select * from userinfo;",create_userinfo_t,h,NULL);
}

//添加一个用户信息
int add_a_userinfo(userinfo_t * u){
        return db_nonquery_operator("insert into userinfo(userid,username) values (?,?)",bind_userinfo_t,u);
}

int main(int argc, char *argv[])
{
        printf("test get all userinfo\n");
        na_queue_t h;
        int ret = get_all_userinfo(&h);
        printusers(&h);
        free_userinfo_t(&h);
        printf("test add userinfo");
        userinfo_t newuser;
        newuser.userid = 7;
        strncpy(newuser.username,"White",10);
        add_a_userinfo(&newuser);
        get_all_userinfo(&h);
        printusers(&h);
        free_userinfo_t(&h);
        return 0;
}

我们还是上一次的数据库来接着运行，输出：

test get all userinfo userid:1 username:Alex userid:2 username:Neo userid:3 username:Allan userid:4 username:coby userid:5 username:micheal test add userinfo userid:1 username:Alex userid:2 username:Neo userid:3 username:Allan userid:4 username:coby userid:5 username:micheal userid:7 username:White

以上就是一个简单的C语言对SQLITE数据库操作的封装，事实上我们已经把它用在了我们的生产环境，不过生产环境版本相对于这个版本要复杂一点，加入的日志模块，线程模块，而且现在还在继续进化中，但是原理就是这样了，实现上大同小异而已。实例也同样只是写了查询和插入，至于其他操作就有读者自己在这个实例上去添加了。SQLITE小型数据库相对与其他Oracle等其他大型数据库而言，他对SQL的支持没有他们强大，但是对于小型嵌入式系统已经足够了，他们之间的差异只有改天再补充了。今天就到这了。

sqlite嵌入式数据库C语言基本操作(1)

2016-03-02T00:00:00+00:00

** sqlite**是应用最广泛的嵌入式数据库，没有之一，其详细的介绍参见官方网站（http://sqlite.org）.最新的版本是3.12.2. C语言的API函数列表见官网SQLite C Interface.这里对一些基本的函数做一个简单的说明。 sqlite3_open: 打开数据库文件. sqlite3_close: 关闭数据库。 sqlite3_prepare : 编译SQL,准备语句。 sqlite3_step: sqlite3_stmt的方式执行SQL语句。 sqlite3_exec: 执行SQL语句。 sqlite3_finalize: 释放 sqlite3_stmt资源。 sqlite3_bind_int: 绑定SQL语句中int参数。 sqlite3_bind_text: 绑定SQL语句中的字符串参数。 sqlite3_bind_blob: 绑定SQL语句中的二进制参数。 sqlite3_column_int: 遍历数据集，得到一行数据中某列的int值。 sqlite3_column_text: 遍历数据集，得到一行数据某列的字符串值。 sqlite3_column_blob: 遍历数据集，得到一行数据某列的二进制值。 ……

以下这个例子做一个简单的insert，和 select 的例子，来讲sqlite3数据库的简单数据操作。首先建一张简单的表，并插入初始化数据。

 create table userinfo (
 userid integer,
 username char(32),
 PRIMARY KEY (userid)
 );
 insert into userinfo (userid,username) values (1,"Alex");
 insert into userinfo (userid,username) values (2,"Allan");
 insert into userinfo (userid,username) values (3,"Blizzard");
 insert into userinfo (userid,username) values (4,"Bob");
 

建立对应的数据模型.

typedef struct userinfo_s {
	int userid;     //用户编号
    char username[33];		//用户姓名
    struct userinfo_s * next; //下一个用户
} userinfo_t;

得到所有Users的函数

 int get_all_userinfos(userinfo_t u){
 	char sql[512] = "select * from userinfo;"; //sql语句
    sqlite3 * db = NULL;
    sqlite3_stmt * stmt = NULL;
    int ret_open = sqlite3_open("test.db",&db); //打开数据库文件
    if (ret_open != SQLITE_OK){
    	printf("open test.db fail\n");
        return -1;
    }
     int ret = sqlite3_prepare(db,sql,-1,&stmt,NULL); //准备好SQL语句
        if (ret != SQLITE_OK){
                printf("prepare fail \n");
                return ret;
        }
        ret = sqlite3_step(stmt); //执行SQL
        int count = 0;
        if(ret != SQLITE_ROW){		//返回有数据
                return 0;
        }else{
                userinfo_t * p = u; //建立链表
                do{
                        userinfo_t * user = calloc(sizeof(userinfo_t),1);
                        user->userid = sqlite3_column_int(stmt,0); //得到USerid   注意get的初始值为index为0
                        const char * name = sqlite3_column_text(stmt,1); //得到用户名
                        if (name){
                                int len = strlen(name);
                                strncpy(user->username,name,len);
                        }
                        user->next = NULL;
                        p->next = user; //串联 建立一个单项链表
                        p = p->next;
                        count ++;
                }while((ret = sqlite3_step(stmt))==SQLITE_ROW); //取值下一个
        }
        sqlite3_finalize(stmt); //释放资源 stmt
        sqlite3_close(db); //关闭数据库句柄
        return count;
 }
 

insert操作函数：

int insert_userinfo_t(userinfo_t * u){
        char sql[512] = "insert into userinfo (userid,username) values (?,?)"; //插入数据库语句
        sqlite3 *db = NULL;
        sqlite3_stmt * stmt = NULL;
        int ret_open = sqlite3_open("test.db",&db); //打开数据库
        if(ret_open !=SQLITE_OK){
                printf("open test.db fail\n");
                return -1;
        }
        int ret = sqlite3_prepare(db,sql,-1,&stmt,NULL); //准备语句
        if (ret != SQLITE_OK){
                printf("prepare fail \n");
                return ret;
        }
        sqlite3_bind_int(stmt,1,u->userid); //绑定参数, 注意绑定参数的初始index值为1
        sqlite3_bind_text(stmt,2,u->username,32,NULL);
        ret = sqlite3_step(stmt); //执行语句
        if(ret == SQLITE_DONE){   //执行结果
                ret = SQLITE_OK;
        }
        sqlite3_finalize(stmt); //释放资源
        sqlite3_close(db); //关闭数据库
        return ret;
}

测试代码:

	
void test_get_all_userinfos(){
        userinfo_t u;
        int count = get_all_userinfos(&u);
        userinfo_t * p = u.next;
        userinfo_t * q = p;
        printf("count:%d\n",count);
        while(p){
                printf("userid:%d username:%s \n",p->userid,p->username);
                p = p->next;
        }
        free_userinfo_t(&u);
}

void test_insert_into_userinfo_t(){
        userinfo_t new_user;
        new_user.userid = 5;
        char new_name[33]= "micheal";
        strncpy(new_user.username,new_name,32);
        int ret= insert_userinfo_t(&new_user);
        printf("ret = %d\n",ret);
}

输出 count:4 userid:1 username:Alex userid:2 username:Allan userid:3 username:Blizzard userid:4 username:Bob ret = 1 count:5 userid:1 username:Alex userid:2 username:Allan userid:3 username:Blizzard userid:4 username:Bob userid:5 username:micheal

gcc编译最后记得加上 -lsqlite3 本文只是很初略的介绍了sqlite嵌入式数据库的基本操作，初略到甚至例程只讲了两个操作，增加和查询，修改和删除都没有讲到，不过看了增加操作，修改和删除操作就很容易实现了。写这篇文章目的只是一个想讲一个过程，一个操作数据库的基本过程

####一个数据库操作流程 1 打开数据库 2 编译准备SQL语句 3 绑定SQL语句参数 4 执行SQL语句 5 关闭释放Statement 6 关闭数据库

当然也只是一个初略的流程，对于数据库操作失败的流程处理也没有。不过了解上面这个初略的流程就可以了。更深入的讲解请参见下篇:[sqlite嵌入式数据库C语言基本操作(2)]

参考文献: sqlite官方网站:sqlite.org 运行环境:ubuntu12.04 LTS

链表(3)

2016-01-20T00:00:00+00:00

###链表(3)### 链表(2)简单讲述了一种Linux通用的链表结构，准确的说一个双向链表描述的双端队列，其实nginx中单向链表ngx_list_t和双向链表ngx_queue_t是分开定义的。我们在这里只讲双向队列的原因是因为实际项目中只用到了双向链表。

nginx中关于ngx_queue_t的典型应用是在其连接池中.作为Web服务器,nginx会处理大量的socket连接，为了提高并发处理链接的能力，nginx引入了连接池（参见ngx_connections.h和ngx_connection.c），其实现这个连接池也用到了一个技巧—静态链表.

我们知道线性表分为顺序分配和链接分配，典型的简单的例子就是数组和链表。数组是顺序分配，连续的在内存中排列着有限个结点。链表是链接分配的，相对与数组，链表意味着离散，无限个结点。

静态链表是既是链表也是数组，其实现就是将一个数组中的元素串成链表中的节点。其继承了链表和数组的优点，也继承了链表和数组的缺点。首先说优点，不管链表的串链顺序是怎样的，其结点在物理上是连续的，因为其本身就是数组，内存分配上不会出现碎片化，而且涉及到队列的push和pop操作不会设计到资源的申请与释放，只是一个链表操作而已，所以非常的高效。而缺点就是其长度是固定的，在初始化的时候就要充分考虑到资源的大小。所以这种链表结构特别适合于像连接池这样的需要频繁高效的得到资源与释放资源的情况。

如果对静态链表应用敢兴趣，可以看看nginx的连接池实现，我在这里就不准备Demo了，只是讲到链表多啰嗦几句。 nginx之所以能处理高并发，高性能，不光其应用了epoll模式这么简单，其代码中用到了很多的技巧，建议Linux下从事C语言应用编程的程序员都可以学习一下高手的代码，无论是架构，项目的模块化，还是编程技巧，都会很有收获的。

参考文献:

«计算机程序设计艺术» 卷一基本算法（第三版）
《深入理解Nginx》模块化开发与架构解析
《算法导论》

链表(2)

2016-01-03T00:00:00+00:00

##链表(2)##

我们在链表1中探讨了链表的一些最基本最简单的一些用法，只能用来讲讲链表操作的基本原理，不具有通用性。

事实上，我们在实际的项目中用的是在nginx内核中的一种通用的循环链表，其完全是由C语言的宏来定义的，设计非常的简洁巧妙，用在生产环境非常的健壮稳固。

在讲通用链表之前先讲一个宏:offsetof()

size_t offsetof(structName, memberName);

其表示为某结构体成员相对于其所在结构体的中偏移量。通用链表的实现就依赖于这个宏实现的。

下面来介绍nginx通用双向链表的结构体定义

typedef struct ngx_queue_s  ngx_queue_t;

struct ngx_queue_s {

    ngx_queue_t  *prev;

    ngx_queue_t  *next;

};

其定义非常的简单，仅仅是两个指向前节点和后节点的指针。ngx_queue_t 作为结构体的子成员，如：

struct userinfo{

	char * firstname;

    char * lastname;

    int age;

    int sex;

	ngx_queue_t queue;

}

所有关于链表的操作，都是对ngx_queue_t的操作，当我们要取得userinfo结构体地址时，就可以用上面的offsetof宏,根据queue的地址来取得了，理论上来说,一个ngx_queue_t的链表可以串起包含有ngx_queue_t的任意结构体类型，但是建议还是像C++或者java,csharp的泛型一样，一个链表中只包含一种结构体类型。

实际项目中，我们对其进行重新命名，并进行了封装，详见源码目录下的core/na_queue.h

其具体代码如下:

/*

 * Copyright(C) Neo

 * Thu Mar 28 11:30:44 2013

 * 对列定义（双向队列,环形队列） 参考nigix队列定义，以及Linux内核队列定义

 */

#ifndef _NA_QUEUE_H_

#define _NA_QUEUE_H_

#include "na_core.h"

typedef struct na_queue_s na_queue_t;

struct na_queue_s {

  na_queue_t * prev;

  na_queue_t * next;

};

/* 初始化队列 */

#define na_queue_init(q)                      \

  (q)->prev = (q);        \

  (q)->next = (q)

/* 判断队列是否为空 */

#define na_queue_empty(h) \

  ((h) == (h)->prev)

/* 从头插入节点 */

#define na_queue_insert_head(h,x)     \

  (x)->next = (h)->next;              \

  (x)->next->prev = (x);              \

  (x)->prev = (h);                    \

  (h)->next = (x)

#define na_queue_insert_after na_queue_insert_head

/* 从末尾插入节点 */

#define na_queue_insert_tail(h,x)      \

  (x)->prev = (h)->prev;               \

  (x)->prev->next = x;                 \

  (x)->next = h;                       \

  (h)->prev = x 

/* 头指针对应的头节点 */

#define na_queue_head(h) (h)->next

/* 最后一个节点 */

#define na_queue_last(h) (h)->prev

#define na_queue_sentinel(h) (h)

/*下一个节点*/

#define na_queue_next(q) (q)->next

/* 前一个节点 */

#define na_queue_prev(q) (q)->prev

/* 移除一个节点 */

#define na_queue_remove(x)             \

  (x)->next->prev = (x)->prev;         \

  (x)->prev->next = (x)->next;         \

  (x)->prev = NULL;                    \

  (x)->next = NULL

/* 切分一个队列

 * h 头指针

 * q 需要拆分的头指针

 * n 拆分完成后另外一个队列的头指针

 */

#define na_queue_split(h,q,n)           \

    (n)->prev = (h)->prev;              \

    (n)->prev->next = n;                \

    (n)->next = q;                      \

    (h)->prev = (q)->prev;              \

    (h)->prev->next = h;                \

    (q)->prev = n;

/* 合并两个队列 */

#define na_queue_add(h,n)               \

  (h)->prev->next = (n)->next;          \

  (n)->next->prev = (h)->prev;          \

  (h)->prev = (n)->prev;                \

  (h)->prev->next = (h);

/* 根据队列指针，得到包涵此队列指针的结构体

 * q 队列指针

 * type 返回的数据类型

 * link 数据项中对应的队列项名字

 */

#define na_queue_data(q, type, link)   \

    (type *) ((u_char *) q - offsetof(type, link))

/* 查找中间节点 */

na_queue_t *

na_queue_middle(na_queue_t * queue);

/* 对队列排序 */

void na_queue_sort(na_queue_t *queue,int (*cmp)(const na_queue_t *, const na_queue_t *));

/*遍历队列中节点的数据

 *q:传入的包含队列类型的结构体指针

 *s:队列的哨兵指针

 *type:包含队列的结构体类型

 *link:队列在结构体中的名字

*/

#define na_queue_foreach(q,s,type,link)          \

  na_queue_t * _head_ =NULL;                         \

  for(_head_=na_queue_head(s),q=na_queue_data(_head_,type,link);_head_!=s;_head_=na_queue_next(_head_),q=na_queue_data(_head_,type,link))

// add by hc

#define NA_QUEUE_INIT(name) {&(name),&(name)}

#define na_queue_is_last(head,node) ((node)->next == (head))

#define na_queue_for_each(pos,head) \

	for(pos = (head)->next;pos != head;pos = pos->next)

#define na_queue_for_each_safe(pos,n,head) \

	for(pos = (head)->next,n = pos->next;pos != (head);pos = n,n = pos->next)

#endif /* _NA_QUEUE_H_ */

其链表的操作

函数名

参数说明

函数执行意义

|——–|——–|———|

na_queue_init

哨兵节点

初始化链表的哨兵节点

na_queue_empty

同上

判断链表是否为空

na_queue_insert_head

在表头插入节点

na_queue_insert_after

在表尾插入节点

na_queue_head

取得链表表头

na_queue_last

取得表尾

na_queue_sentinel

取得哨兵节点

na_queue_next

取得下一个节点

na_queue_prev

取得前一个节点

na_queue_remove

移除一个节点

na_queue_split

拆分一个链表

na_queue_add

合并一个链表

na_queue_data

q 队列指针 type 返回的数据类型 link 数据项中对应的队列项名字

根据队列指针，得到包涵此队列指针的结构体

na_queue_middle

查找中间节点

na_queue_sort

对队列排序

na_queue_foreach

q:传入的包含队列类型的结构体指针 s:队列的哨兵指针 type:包含队列的结构体类型 link:队列在结构体中的名字

遍历队列中节点的数据

na_queue_for_each_safe

安全遍历队列中节点的数据

其他参数说明见源码说明,

这里重点讲两个宏 na_queue_date 和 ** na_queue_foreach **

** na_queue_date ** 是最上面offsetof宏的应用，功能是取得包含链表指针的结构体的地址。

** na_queue_foreach** 是遍历队列中的所有的节点

下面通过一个简单的插入排序来展示链表的用法:

#include <stdio.h>

#include <stdlib.h>

#include "na_queue.h"

#include <time.h>

typedef struct  number_s number_t;

typedef unsigned char u_char;

struct number_s{

        int value;

        na_queue_t queue;

};

//根据一个int值新建一个节点

number_t *

new_number_t(int v){

        number_t * n = calloc(sizeof(number_t),1);

        n->value = v;

        return n;

}

//释放一个number_t的链表中所有节点

void free_number_t(na_queue_t * h){

        na_queue_t * p = h->next;

        while(p!=h){

                na_queue_remove(p);

                number_t* q =na_queue_data(p,number_t,queue);

                free(q);

                p = h->next;

        }

}

//打印一个链表的所有节点值

void

print_queue(na_queue_t * h){

        na_queue_t * p = h->next;

        while(p!=h){

                number_t * q = na_queue_data(p,number_t,queue);

                printf("%d ",q->value);

                p=p->next;

        }

        printf("\n");

}

//在链表中插入一个值，使其按照从小到大顺序排列

void

insert_node(na_queue_t * h,int v){

        number_t * n= new_number_t(v);

        if(na_queue_empty(h)){

               na_queue_insert_tail(h,&n->queue);

               return;

        }

        na_queue_t * p = h->next;

        while(p!=h){

               number_t * num = na_queue_data(p,number_t,queue);

               if(num->value > v){

                       na_queue_t* q = na_queue_prev(p);

                       na_queue_t* c = &n->queue;

                       na_queue_next(q) = c;

                       na_queue_next(c) = p;

                       na_queue_prev(c) = q;

                       na_queue_prev(p) = c;

                       return;

               }

               p = na_queue_next(p);

        }

        na_queue_insert_tail(h,&n->queue);

}

//得到一个随机数

int get_random(){

        srand(time(0));

        return rand()/100000000;

}

int main(int argc, char *argv[])

{

        na_queue_t h;

        na_queue_init(&h);

        int i;

        for (i = 0; i < 10; i++) {

                int r = get_random();

                printf("add number:%d\n",r);

                insert_node(&h,r);

                print_queue(&h);

                sleep(1);

        }

        free_number_t(&h);

        return 0;

}

测试时一段插入排序程序,输出如下:

add number:10

add number:18

10 18

add number:4

4 10 18

add number:1

1 4 10 18

add number:20

1 4 10 18 20

add number:17

1 4 10 17 18 20

add number:3

1 3 4 10 17 18 20

add number:0

0 1 3 4 10 17 18 20

add number:18

0 1 3 4 10 17 18 18 20

add number:5

0 1 3 4 5 10 17 18 18 20

事实上最开始见到这个链表结构是从Linux内核代码中，位于<linux/list.h>

其更是广泛应用于Linux内核中，在Linux驱动程序设计的也会用到，有机会写关于Linux驱动设计的文章时，我们再举例了。

参考文献:

《Linux内核设计与实现》(Linux Kernel Development Third Edition) Robert Love
《深入理解Nginx》模块化开发与架构解析
《算法导论》

链表(1)

2015-12-25T00:00:00+00:00

##链表（1）##

链表是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点都包含指向下一个节点的链接。在链表中各个对象按线性顺序排序。与数组不同的是，数组的线性顺序是由数组的下标决定的，而链表中的顺序是由各个对象中的指针决定的。链表可以用来简单而灵活的表示动态集合。链表是最基本的数据结构之一，也是我们经常会用到的数据结构。链表又分为单向链表，双向链表，循环链表。

单向链表 顾名思义，其链接方向是单向的，对链表的访问要通过顺序的读取从头部开始。下面是一个简单的单向链表结构体定义

typedef struct struct_node{
 	int value;						//数据
    struct struct_node * next;		//指向下一个节点的指针
    }node_t;

双向链表 相对于单向链表，其多了一个指向前一个节点的指针，使其可以向前和向后访问节点，所以双向链表可以从任意一个节点开始读取链表的数据。下面是一个简单的双向链表结构

typedef struct struct_node{
 	int value;						//数据
    struct struct_node * prev;		//指向前一个节点的指针
    struct struct_node * next;		//指向下一个节点的指针
    }node_t;

循环链表 与双向链表相比，循环链表是双向链表的头尾相连，即双向链表的最后一个节点的next指针指向头节点，头节点的prev指针指向最后一个节点。由于是一个循环链表，这个时候表头和表尾的边界条件就很重要了， 哨兵节点的引入可以简化边界条件，哨兵节点是一个哑对象，其在表头和表尾之间，即哨兵节点的next指向头节点，哨兵节点的prev指向尾节点。这样一个空的循环链表就仅包含哨兵节点，其next和prev指针都指向自己本身. 循环链表的定义同双向链表一样，同上不在赘述。

#####链表的基本操作#####

链表的基本操作包括插入操作，删除操作，搜索操作等。这里以循环链表为例来讲链表的基本操作。

#include <stdio.h>

typedef struct struct_node_s{
        int value;
        struct struct_node_s * prev;
        struct struct_node_s * next;
}node_t;

//初始化哨兵节点
void
node_init(node_t * h){
        h->prev = h;
        h->next = h;
}

//创建一个节点
node_t *
node_new(int v){
        node_t * p = calloc(sizeof(node_t),1);
        p->value = v;
        p->next = p;
        p->prev = p;
        return p;
}

//在添加一个节点到链表头
void
node_insert_head(node_t * h,node_t * p){
        node_t * q = h->next;
        h->next = p;
        p->prev = h;
        p->next = q;
        q->prev = p;
}

//添加一个节点到表尾
void
node_insert_tail(node_t * h,node_t * p){
        node_t * q = h->prev;
        h->prev = p;
        p->next = h;
        q->next = p;
        p->prev = q;
}

//删除一个节点
void
node_remove(node_t * p){
        node_t * h = p->prev;
        node_t * q = p->next;
        h->next = q;
        q->prev = h;
}

//释放链表中所有节点（哨兵节点除外）
void
node_free(node_t * h){
        node_t * p = h->next;
        while(p != h){
                node_remove(p);
                free(p);
                p = h->next;
        }
}

//从表头开始打印链表
void
node_print(node_t * h){
        printf("list:");
        node_t * p = h->next;
        while(p != h){
                printf("%d ",p->value);
                p=p->next;
        }
        printf("\n");
}

int main(int argc, char *argv[])
{
        printf("node_init:\n");
        node_t h;
        node_init(&h);
        node_print(&h);
        printf("node_insert_tail:\n");
        for (int i = 0; i < 10; i++) {
                node_t * p = node_new(i);
                node_insert_tail(&h,p);
        }
        node_print(&h);
        printf("node_insert_head value 10 :\n");
        node_t * p = node_new(10);
        node_insert_head(&h,p);
        node_print(&h);
        printf("node_remove value 10 :\n");
        node_remove(p);
        node_print(&h);
        node_free(&h);
        printf("node_free:\n");
        node_print(&h);
        printf("----------------end---------------\n");
        return 0;
}

输出结果:

node_init:
list:
node_insert_tail:
list:0 1 2 3 4 5 6 7 8 9 
node_insert_head value 10 :
list:10 0 1 2 3 4 5 6 7 8 9 
node_remove value 10 :
list:0 1 2 3 4 5 6 7 8 9 
node_free:
list:

—————-end—————

上面的例子只是链表的一个基本用法，这里着重将循环链表拿出来举例，是因为它是我们在实际编程中用的最多的一种数据结构。但是通常在进行Linux环境下进行C程序设计的时候，我们常用的链表是在Linux内核中的链表，详见链表(2)

参考文献:

«算法导论»第10章，基本数据结构

程序运行环境：Ubuntu 12.04 LTS