久久91精品国产91久,国产精品福利一区二区久久,亚洲国产精品一区二区久久hs

qsort函数应用大全七种qsort排序�Ҏ(gu��)��

井泉 — Tue, 29 Aug 2006 03:58:00 GMT

<本文中排序都是采用的从小到大排序>

一、对int�c�d��数组排序

int num[100];

Sample:

int cmp ( const void *a , const void *b )
{
return *(int *)a - *(int *)b;
}

qsort(num,100,sizeof(num[0]),cmp);

二、对char�c�d��数组排序�Q�同int�c�d��Q?

char word[100];

Sample:

int cmp( const void *a , const void *b )
{
return *(char *)a - *(int *)b;
}

qsort(word,100,sizeof(word[0]),cmp);

三、对double�c�d��数组排序�Q�特别要注意�Q?

double in[100];

int cmp( const void *a , const void *b )
{
return *(double *)a > *(double *)b ? 1 : -1;
}

qsort(in,100,sizeof(in[0]),cmp)�Q?

四、对�l�构体一�U�排�?

struct In
{
double data;
int other;
}s[100]

//按照data的��g��到大将�l�构体排�?关于�l�构体内的排序关键数据data的类型可以很多种�Q�参考上面的例子�?

int cmp( const void *a ,const void *B)
{
return (*(In *)a)->data > (*(In *)B)->data ? 1 : -1;
}

qsort(s,100,sizeof(s[0]),cmp);

五、对�l�构体二�U�排�?

struct In
{
int x;
int y;
}s[100];

//按照x从小到大排序�Q�当x相等时按照y从大到小排序

int cmp( const void *a , const void *b )
{
struct In *c = (In *)a;
struct In *d = (In *)b;
if(c->x != d->x) return c->x - d->x;
else return d->y - c->y;
}

qsort(s,100,sizeof(s[0]),cmp);

六、对字符串进行排�?

struct In
{
int data;
char str[100];
}s[100];

//按照�l�构体中字符串str的字兔R��序排�?

int cmp ( const void *a , const void *b )
{
return strcmp( (*(In *)a)->str , (*(In *)B)->str );
}

qsort(s,100,sizeof(s[0]),cmp);

七、计��几何中求凸包的cmp

int cmp(const void *a,const void *B) //重点cmp函数�Q�把除了1点外的所有点�Q�旋转角度排�?
{
struct point *c=(point *)a;
struct point *d=(point *)b;
if( calc(*c,*d,p[1]) < 0) return 1;
else if( !calc(*c,*d,p[1]) && dis(c->x,c->y,p[1].x,p[1].y) < dis(d->x,d->y,p[1].x,p[1].y)) //如果在一条直�U�上�Q�则把远的放在前�?
return 1;
else return -1;
}

PS:

其中的qsort函数包含�?lt;stdlib.h>的头文�g里，strcmp包含�?lt;string.h>的头文�g�?img src ="http://www.shnenglu.com/zjj2816/aggbug/11816.html" width = "1" height = "1" />

井泉 2006-08-29 11:58 发表评论

井泉 — Mon, 26 Jun 2006 11:37:00 GMT

一个简化的问题�C�Z��

链表的难点在于必��d��刉��表处理函数来处理不同的对象，即便逻辑是完全相同的。例如两个结构类似的链表:

struct Struct_Object_A
　　{
　　　　int a;
　　　　int b;
　　　　Struct_Object_A *next;
　　
　　} OBJECT_A;
　　
　　typedef struct Struct_Object_B
　　{
　　　　int a;
　　　　int b;
　　　　int c;
　　　　Struct_Object_B *next;
　　
　　} OBJECT_B;

上面定义的两个结构只有很��的一点差别。OBJECT_B �?OBJECT_A 之间只差一个整型变量。但是，在编译器看来�Q�它们仍然是非常不同的。必��Mؓ(f��)存储在链表中的每个对象复制用来添加、删除和搜烦链表的函数。�ؓ(f��)了解册��个问题，可以使用��h��全部三个变量的一个联合或�l�构�Q�其中整�?c �q�不是在所有的情况下都要��用。这可能变得非常复杂�Q��ƈ�?x��)�Ş成不良的�~�程风格�?

C 代码解决�Ҏ(gu��)��Q�虚拟链�?

此问题更好的解决�Ҏ(gu��)��之一是虚拟链表。虚拟链表是只包含链表指针的链表。对象存储在链表�l�构背后。这一�Ҏ(gu��)��q�样实现的，首先为链表节点分配内存，接着为对象分配内存，然后��这块内存分配给链表节点指针�Q�如下所�C�：(x��)

虚拟链表�l�构的一�U�实�?

typedef struct liststruct
　　{
　　　　liststruct *next;
　　
　　} LIST, *pLIST;
　　
　　pLIST Head = NULL;
　　
　　pLIST AddToList( pLIST Head,
void * data, size_t datasize )
　　{
　　pLIST newlist=NULL;
　　void *p;
　　
　　　　// 分配节点内存和数据内�?
　　　　newlist = (pLIST) malloc
( datasize + sizeof( LIST ) );
　　
　　　　// �����块数据缓冲区指定一个指�?
　　　　p = (void *)( newlist + 1 );
　　
　　　　// 复制数据
　　　　memcpy( p, data, datasize );
　　
　　　　// ���这个节�Ҏ(gu��)��定给链表的表�?
　　　　if( Head )
　　　　{
　　　　newlist->next = Head;
　　　　}
　　　　else
　　　　newlist->next = NULL;
　　
　　　　Head = newlist;
　　
　　　　return Head;
　　}

链表节点现在建立在数据值副本的基本之上。这个版本能很好地处理标量��|��但不能处理带有用 malloc �?new 分配的元素的对象。要处理�q�些对象�Q�LIST �l�构需要包含一个一般的解除函数指针�Q�这个指针可用来在将节点从链表中删除�q�解除它之前释放内存�Q�或者关闭文�Ӟ��或者调用关闭方法）�?

一个带有解除函数的链表

typedef void (*ListNodeDestructor)( void * );
　　
　　typedef struct liststruct
　　{
　　　　ListNodeDestructor DestructFunc;
　　　　liststruct *next;
　　
　　} LIST, *pLIST;
　　
　　pLIST AddToList( pLIST Head, void * data, 
size_t datasize,
　　ListNodeDestructor Destructor )
　　{
　　pLIST newlist=NULL;
　　void *p;
　　
　　
　　　　// 分配节点内存和数据内�?
　　　　newlist = (pLIST) malloc
( datasize + sizeof( LIST ) );
　　
　　　　// �����块数据缓冲区指定一个指�?
　　　　p = (void *)( newlist + 1 );
　　
　　　　// 复制数据
　　　　memcpy( p, data, datasize );
　　
　　　　newlist->DestructFunc = Destructor;
　　　　
　　　　// ���这个节�Ҏ(gu��)��定给链表的表�?
　　　　if( Head )
　　　　{
　　　　　　newlist->next = Head;
　　　　}
　　　　else
　　　　　　newlist->next = NULL;
　　
　　　　Head = newlist;
　　
　　　　return Head;
　　}
　　
　　void DeleteList( pLIST Head )
　　{
　　　　pLIST Next;
　　　　while( Head )
　　　　{
　　　　　　Next = Head->next;
　　　　　　Head->DestructFunc( 
(void *) Head );
　　　　　　free( Head );
　　　　　　Head = Next;
　　　　}
　　}
　　
　　typedef struct ListDataStruct
　　{
　　　　LPSTR p;
　　
　　} LIST_DATA, *pLIST_DATA;
　　
　　void ListDataDestructor( void *p )
　　{
　　　　// 对节�Ҏ(gu��)��针进行类型�{�?
　　　　pLIST pl = (pLIST)p;
　　
　　　　// �Ҏ(gu��)��据指针进行类型�{�?
　　　　pLIST_DATA pLD = (pLIST_DATA)
( pl + 1 );
　　
　　　　delete pLD->p;
　　}
　　pLIST Head = NULL;
　　
　　void TestList()
　　{
　　　　pLIST_DATA d = new LIST_DATA;
　　　　d->p = new char[24];
　　　　strcpy( d->p, "Hello" ); 
　　　　Head = AddToList( Head, (void *) d,
sizeof( pLIST_DATA ),
　　　　ListDataDestructor );
　　　　// 该对象已被复�Ӟ��现在删除原来的对�?
　　　　delete d;
　　
　　　　d = new LIST_DATA;
　　　　d->p = new char[24];
　　　　strcpy( d->p, "World" ); 
　　　　Head = AddToList( Head, (void *) d,
sizeof( pLIST_DATA ),
　　　　ListDataDestructor );
　　　　delete d;
　　
　　　　// 释放链表
　　　　DeleteList( Head );
　　}

在每个链表节点中包含同一个解除函数的同一个指针似乎是��费内存�I�间。确实如此，但只有链表始�l�包含相同的对象才属于这�U�情��c(di��n)��按�q�种方式�~�写链表允许�(zh��n)�将��M��对象攑֜�链表中的��M��位置。大多数链表函数要求对象��L��相同的类型或�c�R�?

虚拟链表则无此要求。它所需要的只是��对象彼此区分开的一�U�方法。要实现�q�一点，�(zh��n)�既可以��解除函数指针的��|��也可以在链表中所用的全部�l�构前添加一个类型值�ƈ对它�q�行��?

当然�Q�如果要��链表编写�ؓ(f��)一�?C++ �c�，则对指向解除函数的指针的讄��和存储只能进行一�ơ�?

C++ 解决�Ҏ(gu��)��Q�类链表

本解��x��案将 CList �c�d��义�ؓ(f��)�?LIST �l�构导出的一个类�Q�它通过存储解除函数的单个值来处理单个存储�c�d��。请注意��d��?GetCurrentData() 函数�Q�该函数完成从链表节�Ҏ(gu��)��针到数据偏移指针的数学�{换。一个虚拟链表对�?

// 定义解除函数指针
　　
　　typedef void (*ListNodeDestructor)
( void * );
　　
　　// 未添加解除函数指针的链表
　　
　　typedef struct ndliststruct
　　{
　　　　ndliststruct *next;
　　
　　} ND_LIST, *pND_LIST;
　　
　　// 定义处理一�U�数据类型的链表�c?
　　
　　class CList : public ND_LIST
　　{
　　public:
　　　　CList(ListNodeDestructor);
　　　　~CList();
　　　　pND_LIST AddToList
( void * data, size_t datasize );
　　　　void *GetCurrentData();
　　　　void DeleteList( pND_LIST Head );
　　
　　
　　private:
　　　　pND_LIST m_HeadOfList;
　　　　pND_LIST m_CurrentNode;
　　　　ListNodeDestructor
m_DestructFunc;
　　};
　　
　　// 用正���的起始值构造这个链表对�?
　　
　　CList::CList(ListNodeDestructor Destructor)
　　　　: m_HeadOfList(NULL), 
m_CurrentNode(NULL)
　　{
　　　　m_DestructFunc = Destructor;
　　}
　　
　　// 在解除对象以后删除链�?
　　
　　CList::~CList()
　　{
　　　　DeleteList(m_HeadOfList);
　　}
　　
　　// 向链表中��d��一个新节点
　　
　　pND_LIST CList::AddToList
( void * data, size_t datasize )
　　{
　　pND_LIST newlist=NULL;
　　void *p;
　　
　　
　　　　// 分配节点内存和数据内�?
　　　　newlist = (pND_LIST) malloc
( datasize + sizeof( ND_LIST ) );
　　
　　　　// �����块数据缓冲区指定一个指�?
　　　　p = (void *)( newlist + 1 );
　　
　　　　// 复制数据
　　　　memcpy( p, data, datasize );
　　
　　　　// ���这个节�Ҏ(gu��)��定给链表的表�?
　　　　if( m_HeadOfList )
　　　　{
　　　　　　newlist->next = m_HeadOfList;
　　　　}
　　　　else
　　　　　　newlist->next = NULL;
　　
　　　　m_HeadOfList = newlist;
　　
　　　　return m_HeadOfList;
　　}
　　
　　// ���当前的节点数据作�ؓ(f��) void �c�d���q�回�Q?
以便调用函数能够���它转换��Z�Q何类�?
　　
　　void * CList::GetCurrentData()
　　{
　　　　return (void *)(m_CurrentNode+1);
　　}
　　
　　// 删除已分配的链表
　　
　　void CList::DeleteList( pND_LIST Head )
　　{
　　　　pND_LIST Next;
　　　　while( Head )
　　　　{
　　　　　　Next = Head->next;
　　　　　　m_DestructFunc( (void *) Head );
　　　　　　free( Head );
　　　　　　Head = Next;
　　　　}
　　}
　　
　　// 创徏一个要在链表中创徏和存储的�l�构
　　
　　typedef struct ListDataStruct
　　{
　　　　LPSTR p;
　　
　　} LIST_DATA, *pND_LIST_DATA;
　　
　　// 定义标准解除函数
　　
　　void ClassListDataDestructor( void *p )
　　{
　　　　// 对节�Ҏ(gu��)��针进行类型�{�?
　　　　pND_LIST pl = (pND_LIST)p;
　　
　　　　// �Ҏ(gu��)��据指针进行类型�{�?
　　　　pND_LIST_DATA pLD = (pND_LIST_DATA)
( pl + 1 );
　　
　　　　delete pLD->p;
　　}
　　
　　// ���试上面的代�?
　　
　　void MyCListClassTest()
　　{
　　　　// 创徏链表�c?
　　
　　　　CList* pA_List_of_Data =
new CList(ClassListDataDestructor);
　　
　　　　// 创徏数据对象
　　　　
　　　　pND_LIST_DATA d = new LIST_DATA;
　　　　d->p = new char[24];
　　　　strcpy( d->p, "Hello" ); 
　　
　　　　// 创徏指向链表�剙��的局部指�?
　　
　　　　pND_LIST Head = NULL;
　　
　　　　//向链表中��d��一些数�?
　　
　　　　Head = pA_List_of_Data->AddToList
( (void *) d, 
　　　　sizeof( pND_LIST_DATA ) );
　　　　// 该对象已被复�Ӟ��现在删除原来的对�?
　　　　delete d;
　　
　　　　// ���认它已被存�?
　　　　char * p = ((pND_LIST_DATA) pA_List_of_Data->GetCurrentData())->p;
　　
　　　　d = new LIST_DATA;
　　　　d->p = new char[24];
　　　　strcpy( d->p, "World" ); 
　　　　Head = pA_List_of_Data->AddToList
( (void *) d, sizeof( pND_LIST_DATA ) );
　　　　// 该对象已被复�Ӟ��现在删除原来的对�?
　　　　delete d;
　　
　　　　// ���认它已被存�?
　　　　p = ((pND_LIST_DATA) 
pA_List_of_Data->GetCurrentData())->p;
　　
　　　　// 删除链表�c�，析构函数���删除链�?
　　　　delete pA_List_of_Data;
　　}

��结

从前面的讨论来看�Q�似乎仅�~�写一个简单的链表��p��做大量的工作�Q�但�q�只��进行一�ơ。很�Ҏ(gu��)��这�D�代码扩充�ؓ(f��)一个处理排序、搜索以�?qi��ng)各�U�其他�Q务的 C++ �c�，�q�且�q�个�c�d��以处理�Q何数据对象或�c�（在一个项目中�Q�它处理大约二十个不同的对象�Q�。�?zh��n)�永远不必重新�~�写�q�段代码�?/p>

井泉 2006-06-26 19:37 发表评论

队列

井泉 — Mon, 26 Jun 2006 11:25:00 GMT

队列

需要队列是��Z��两个原因。首先，需要队列来保存工作作业。还需要可用于跟踪已终止线�E�的数据�l�构。还记得前几��文章（请参阅本文结��֤��?参考资�?/font>�Q�中�Q�我曾提到过需要��用带有特定进�E�标识的 pthread_join 吗？使用“清除队列”（�U�C�� "cq"�Q�可以解��x��法等�?��M��已终止线�E�的问题�Q�稍后将详细讨论�q�个问题�Q�。以下是标准队列代码。将此代码保存到文�g queue.h �?queue.c�Q?

queue.h

												
														/* queue.h
** Copyright 2000 Daniel Robbins, Gentoo Technologies, Inc.
** Author: Daniel Robbins
** Date: 16 Jun 2000
*/

typedef struct node {
  struct node *next;
} node;

typedef struct queue {
  node *head, *tail; 
} queue;

void queue_init(queue *myroot);
void queue_put(queue *myroot, node *mynode);
node *queue_get(queue *myroot);

queue.c

												
														/* queue.c
** Copyright 2000 Daniel Robbins, Gentoo Technologies, Inc.
** Author: Daniel Robbins
** Date: 16 Jun 2000
**
** This set of queue functions was originally thread-aware.  I
** redesigned the code to make this set of queue routines
** thread-ignorant (just a generic, boring yet very fast set of queue
** routines).  Why the change?  Because it makes more sense to have
** the thread support as an optional add-on.  Consider a situation
** where you want to add 5 nodes to the queue.  With the
** thread-enabled version, each call to queue_put() would
** automatically lock and unlock the queue mutex 5 times -- that's a
** lot of unnecessary overhead.  However, by moving the thread stuff
** out of the queue routines, the caller can lock the mutex once at
** the beginning, then insert 5 items, and then unlock at the end.
** Moving the lock/unlock code out of the queue functions allows for
** optimizations that aren't possible otherwise.  It also makes this
** code useful for non-threaded applications.
**
** We can easily thread-enable this data structure by using the
** data_control type defined in control.c and control.h.  */

#include 
#include "queue.h"

void queue_init(queue *myroot) {
  myroot->head=NULL;
  myroot->tail=NULL;
}

void queue_put(queue *myroot,node *mynode) {
  mynode->next=NULL;
  if (myroot->tail!=NULL)
    myroot->tail->next=mynode;
  myroot->tail=mynode;
  if (myroot->:head==NULL)
    myroot->head=mynode;
}

node *queue_get(queue *myroot) {
  //get from root
  node *mynode;
  mynode=myroot->head;
  if (myroot->head!=NULL)
    myroot->head=myroot->head->next;
  return mynode;
}

井泉 2006-06-26 19:25 发表评论

久久91精品国产91久,国产精品福利一区二区久久,亚洲国产精品一区二区久久hs

qsort函数应用大全 七种qsort排序�Ҏ(gu��)��

队列

qsort函数应用大全七种qsort排序�Ҏ(gu��)��