排序
二分查找
#include <stdlib.h>
#include <string.h>
#include "search.h"
int bisearch(void *sorted, const void *target, int size, int esize, int (*compare)(const void *key1, const void *key2))
{
int left,
right,
middle;
left = 0;
right = size - 1;
while(left <= right)
{
middle = (right + left) / 2;
switch(compare((char *)sorted+(esize*middle), target))
{
case -1:
left = middle + 1;
break;
case 1:
right = middle - 1;
break;
case 0:
return middle;
}
}
//not found.
return -1;
}
#include "sort.h"
#include <stdlib.h>
#include <string.h>
int issort( void *data, int size, int esize, int (*compare)(const void *key1, const void *key2) )
{
void *a = data;
char *key;
int i,
j;
key = (char *)malloc(sizeof(char)*esize);
if( key == NULL )
return -1;
for(j = 1; j < size; j++ )
{
memcpy(key, &a[j*esize], esize);
i = j-1;
while( i >= 0 && compare( &a[i*esize], key ) > 0 )
{
memcpy(&a[(i+1)*esize],&a[i*esize], esize );
i--;
}
memcpy(&a[(i+1)*esize], key, esize);
}
free(key);
return 0;
}
快速排序
#include <stdlib.h>
#include <string.h>
#include "sort.h"
/* partition */
static int partition(void *data, int esize, int i, int k,
int (*compare)(const void *key1, const void *key2))
{
char *a = data;
void *pval,
*temp;
int r[3];
/* Allocate storage for the partition value and swapping */
pval = malloc(esize);
if( pval == NULL )
return -1;
temp = malloc(esize);
if( temp == NULL )
return -1;
r[0] = (rand()%(k-i+1)) + i;
r[1] = (rand()%(k-i+1)) + i;
r[2] = (rand()%(k-i+1)) + i;
issort(r,3, sizeof(int), compare_int);
memcpy(pval, &a[r[1]*esize], esize);
/* Create two partitions around the partition value. */
i--;
k++;
while(1)
{
/* Move left until an element is found in the wrong partition */
do
{
k--;
}while(compare(&a[k*esize], pval) > 0);
do
{
i++;
}while(compare(&a[i*esize], pval) < 0 );
if( i >= k )
{
break;
}
else
{
/* swap the value */
memcpy(temp, &a[i*esize], esize);
memcpy(&a[i*esize], &a[k*esize],esize);
memcpy(&a[k*esize], temp, esize);
}
}
free(pval);
free(temp);
return k;
}
int qksort(void *data, int size, int esize, int i, int k, int (*compare)(const void *key1, const void *key2))
{
while( i < k )
{
if( (j = partition(data, size, i, k, compare)) < 0 )
return -1;
if( qksort(data, size, esize, i, j, compare) < 0 )
return -1;
i = j + 1;
}
return 0;
}
计数排序
#include <stdlib.h>
#include <string.h>
#include "sort.h"
int ctsort(void *data, int size, int k)
{
int *counts,
*temp;
int i,
j;
/* Allocate storage for the counts */
counts = malloc(k*sizeof(int));
if( counts == NULL )
return -1;
temp = malloc(size*sizeof(int));
if( temp == NULL )
return -1;
/* init the counts. */
for(i = 0; i < k; i++ )
counts[i] = 0;
/* count the occurrences of each element */
for(j = 0; j < size; j++ )
counts[data[j]] = counts[data[j]]+1;
/* Adjust each count to reflect the counts before it. */
for(i = 1; i < k; i++ )
counts[i] += count[i-1];
/* Use the counts to position each element where it belongs. */
for(j = size-1; j >= 0; j-- )
{
temp[counts[data[j]] - 1] = data[j];
counts[data[j]] = counts[data[j]] - 1;
}
memcpy(data, temp, size * sizeof(int));
free(counts);
free(temp);
return 0;
}
归并排序
#include <stdlib.h>
#include <string.h>
#include "sort.h"
/* merge */
static int merge(void *data, int esize, int i, int j, int k, int (*compare)(const void *key1, const void *key2))
{
char *a = data,
*m;
int ipos,
jpos,
mpos;
/* Initialize the counters used in mergeing. */
ipos = i;
jpos = j+1;
mpos = 0;
/* Allocate the storage for the merged elements. */
if( (m = (char *)malloc(esize*((k-i)+1))) == NULL )
return -1;
while( ipos <= j || jpos <= k )
{
if( ipos > j )
{
/* the left division has no more elements to merge */
while( jpos <= k )
{
memcpy( &m[mpos * esize], &a[jpos*esize], esize);
jpos++;
mpos++;
}
continue;
}
else if( jpos > k )
{
/* The right division has no more elements to merge */
while( ipos <= j )
{
memcpy(&m[mpos * esize], &a[ipos *esize], esize);
ipos++;
mpos++;
}
continue;
}
/* Append the next ordered element to the merged elements */
if( compare(&a[ipos * esize], &a[jpos * esize]) < 0 )
{
memcpy( &m[mpos * esize], &a[ipos * esize], esize );
ipos++;
mpos++;
}
else
{
memcpy( &m[mpos * esize], &a[jpos * esize], esize);
jpos++;
mpos++;
}
}
/* Prepare to pass back the merged data.*/
memcpy(&a[i * esize], m, esize * ((k - i) + 1));
free(m);
return 0;
}
int mgsort(void *data, int size, int esize, int i, int k, int (*compare)(const void *key1, const void *key2))
{
int j;
if( i < k )
{
j = (int)(((k - i)+1)/2);
if( mgsort(data, size, esize, i, j, compare) < 0 )
return -1;
if( mgsort(data, size, esize, j+1, k, compare) < 0 )
return -1;
if( merge(data, esize, i, j, k, compare) < 0 )
return -1;
}
return 0;
}
String实现
class String
{
public:
String(const char *str = NULL);//common constructor
String(const String &other); //copy constructor
~String(void); //desconstructor
String & operate=(const String &other);//assignment function
private:
char *m_data; //use to keep ths string.
}
String::String(const char *str = NULL)
{
if( str == NULL )
{
m_data = new char[1];
*m_data = '\0';
}
else
{
int length = strlen(str);
m_data = new char[length+1];
strcpy(m_data, str);
}
}
String::String(const String &other)
{
int length = strlen(other.m_data);
m_data = new char[length+1];
strcpy(m_data, other.m_data);
}
String & String::operate=(const String &other)
{
if(this == &other)
return *this;
delete [] m_date;
int length = strlen(other.m_data);
m_data = new char[length+1];
strcpy(m_data, other.m_data);
return *this;
}