冒泡排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void bubble_sort(int array[],int n)
{
int i,j,tmp;
for(j=0;j<n-1;j++)
{
for(i=0;i<n-1-j;i++)
{
if(array[i]>array[i+1])
{
tmp = array[i];
array[i] = array[i+1];
array[i+1] = tmp;
}
}
}
}
int main (int argc, char **argv)
{
int a[6] = {5,2,6,4,1,3};
bubble_sort(a,6);
int i = 0;
for(i;i<6;i++)
printf("%d\n",a[i]);
return 0;
}
strstr （判斷子串）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
const char *my_strstr(const char *str,const char *sub_str)
{
int i;
for(i=0;str[i]!='\0';i++)
{
int tmp = i;
int j=0;
while(str[i++]==sub_str[j++])
{
if(sub_str[j]=='\0')
return &str[tmp];
}
i = tmp;
}
return NULL;
}
int main(void)
{
char *s1="12345";
char *s2="34";
printf("%s\n",my_strstr(s1,s2));
}
strcpy（字符串複製）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
char *my_strcpy(char *dest, const char *src)
{
assert(dest);
assert(src);
char *tmp = dest;
while((*dest++=*src++)!='\0')
;
return tmp;
}
int main(int argc, char ** argv)
{
char a[10];
char *b = "hello";
printf("%s\n",my_strcpy(a,b));
return 0;
}
strncpy（複製子串前n個字節）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
char *my_strncpy(char *dst, const char *src,size_t count)
{
assert(dst&&src);
char *tmp = dst;
while(count)
{
if((*dst=*src)!=0)
{
dst++;
src++;
}
count--;
}
*dst = '\0';
return tmp;
}
int main()
{
char a[5] = "hello";
char *b = "12345";
printf("%s\n",my_strncpy(a,b,6));
}
strcat（字符串連接）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
char *my_strcat(char *dest, const char *src)
{
assert(dest);
assert(src);
char *tmp = dest;
while(*dest)
dest++;
while((*dest++=*src++)!='\0')
;
return tmp;
}
int main(int argc, char ** argv)
{
char a[10] = "world";
char *b = "hello";
printf("%s\n",my_strcat(a,b));
return 0;
}
strncat
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
char *my_strncat(char *dest, const char *src, size_t count)
{
assert(dest);
assert(src);
char *tmp = dest;
if(count)
{
while(*dest)
dest++;
while((*dest++=*src++)!='\0')
<span> </span>{
if(--count==0)
{
*dest = '\0';
break;
}
<span> </span>}
}
return tmp;
}
int main(int argc, char ** argv)
{
char a[10] = "world";
char *b = "hello";
printf("%s\n",my_strncat(a,b,3));
return 0;
}
strcmp（字符串比較）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int my_strcmp(const char *cs, const char *ct)
{
assert(cs);
assert(ct);
unsigned char c1,c2;
while(1)
{
c1 = *cs++;
c2 = *ct++;
if(c1!=c2)
return c1 < c2 ? -1 : 1;
if(!c1)
break;
}
return 0;
}
int main(int argc, char ** argv)
{
char a[10] = "gello";
char *b = "hello";
printf("%d\n",my_strcmp(a,b));
return 0;
}
memmove：
#include<stdio.h>
#include<assert.h>
void my_memmove(void *p1,void const *p2,size_t count)
{
assert(p1);
assert(p2);
char *dest = (char *)p1;
char *src = (char *)p2;
if((dest > src) && (dest < src +count)) //判斷內存重疊時的情況
{
while(count--)
{
*(dest + count) = *(src + count);
}
}
else //判斷不重疊是的情況
{
while(count--)
{
*dest++ = *src++;
}
return p1;
}
}
int main()
{
int arr1[10]={1,2,3,4,5,6,7,8,9,10};
int i = 0;
my_memmove(arr1+4,arr1+2,16);
for(i=0;i<10;i++)
{
printf("%d ",arr1[i]);
}
printf("\n");
return 0;
}
memcpy
void *memcpy(void *dest, const void *src, size_t count)
{
char *tmp = dest;
const char *s = src;
while (count--)
*tmp++ = *s++;
return dest;
}
字符串逆序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
char *reverse(char *dest, const char *src)
{
assert(dest);
assert(src);
char *tmp = dest;
int len,i;
len = strlen(src);
dest[len] = '\0';
for(i=0;i<len;i++)
{
*(dest+i) = *(src+len-i-1);
}
return tmp;
}
int main(int argc, char ** argv)
{
char a[10];
char *b = "abcde";
printf("%s\n",reverse(a,b));
return 0;
}
二分法/折半法
#include<stdio.h>
//遞歸算法
int recurbinary(int *a, int key, int low, int high)
{
int mid;
if(low > high)
return -1;
mid = low + (high-low)/2;
if(a[mid] == key) return mid;
else if(a[mid] > key)
return recurbinary(a,key,low,mid -1);
else
return recurbinary(a,key,mid + 1,high);
}
//非遞歸算法
int binary( int *a, int key, int n )
{
int left = 0, right = n - 1, mid = 0;
mid = left + (right - left) / 2;
while( left < right && a[mid] != key )
{
if( a[mid] < key ) {
left = mid + 1;
} else if( a[mid] > key ) {
right = mid;
}
mid = ( left + right ) / 2;
}
if( a[mid] == key )
return mid;
return -1;
}
int main()
{
int a[] = {1,2,3,4,5,6,7,8,9,12,13,45,67,89,99,101,111,123,134,565,677};
int b[] = {677,1,7,11,67};
int i;
for( i=0; i<sizeof(b)/sizeof(b[0]); i++ )
{
//printf( "%d\n", recurbinary(a, b[i],0,sizeof(a)/sizeof(a[0])-1) );
printf( "%d\n", binary( a, b[i], sizeof(a)/sizeof(a[0])));
}
return 0;
}
volatile關鍵字
定義爲volatile的變量表示該變量可能被意想不到的改變，使用該變量時，必須每次重新從內存中讀取數據，而不是使用保存在寄存器中的備份。
eg：
（1）並行設備的硬件寄存器；如狀態寄存器
（2）一箇中斷服務子程序中會訪問的非自動變量；
（3）多線程應用中被幾個任務共享的變量；
static關鍵字
（1）函數體內static變量的作用範圍爲該函數體，不同於auto變量，該變量的內存只被分配一次，因此其值在下次調用時仍維持上次的值；
（2）在模塊內的static全局變量可以被模塊內所用函數訪問，但不能被模塊外其它函數訪問；
（3）在模塊內的static函數只可被這一模塊內的其它函數調用，這個函數的使用範圍被限制在聲明它的模塊內；
const關鍵字
（1）欲阻止一個變量被改變，可以使用const關鍵字。在定義該const變量時，通常需要對它進行初始化，因爲以後就沒有機會再去改變它了；
（2）對指針來說，可以指定指針本身爲const，也可以指定指針所指的數據爲const，或二者同時指定爲const；
（3）在一個函數聲明中，const可以修飾形參，表明它是一個輸入參數，在函數內部不能改變其值；
（4）對於類的成員函數，若指定其爲const類型，則表明其是一個常函數，不能修改類的成員變量；