C

1.使用C语言实现字符串、句子的倒序。

/*实现字符串的反转*/
char *reserve_str(char *a,int len)
  {
           int i;
           char t;
          for(i=0;i<len/2;i++)
          {
                  t=a[i];
                 a[i]=a[len-i-1];
                 a[len-i-1]=t;
         }
         return a;
 }
 /*实现句子的倒叙
 先将整个句子字母反转，再将句子里的单词再次反转*/
 char* reserve_word(char *str)
 {
          if(str==NULL)
                  return 0;
          reserve_str(str,strlen(str));//将整个句子字母反转
          
          char *pBegin=str;
          char *pEnd=str;
 
          while(*pEnd!='\0')
          {			/*得到一个单词后，将单词字母反转*/
                  while(*pEnd!='\0'&&*pEnd!=' ')
                          ++pEnd;
                  reserve_str(pBegin,pEnd-pBegin);//
                  if(*pEnd=='\0')
                          break;
                 ++pEnd;//进入下一个单词
                  pBegin=pEnd;
         }
         return str;
  }

int main()
{
        char *str;
        char name[128],c;
        char i=0;
        printf("enter string:\n");
        while(c!='\n')
         {
                 c=getchar();
                 name[i++]=c;
          }
         if(c=='\n')
          name[i-1]='\0';//将最后一个'\n'换为'\0'

         //char name[]="aaa bbb ccc";
          str=reserve_word(name);
        printf("%s\n",str);
        return 0;
}

char *p=“abcde”；的时候，字符串是不可以修改的！
而char p[]=“abcde”;的时候，字符串是可以修改的！
同一个字符串，用指针定义的时候在常量区，而用数组定义的时候在栈中。

2.位转换
位 8 7 6 5 4 3 2 1
数 v8 v7 v6 v5 v4 v3 v2 v1
转换后：
位 8 7 6 5 4 3 2 1
数 v1 v2 v3 v4 v5 v6 v7 v8

unsigned char bit_reverse(unsigned char c)
{
　　unsigned char buf = 0;
　　int bit = 8;
　　while(bit)
　　{
　　bit–;
　　buf |= ((c & 1) << bit);
　　c >>=1;
　　}
　　return buf;

3、二分法查找

 int binary_search(int array[],int value,int size)
{
 int low=0,high=size-1,mid;
 
 while(low<=high)    //只要高低不碰头就继续二分查找
 {
  mid=(low+high)/2;
  if(value==array[mid])  //比较是不是与中间元素相等
   return mid;
  else if(value > array[mid]) //每查找一次，就判断一次所要查找变量所在范围，并继续二分
   low=mid;     //如果大于中间值，下限移到中间的后一个位，上限不变，往高方向二分
  else
   high=mid;        //上限移到中间的前一个位，往低方向二分
 }
 return -1;
}

4.单向链表逆序

LONDE *link_reverse(LNODE *head)
{
 LNODE *pCur,*pNext;
 if(head == NULL)
  return head;
 pCur = head->next;
 head->next=NULL;//反转后head->next为null
 /*pCur从第二个节点开始不断向后移动*/
 while(pCur != NULL)
 {
  pNext = pCur->next;//取出pCur的下一个节点
  pCur->next = head;//第二个节点指向第一个节点
  head = pCur;//新头节点
  pCur = pNext;//改变pCur，向后移动
 }
 return head;
}

5、实现strcpy、memcpy函数
char *strcpy(char *strDest, const char *strSrc)。其中，strDest是目的字符串，strSrc是源字符串。
不调用C++/C的字符串库函数，请编写函数strcpy

 char *strcpy(char *dest, const char *src)
 {
  	if (dest == NULL || src == NULL)
   		return NULL;
  	char *ret = dst; 
  	while ((*dst++=*src++)!='\0');  
    return ret;
 }

void * memcpy(void *dest,void *src,unsigned count )
{
	if (dest == NULL || src == NULL)
		return NULL;
		
	char* pdest =(char*) dest;
	char* psrc = (char*)src;
	while (count--)
	{
		*pdest++ = *psrc++;
	}
	return dest;
}

效率最高的算法
a=bx2 -> a=b<<1;
a=b/4 -> a=b>>2;
a=b%8 -> a=b&7;
a=b/8x8+b%4 -> a=((b>>3)<<3)+(b&3)
a=b*15 -> a=(b<<4)-b

length = sizeof(arr) / sizeof(int);