复习 C语言

今天把开课为止，所有的作业做了一遍

#include <stdio.h>


int my_strlen(char *str);
char *my_strcpy(char *dest, char *src);
char *my_strncpy(char *dest, char *src, int n);
char *reverse(char *str);
void bubble_sort(int *str, int n);
int fibe_frac(int n);
void fibe_iteration(int n);
int *fibswap(int *a, int *b, int *c);
int bin_search(int *array,int start, int stop, int target);
int bin_search_recursion(int *array,int start, int stop, int target);
int fractorial_iteration(int n);
int fractorial(int n);

void test_sort();
void test_strlen();
void test_my_strcpy();

int input_num();
void print_string(char *str);
void printf_array(int *a, int n);


int main()
{
    int i = 0;
    int n = 0;
    test_strlen();
    test_my_strcpy();
    test_sort();
    n = input_num();
    for (i = 0; i < n; ++i)
    {
        printf("%d ",fibe_frac(i));
    }
    printf("
");

    printf("The fractorial is %d.
",fractorial_iteration(input_num()));

    return 0;
}

/*
*****************************************************************
*/


/*
*   calculate the length of the string
*/
int my_strlen(char *str)  
{
    int len = 0;

    while(*str != '')
    {
        str ++;
        len ++;
    }

    return len;
}

/*
*   reverse the string
*/
char *reverse(char *str)  
{
    int i = 0;
    int len = my_strlen(str);
    char tmp = 0;
    for (i = 0; i < len /2; i ++)
    {
        tmp = *(str + i);
        *(str + i) = *(str + len - i - 1);
        *(str + len - i -1) = tmp;
    }
    return str;
}

/*
********************************************************************
*/

/*
*   Make sure the length of dest is bigger than or equals to src.
*/
char *my_strcpy(char *dest, char *src)  
{
    char *tmp = dest;
    while (*src != '')
    {
        *dest = *src;
        dest ++;
        src ++;
    }
    *dest = '';

    return tmp;
}


/*
*   Copy string to n
*/
char *my_strncpy(char *dest, char *src, int n) 
{
    char *tmp = dest;
    int i = 0;
    for (i = 0; i < n; i++)
    {
        if(*src == '')
        {
            break;
        }

        *dest = *src;
        dest ++;
        src ++;
    }

    *dest = '';
    return tmp;
}

/*
****************************************************************
*/

/*
* bubble sort
*/
void bubble_sort(int *str, int n)
{
    int i, j;
    char tmp;
    for (i = 0; i < n; ++i)
    {
        for (j = 0; j < n - i - 1; ++j)
        {
            if (str[j] > str[j + 1])
            {
                tmp = str[j];
                str[j] = str[j + 1];
                str[j + 1] = tmp;
            }
        }
    }
}

/*
* BinSearch
*/
int bin_search(int *array,int start, int stop, int target)
{
    int mid; 
    while (start <= stop)
    {
        mid = (start + stop) / 2;
        if (target == array[mid])
        {
            return mid;
        }
        else if (target > array[mid])
        {
            start = mid +1;

        }
        else
        {
            stop = mid -1;
        }
    }
    return -1;
}


int bin_search_recursion(int *array,int start, int stop, int target)
{
    int mid = (start + stop) / 2;
    if (start > stop )
    {
        return -1;
    }
    if (array[mid] == target)
    {
        return mid;
    }
    else if (array[mid] > target)
    {
        stop = mid -1;
    }
    else
    {
        start = mid +1;
    }
    return bin_search_recursion(array,start,stop,target);
}

/*
**********************************************************************
*/

/*
*   fib
*/

int fibe_frac(int n)
{

    if ((n == 0) || (n == 1))
    {
        return n;
    }
    else
    {
        //printf("%d ", n);
        return (fibe_frac(n - 1) + fibe_frac(n - 2));
    }
}

void fibe_iteration(int n)
{
    int i ;
    int a[3] = { 0, 0, 0};
    for ( i = 0; i < n; ++i)
    {
        if (i < 2)
        {
            a[2] = i;
            printf("%d ", a[2]);
            fibswap( &a[0], &a[1], &a[2]);
        }
        else
        {
            printf("%d ", a[2]);
            fibswap( &a[0], &a[1], &a[2]);
        }
    }
    printf("
");
}

int *fibswap(int *a, int *b, int *c)
{

    int temp = *b + *c;
    temp = *b + *c;
    *a = *b;
    *b = *c;
    *c = temp;
    return a;
}

/*
***********************************************************
*/

/*
*  fracorial
*/

int fractorial(int n)
{
    if ((n == 1) || (n == 0))
    {
        return 1;
    }
    else
    {
        return n*fractorial(n - 1);
    }

}

int fractorial_iteration(int n)
{
    int i = 0;
    int frac = 1;
    for (i = 1; i <= n; ++i)
    {
        frac *= i;
    }
    return frac;
}


/*
***************************************************************
*/

void test_sort()
{
    // sort
    int target = 0;
    int index;
    int len = 0;
    int a[15] = { 13, 25, 45, 57, 89,
                  70, 97, 55, 43, 21,
                  32, 65, 75, 37, 65};

    len = sizeof(a)/sizeof(a[0]);
    bubble_sort(a,len);
    printf_array(a,len);

    //input
    target = input_num();

    // search
    index = bin_search_recursion(a,0,len,target);
    if (index < 0)
    {
        printf("No target find, your target is not in the range.
");
    }
    else
    {
        printf("Your target is %d.
",index);
    }

}

void test_strlen()
{
    char *p = "Hello world!";
    printf("%s
",p);
    printf("%d
",my_strlen(p));
}




void test_my_strcpy()
{
    char *p = "Hello world! hello";
    char dest[20] = {};

    p = my_strncpy(dest,p,13);

    print_string(p);
    p = reverse(dest);
    print_string(p);
}


/*
*******************************************************************
*/

void print_string(char *str)
{
    int n = my_strlen(str);
    int i = 0;

    for(i = 0; i < n; i ++)
    {
        printf("%c",str[i]);
    }

    printf("
");
}

void printf_array(int *a, int n)
{
    int i = 0;

    for (i = 0; i < n; ++i)
    {
        printf("%d ",a[i]);
    }
    printf("
");
}


int input_num()
{
    int num = 0;
    printf("Please input a number
");
    scanf("%d", &num );
    return num;
}

包括 冒泡排序 二分法排序 阶乘 求字符串长度 复制字符串 字符串反转  部分有递归和迭代的方式