1、重写折半查找，使得在循环内部只执行一次测试
传统的非递归式的折半查找的例子中，while循环语句内部共执行了两次测试，其实只要一次就足够（代价是将更多的测试在循环外执行）。重写该函数，使得在循环内部只执行一次测试，比较两种版本函数的运行时间。
/* binsearch: find x in v[0] <= v[1] <= ... <= v[n-1] */
int binsearch(int x, int v[], int n)
{
int low, high, mid; low = 0;
high = n - 1;
mid = (low+high) / 2;
while(low <= high && x != v[mid])
{
if(x < v[mid])
high = mid - 1;
else
low = mid + 1;
mid = (low+high) / 2;
}
if(x == v[mid])
return mid; // found match
else
return -1; // no match
}
两种方案的执行时间几乎没有差异，我们并没有得到多大的性能改进，反而失掉了代码的可读性。
2、可视化转义字符与实际字符的双向转换
编写一个函数escape(s, t)，将字符串t 复制到字符串s 中，并在复制的过程中将换行符、制表符等等不可显地字符分别转换为\n、\t等相应的可显示的转义字符序列。要求使用switch语句，再编写一个具有相反功能的函数，在复制过程中将转义字符序列转换为实际字符。
/* escape: expand newline and tab into visible sequences while copying the string t to s */
void escape(char s[], char t[])
{
int i, j; for(i = j = 0; t[i] != '\0'; i++)
{
switch(t[i])
{
case '\n': // newline
s[j++] = '\\';
s[j++] = 'n';
break;
case '\t': // tab
s[j++] = '\\';
s[j++] = 't';
break;
default: // all other chars
s[j++] = t[i];
break;
}
}
s[j] = '\0';
}
unescape函数与escape函数很相似，如下：
/* unescape: convert escape sequences into real characters while copying the string t to s */
void unescape(char s[], char t[])
{
int i, j; for(i = j = 0; t[i] != '\0'; i++)
{
if(t[i] != '\\')
s[j++] = t[i];
else // it is a backslach
switch(t[++i])
{
case 'n': // real newline
s[j++] = '\n';
break;
case 't': // real tab
s[j++] = '\t';
break;
default: // all other chars
s[j++] = '\\';
s[j++] = t[i];
break;
}
}
s[j] = '\0';
}
switch语句是允许嵌套的，因此unescape 函数也可以这样写：
/* unescape: convert escape sequences into real characters while copying the string t to s */
void unescape(char s[], char t[])
{
int i, j; for(i = j = 0; t[i] != '\0'; i++)
{
switch(t[i])
{
case '\\': // backslach
switch(t[++i])
{
case 'n': // real newline
s[j++] = '\n';
break;
case 't': // real tab
s[j++] = '\t';
break;
default: // all other chars
s[j++] = '\\';
s[j++] = t[i];
break;
}
break;
default: // not a backslach
s[j++] = t[i];
break;
}
}
s[j] = '\0';
}
3、正如TCPL读书笔记&心得中第33条阐述的那样，我们先前编写的itoa 函数不能处理绝对值最大的负数，因为在整形32位二进制数字的表示中，最大的负数取负，在机器底层上得到的结果仍然为最大的负数（也就是相应正数溢出的结果），这里我们的想法是把取模操作的结果转换为正数，从而绕过无法把最大的负数转换为正数的问题。
#include <stdio.h>
#define abs(x) ((x) < 0 ? -(x) : (x)) // itoa: convert n to characters in s - modified
void itoa(int n, char s[])
{
int i, sign;
void reverse(char s[]); sign = n; // record sign
i = 0;
do{ // generate digits in reverse order
s[i++] = abs(n % 10) + '0'; // get next digit
}while((n /= 10) != 0); // delete it
if(sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
当然了，还可以采取一种措施，就是先判断该数字是不是最大的负数，如果是就进行特殊处理，不过这样做比较浪费资源，要额外多进行一次比较操作。
4、编写函数，将字符串s1中的速记符号在s2中扩展为等价的完整列表
编写函数expand(s1, s2)，将字符串s1 中类似于a-z 一类的速记符号在字符串s2 中扩展为等价的完整列表abc···xyz。该函数可以处理大小写字母和数字，并可以处理a-b-c、a-z0-9 与a-z 等类似的情况。作为前导和尾随的字符原样复制。
/* expand: expand shorthand notation in s1 into string s2 */
void expand(char s1[], char s2[])
{
char c; int i, j;
while((c = s1[i++]) != '\0') // fetch a char from s1[]
{
if(s1[i] == '-' && s1[i+1] >= c)
{
i++;
while(c < s1[i]) // expand shorthand
s2[j++] = c++;
}
else
s2[j++] = c; // copy the character
}
s2[j] = '\0';
}
5、编写函数itob(n, s, b)，将整数n转换为以b为底的数，并将结果以字符的形式保存到字符串s中。例如，itob(n, s, 16)把整数n格式化成十六进制整数保存在s中。
思路：先按逆序生成b进制数的每一位数字，再用函数reverse(自行编写，非库函数)对字符串s中的字符做一次颠倒而得到最终的结果。
/* itob: convert n to characters in s - base b */
void itob(int n, char s[], int b)
{
int i, j, sign;
void reverse(char s[]); if((sign = n) < 0) // record sign
n = -n; // make n positive
i = 0;
do // generate digits in reverse order
{
j = n % b; // get next digit
s[i++] = (j <= 9) ? j+'0' : j+'a'-10;
}while((n /= b) > 0); // delete it
if(sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}