常见算法的实现

#include <stdio.h>

// 线性搜索 

size_t line_find (int data[],

  size_t size, int key) {

  size_t i;

  for (i = 0; i < size; ++i)

    if (data[i] == key)

      return i;

  return -1;

}

// 二分搜索

size_t half_find (int data[],

  int left, int right, int key) {
if (left <= right) {
 int mid = (left + right) / 2;

  if (key < data[mid])

    return half_find (data, left,

      mid - 1, key);
else

  if (data[mid] < key)

    return half_find (data, mid + 1,
right, key);
else
return mid;
}
return -1;

}

size_t loop_find (int data[],

  size_t size, int key) {

  int left = 0;

  int right = size - 1;

  while (left <= right) {

    int mid = (left + right) / 2;

    if (key < data[mid])

      right = mid - 1;

    else

    if (data[mid] < key)

      left = mid + 1;

    else

      return mid;
}

  return -1;

}

int main (void) {

//int data[] = {9, 0, 7, 2, 5, 4, 3, 6,

//  1, 8};

  int data[] = {0, 1, 2, 3, 4, 5, 6, 7,

    8, 9};

  size_t size = sizeof (data) /

    sizeof (data[0]);

//size_t i = line_find (data, size, 5);

//size_t i = line_find (data, size,10);

//size_t i = half_find (data, 0,

//  size - 1, 2);

//size_t i = half_find (data, 0,

//  size - 1, 10);

//size_t i = loop_find (data, size, 2);

  size_t i = loop_find (data, size,10);

  if (i == -1)

    printf ("没找到！\n");

  else

    printf ("找到了：data[%d]=%d\n",

      i, data[i]);

  return 0;
}

/*

有数组如下：

1 2 8 9 2 3 9 12 4 7 10 13 6 8 11 15

编写一个函数返回该数组中与参数匹配的

元素下标。

1  2  8  9

2  3  9 12

4  7 10 13

6  8 11 15

*/

#include <stdio.h>

int find (int data[], int rows,

  int cols, int key) {

  if (! data || rows <= 0 || cols <= 0)

    return -1;

  int row = 0, col = cols - 1;

  while (row < rows && col >= 0) {

    int i = row * cols + col;

    if (key < data[i])

      --col;

    else

    if (data[i] < key)
++row;

    else

      return i;

  }

  return -1;

}

int main (void) {

  int data[] = {1, 2, 8, 9, 2, 4, 9,

    12, 4, 7, 10, 13, 6, 8, 11, 15};

  int i = find (data, 4, 4, /*7*/3);

  if (i == -1)

    printf ("没找到！\n");

  else

    printf ("找到了：data[%d]=%d\n",

      i, data[i]);

  return 0;

}

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

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

}

int strCmp (const void* a,
const void* b) {
return strcmp (
*(char const* const*)a,
*(char const* const*)b);

}

struct Student {
char name[256];
int age;

};

int stuCmp (const void* a,
const void* b) {
struct Student const* sa =
(struct Student const*)a;
struct Student const* sb =
(struct Student const*)b;
if (sb->age == sa->age)
return strcmp (sa->name, sb->name);
return sb->age - sa->age;

}

int main (void) {
int data[] = {13, 29, 17, 43, 29};
size_t size = sizeof (data[0]);
size_t nmemb = sizeof (data) / size;
qsort (data, nmemb, size, intCmp);
size_t i;
for (i = 0; i < nmemb; ++i)
printf ("%d ", data[i]);
printf ("\n");
char const* sarr[] = {
"jinan", "qingdao", "weifang",
"qingdao", "heze", "zibo"};
size = sizeof (sarr[0]);
nmemb = sizeof (sarr) / size;
qsort (sarr, nmemb, size, strCmp);
for (i = 0; i < nmemb; ++i)
printf ("%s ", sarr[i]);
printf ("\n");
struct Student ss[] = {
{"zhaoliu", 10},
{"zhangsan", 20},
{"lisi", 20},
{"wangwu", 30}};
size = sizeof (ss[0]);
nmemb = sizeof (ss) / size;
qsort (ss, nmemb, size, stuCmp);
for (i = 0; i < nmemb; ++i)
printf ("%s %d\n", ss[i].name,
ss[i].age);
return 0;

}

#include <stdio.h>

#include <stdlib.h>

// 冒泡排序

void bubble_sort (int data[],
size_t size) {
size_t i;
for (i = 0; i < size - 1; ++i) {
int ordered = 1;
size_t j;
for (j = 0; j < size - 1 - i; ++j)
if (data[j+1] < data[j]) {
int swap = data[j];
data[j] = data[j+1];
data[j+1] = swap;
ordered = 0;
}
if (ordered)
break;
}

}

// 插入排序

void insert_sort (int data[],
size_t size) {
size_t i;
for (i = 1; i < size; ++i) {
int inserted = data[i];
size_t j;
for (j = i; j > 0 &&
inserted < data[j-1]; --j)
data[j] = data[j-1];
if (j != i)
data[j] = inserted;
}

}

// 选择排序

void select_sort (int data[],
size_t size) {
size_t i;
for (i = 0; i < size - 1; ++i) {
size_t min = i, j;
for (j = i + 1; j < size; ++j){
if (data[j] < data[min])
min = j;
}
if (min != i) {
int swap = data[i];
data[i] = data[min];
data[min] = swap;
}
}

}

// 快速排序

void quick_sort (int data[],
size_t left, size_t right) {
size_t p = (left + right) / 2;
int pivot = data[p];
size_t i = left, j = right;
while (i < j) {
for (; ! (i >= p ||
pivot < data[i]); ++i);
if (i < p) {
data[p] = data[i];
p = i;
}
for (; ! (j <= p ||
data[j] < pivot); --j);
if (j > p) {
data[p] = data[j];
p = j;
}
}
data[p] = pivot;
if (p - left > 1)
quick_sort (data, left, p - 1);
if (right - p > 1)
quick_sort (data, p + 1, right);

}

// 测试用例

int main (void) {
srand (time (NULL));
int data[10];
size_t i, size = sizeof (data) /
sizeof (data[0]);
for (i = 0; i < size; ++i)
printf ("%2d ", data[i] =
rand () % 100);
printf ("\n");

//bubble_sort (data, size);

//insert_sort (data, size);

//select_sort (data, size);
quick_sort (data, 0, size - 1);
for (i = 0; i < size; ++i)
printf ("%2d ", data[i]);
printf ("\n");
return 0;

}