常见算法的实现

#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;
}