Linux实现插入排序的双向链表

实现插入自动排序的双向链表，插入的的每个元素是唯一且是排序好的，从链表头到链表尾部都是按照从小到大的顺序的

/*************************************************************************
> File Name: ds.h
> Author: zhoulin
> Mail: 715169549@qq.com
> Created Time: Thu 31 Dec 2015 07:16:49 PM EST
***********************************************************************/
/***********************************************************************
* define listNode 、list struct
***********************************************************************/
#ifndef __ds_h
#define __ds_h
typedef struct listNode   //双向变脸的节点定义
{
int var;
struct listNode *prev;
struct listNode *next;
}listNode;
typedef struct list
{
unsigned int len; //链表的长度
struct listNode *head; //链表的头部节点
struct listNode *tail; //链表的尾部节点
}list;

#define listNodeHead(l)   ((l)->head)
#define listNodeTail(l)   ((l)->tail)
#define listNodeLen(l)    ((l)->len)
#define listNodePrev(l)   ((l)->prev)
#define listNodeNext(l)   ((l)->next)
#define listNodeNull(n)    \
{                          \
(n)->prev = NULL;      \
(n)->next = NULL;      \
}
/**********************************************************************
* operation of struct listNode and list
* ********************************************************************/
list *listCreate(); //链表创建
int listNodeAdd(list *lt, listNode *value); //添加listNode到链表
int listNodeDel(list *lt, int var); //删除某个链表
listNode *listNodeQuery(list *lt, int var); //查询某个链表
void listNodePrt(list *lt); //打印整个链表
int listNodeRelease(list *lt); //销毁整个链表
#endif

/*************************************************************************
> File Name: ds_pt.c
> Author: zhoulin
> Mail: 715169549@qq.com
> Created Time: Thu 31 Dec 2015 07:33:04 PM EST
************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "ds.h"
list *listCreate()
{
list *lt = NULL;
if((lt = (list *)malloc(sizeof(*lt))) != NULL) {
listNodeLen(lt) = 0;
listNodeHead(lt) = NULL;
listNodeTail(lt) = NULL;
}
return lt;
}
int listNodeAdd(list *lt, listNode *value)
{
if(lt == NULL || value == NULL) {
return -1;
}
if(listNodeLen(lt) == 0) {
listNodeHead(lt) = listNodeTail(lt) = value;
__sync_fetch_and_add(&(lt->len),1);
return 0;
}
listNode *pHead = listNodeHead(lt);
listNode *pTail = listNodeTail(lt);
if(listNodeLen(lt) == 1) {
if(pHead->var == value->var){
return -1;
}
if(pHead->var > value->var) {
listNodeHead(lt) = value;
listNodeNext(value) = pHead;
listNodePrev(pHead) = value;
__sync_fetch_and_add(&(lt->len),1);
return 0;
}
listNodeTail(lt) = listNodeTail(lt) =  value;
listNodePrev(value) = pHead;
listNodeNext(pHead) = value;
__sync_fetch_and_add(&(lt->len),1);
return 0;
}
listNode *pCur = pHead;
while(pCur != NULL){
if(pCur->var == value->var){
return -1;
}
listNode *pNext=listNodeNext(pCur);
listNode *pPrev=listNodePrev(pCur);
if(pPrev == NULL && pNext != NULL) {  //head
if(pCur->var > value->var) {
listNodeHead(lt) = value;
listNodeNext(value) = pCur;
listNodePrev(pCur) = value;
__sync_fetch_and_add(&(lt->len),1);
break;
}
if(pCur->var < value->var && pNext->var> value->var) {
listNodePrev(value) = pCur;
listNodeNext(value) = pNext;
listNodePrev(pNext) = listNodeNext(pCur)  = value;
__sync_fetch_and_add(&(lt->len),1);
break;
}
}
if(pPrev != NULL && pNext != NULL) { //mid
if(pCur->var < value->var && pNext->var > value->var) {
listNodePrev(value) = pCur;
listNodeNext(value) = pNext;
listNodePrev(pNext) = listNodeNext(pCur)  = value;
__sync_fetch_and_add(&(lt->len),1);
break;
}
if(pCur->var > value->var && pPrev->var < value->var) {
listNodePrev(pCur) = value;
listNodeNext(pPrev) = value;
listNodePrev(value) = pPrev;
listNodeNext(value) = pCur;
__sync_fetch_and_add(&(lt->len),1);
break;
}
}
if(pPrev != NULL && pNext == NULL) {  //tail listNode
if(pCur->var < value->var) {
listNodeTail(lt) = value;
listNodePrev(value) =pCur;
listNodeNext(pCur) = value;
__sync_fetch_and_add(&(lt->len),1);
break;
}
if(pCur->var > value->var && pPrev->var < value->var) {
listNodeNext(value) = pCur;
listNodePrev(value) = pPrev;
listNodePrev(pCur) = value;
listNodeNext(pPrev) = value;
__sync_fetch_and_add(&(lt->len),1);
break;
}
}
pCur = listNodeNext(pCur);
}
return 0;
}
int listNodeDel(list *lt, int var)
{
if(lt == NULL) {
return -1;
}
listNode *pHead = listNodeHead(lt);
listNode *pTail = listNodeTail(lt);
if(pHead != NULL && pTail != NULL) {
if(pHead->var > var || pTail->var < var){
return -1;
}
}
listNode *pCur = pHead;
while(pCur != NULL) {
listNode *pNext = listNodeNext(pCur);
listNode *pPrev = listNodePrev(pCur);
if(pCur->var == var) {
if(pPrev == NULL && pNext != NULL){
listNodeHead(lt) = pNext;
listNodePrev(pNext) = NULL;
__sync_fetch_and_sub(&(lt->len),1);
listNodeNull(pCur);
free(pCur);
pCur = NULL;
return 0;
}
if(pPrev != NULL && pNext != NULL){
listNodePrev(pNext) = pPrev;
listNodeNext(pPrev) = pNext;
__sync_fetch_and_sub(&(lt->len),1);
listNodeNull(pCur);
pCur = NULL;
return 0;
}
if(pPrev != NULL && pNext == NULL){
listNodeTail(lt) = pPrev;
listNodeNext(pPrev) = NULL;
__sync_fetch_and_sub(&(lt->len),1);
listNodeNull(pCur);
free(pCur);
pCur=NULL;
return 0;
}
}
pCur =listNodeNext(pCur);
}
return -1;
}
listNode *listNodeQuery(list *lt, int var)
{
listNode *query = NULL;
if(lt == NULL || listNodeLen(lt) <= 0){
return NULL;
}
listNode *pHead = listNodeHead(lt);
listNode *pTail = listNodeTail(lt);
if(pHead->var > var || pTail->var < var) {
return NULL;
}
listNode *pCur = pHead;
while(pCur !=  NULL) {
if(pCur->var == var) {
query = pCur;
break;
}
pCur = listNodeNext(pCur);
}
return query;
}
void listNodePrt(list *lt)
{
if(lt != NULL) {
listNode *pCur = listNodeHead(lt);
while(pCur != NULL) {
listNode *pPrev = listNodePrev(pCur);
listNode *pNext = listNodeNext(pCur);
printf("listNode =%p,var=%d,prev=%p,next=%p\n",pCur,pCur->var,pPrev,pNext);
pCur=pNext;
}
}
}
int listNodeRelease(list *lt)
{
int count=0;
if(lt == NULL || listNodeLen(lt) == 0) {
return count;
}
listNode *pCur = listNodeHead(lt);
while(pCur != NULL) {
count++;
listNode *pNext = listNodeNext(pCur);
free(pCur);
pCur = pNext;
}
return count;
}
void test(int count, double base)
{
list *lt=listCreate();
srand((unsigned int) time(NULL));
int i;
printf("*************************listNodeAdd*******************\n");
int ok = 0;
int fail = 0;
for(i = 0; i < count; i++) {
int v =i+ (int)( base *rand()/(RAND_MAX + 1.0));
listNode *tmp =(listNode *)malloc(sizeof(*tmp));
tmp->var = v;
int exec = listNodeAdd(lt, tmp);
if(exec == 0) {
ok++;
printf("var=%d,listNodeAdd =%d\n",v,exec);
} else {
fail++;
printf("var=%d,listNodeAdd =%d\n",v,exec);
}
}
printf("*************************listNodeAdd ok =%d | fail =%d*******************\n\n", ok, fail);
ok = 0,fail = 0;
printf("********head=%p,tail=%p,listNodeLen=%d*****\n\n",listNodeHead(lt),listNodeTail(lt),listNodeLen(lt));
printf("*************************listNodePrt*****************\n");
listNodePrt(lt);
printf("*************************listNodeQuery*****************\n");
for(i = 0; i < count; i++) {
int v =i+ (int)( base *rand()/(RAND_MAX + 1.0));
listNode *tmp = listNodeQuery(lt,v);
if(tmp !=NULL) {
ok++;
printf("listNodeQuery(%d) =%p,var=%d\n",v,tmp,tmp->var);
} else {
fail++;
printf("listNodeQuery(%d) =%p\n",v,tmp);
}
}
printf("   ------------>listNodeQuery ok=%d | fail =%d<-------------------\n\n", ok, fail);
ok = 0,fail = 0;
printf("*************************listNodeDel*****************\n");
for(i = 0;i < count; i++){
int v =i+ (int)( base *rand()/(RAND_MAX + 1.0));
int exec = listNodeDel(lt,v);
if(exec == 0){
ok++;
printf("listNodeDel(%d) =%d\n",v,exec);
}else {
fail++;
printf("listNodeDel(%d) =%d\n",v,exec);
}
}
printf("   --------------->listNodeDel ok =%d | fail =%d<------------------\n\n", ok, fail);
printf("*************************listNodeRelease***************\n");
printf("list len = %d,istNodeRelease(%p) =%d\n",listNodeLen(lt),lt,listNodeRelease(lt));
}
int main(void)
{
test(30,100.0);
return 0;
}

zhoulin@:~/code_20160101/cas:./ds
*************************listNodeAdd*******************
var=64,listNodeAdd =0
var=52,listNodeAdd =0
var=67,listNodeAdd =0
var=13,listNodeAdd =0
var=41,listNodeAdd =0
var=15,listNodeAdd =0
var=70,listNodeAdd =0
var=15,listNodeAdd =-1
var=43,listNodeAdd =0
var=17,listNodeAdd =0
var=89,listNodeAdd =0
var=52,listNodeAdd =-1
var=99,listNodeAdd =0
var=74,listNodeAdd =0
var=14,listNodeAdd =0
var=82,listNodeAdd =0
var=97,listNodeAdd =0
var=48,listNodeAdd =0
var=49,listNodeAdd =0
var=69,listNodeAdd =0
var=45,listNodeAdd =0
var=73,listNodeAdd =0
var=106,listNodeAdd =0
var=40,listNodeAdd =0
var=30,listNodeAdd =0
var=122,listNodeAdd =0
var=47,listNodeAdd =0
var=64,listNodeAdd =-1
var=62,listNodeAdd =0
var=127,listNodeAdd =0
*************************listNodeAdd ok =27 | fail =3*******************

********head=0x1a62090,tail=0x1a623d0,listNodeLen=27*****

*************************listNodePrt*****************
listNode =0x1a62090,var=13,prev=(nil),next=0x1a621f0
listNode =0x1a621f0,var=14,prev=0x1a62090,next=0x1a620d0
listNode =0x1a620d0,var=15,prev=0x1a621f0,next=0x1a62150
listNode =0x1a62150,var=17,prev=0x1a620d0,next=0x1a62330
listNode =0x1a62330,var=30,prev=0x1a62150,next=0x1a62310
listNode =0x1a62310,var=40,prev=0x1a62330,next=0x1a620b0
listNode =0x1a620b0,var=41,prev=0x1a62310,next=0x1a62130
listNode =0x1a62130,var=43,prev=0x1a620b0,next=0x1a622b0
listNode =0x1a622b0,var=45,prev=0x1a62130,next=0x1a62370
listNode =0x1a62370,var=47,prev=0x1a622b0,next=0x1a62250
listNode =0x1a62250,var=48,prev=0x1a62370,next=0x1a62270
listNode =0x1a62270,var=49,prev=0x1a62250,next=0x1a62050
listNode =0x1a62050,var=52,prev=0x1a62270,next=0x1a623b0
listNode =0x1a623b0,var=62,prev=0x1a62050,next=0x1a62030
listNode =0x1a62030,var=64,prev=0x1a623b0,next=0x1a62070
listNode =0x1a62070,var=67,prev=0x1a62030,next=0x1a62290
listNode =0x1a62290,var=69,prev=0x1a62070,next=0x1a620f0
listNode =0x1a620f0,var=70,prev=0x1a62290,next=0x1a622d0
listNode =0x1a622d0,var=73,prev=0x1a620f0,next=0x1a621d0
listNode =0x1a621d0,var=74,prev=0x1a622d0,next=0x1a62210
listNode =0x1a62210,var=82,prev=0x1a621d0,next=0x1a62170
listNode =0x1a62170,var=89,prev=0x1a62210,next=0x1a62230
listNode =0x1a62230,var=97,prev=0x1a62170,next=0x1a621b0
listNode =0x1a621b0,var=99,prev=0x1a62230,next=0x1a622f0
listNode =0x1a622f0,var=106,prev=0x1a621b0,next=0x1a62350
listNode =0x1a62350,var=122,prev=0x1a622f0,next=0x1a623d0
listNode =0x1a623d0,var=127,prev=0x1a62350,next=(nil)
*************************listNodeQuery*****************
listNodeQuery(30) =0x1a62330,var=30
listNodeQuery(100) =(nil)
listNodeQuery(52) =0x1a62050,var=52
listNodeQuery(99) =0x1a621b0,var=99
listNodeQuery(14) =0x1a621f0,var=14
listNodeQuery(93) =(nil)
listNodeQuery(12) =(nil)
listNodeQuery(81) =(nil)
listNodeQuery(105) =(nil)
listNodeQuery(51) =(nil)
listNodeQuery(92) =(nil)
listNodeQuery(87) =(nil)
listNodeQuery(96) =(nil)
listNodeQuery(83) =(nil)
listNodeQuery(52) =0x1a62050,var=52
listNodeQuery(99) =0x1a621b0,var=99
listNodeQuery(54) =(nil)
listNodeQuery(36) =(nil)
listNodeQuery(33) =(nil)
listNodeQuery(89) =0x1a62170,var=89
listNodeQuery(89) =0x1a62170,var=89
listNodeQuery(61) =(nil)
listNodeQuery(44) =(nil)
listNodeQuery(76) =(nil)
listNodeQuery(81) =(nil)
listNodeQuery(53) =(nil)
listNodeQuery(76) =(nil)
listNodeQuery(106) =0x1a622f0,var=106
listNodeQuery(93) =(nil)
listNodeQuery(114) =(nil)
------------>listNodeQuery ok=9 | fail =21<-------------------

*************************listNodeDel*****************
listNodeDel(78) =-1
listNodeDel(97) =0
listNodeDel(86) =-1
listNodeDel(32) =-1
listNodeDel(97) =-1
listNodeDel(100) =-1
listNodeDel(23) =-1
listNodeDel(106) =0
listNodeDel(77) =-1
listNodeDel(23) =-1
listNodeDel(52) =0
listNodeDel(63) =-1
listNodeDel(103) =-1
listNodeDel(39) =-1
listNodeDel(36) =-1
listNodeDel(44) =-1
listNodeDel(27) =-1
listNodeDel(77) =-1
listNodeDel(66) =-1
listNodeDel(45) =0
listNodeDel(51) =-1
listNodeDel(39) =-1
listNodeDel(89) =0
listNodeDel(76) =-1
listNodeDel(95) =-1
listNodeDel(50) =-1
listNodeDel(108) =-1
listNodeDel(49) =0
listNodeDel(33) =-1
listNodeDel(77) =-1
--------------->listNodeDel ok =6 | fail =24<------------------

*************************listNodeRelease***************
list len = 21,istNodeRelease(0x1a62010) =21

zhoulin@:~/code_20160101/cas:gcc -g ds.h ds_pt.c -O2 -o ds //使用gcc原子操作函数
zhoulin@:~/code_20160101/cas:gcc -g ds1.h ds_pt1.c -O2 -o ds1 -lpthread //使用pthread_mutex_t进行原子操作
zhoulin@:~/code_20160101/cas:time ./ds
*************************listNodeRelease***************
list len = 8008,listNodeRelease(0x1d51010) =8008

real    0m5.809s
user    0m5.770s
sys     0m0.004s
zhoulin@:~/code_20160101/cas:time ./ds1
*************************listNodeRelease***************
list len = 8051,listNodeRelease(0x21cd010) =8051

real    0m6.231s
user    0m6.220s
sys     0m0.002s