c/c++笔试面试经典函数实现 

 1 /* strcpy函数实现 拷贝字符串 */
 2 char* Strcpy(char* dst, char* src)
 3 {
 4     assert(dst != NULL && src != NULL); // 断言　dst和src不能为NULL
 5 
 6     char* dst_address = dst; // 保存目的地址
 7 
 8     while((*(dst++) = *(src++)) != '\0')
 9     {
10         /* do nothing */
11     }
12 
13     return dst_address; // 返回目的地址 允许链式表达式
14 }
15 
16 /* strncpy函数实现*/
17 
18 char* Strncpy(char* dst, const char* src, size_t num)
19 {
20     assert(dst != NULL && src != NULL); // 断言　dst和src不能为NULL
21 
22     char* dst_address = dst;
23 
24     size_t i = 0; // 控制复制的个数
25     while(i++ < num && (*dst++ = *src++) != '\0')
26     {
27         /* do nothing */
28     }
29 
30     if(*dst != '\0') // 字符必须以'\0'结尾
31     {
32         *dst = '\0';
33     }
34 
35     return dst_address;
36 }
37 
38 size_t Strlen(const char *str)
39 {
40     assert(str != NULL);
41 
42     int count = 0;
43 
44     while(*str++ != '\0')
45     {
46         ++count;
47     }
48 
49     return count;
50 }
51 
52 void* Memcpy( void *dest, const void *src, size_t count )
53 {
54     assert(dest != NULL && src != NULL);
55 
56     char* _dest = (char*)dest;
57     char* _src = (char*)src;
58 
59     while (count--)
60     {
61         *_dest++ = *_src++;
62     }
63 
64     return dest;
65 }
66 
67 void * Memmove ( void * destination, const void * source, size_t num )
68 {
69     char* _dst = NULL;
70     char* _src = NULL;
71 
72     if(destination <= source)
73     {
74         _dst = destination;
75         _src = source;
76 
77         while (num--)
78         {
79             *_dst++ = *_src++;
80         }
81     }
82     else
83     {
84         _dst = destination;
85         _src = source;
86 
87         _dst += num;
88         _src += num;
89 
90         while (num--)
91         {
92             *--_dst = *--_src;
93         }
94     }
95 }

 

 1 int FibonacciSequence(unsigned int n)
 2 {
 3     if(1 == n || 0 == n)
 4     {
 5         return n;
 6     }
 7     else
 8     {
 9         return FibonacciSequence(n-1)+FibonacciSequence(n-2);
10     }
11 }
 1 int BinSearch(int* arr, int left, int right, int key)
 2 {
 3     if(!arr)
 4     {
 5         return -1;
 6     }
 7 
 8     while (left <= right)
 9     {
10         int mid = left + ((right - left) >> 1);
11 
12         if(arr[mid] < key)
13         {
14             left = mid + 1;
15         }
16         else if(arr[mid] > key)
17         {
18             right = mid - 1;
19         }
20         else
21         {
22             return mid;
23         }
24     }
25     return -1;
26 }
 1 // 插入排序
 2 void InsertionSort(int* arr, int len)
 3 {
 4     for(int j = 1; j < len; ++j)
 5     {
 6         int i = j - 1;
 7         int key = arr[j];
 8 
 9         while(i >= 0 && a[i] > key)
10         {
11             a[i+1] = a[i];
12             --i;
13         }
14         arr[i+1] = key;
15     }
16 }

 

 1 int Partition(vector<int>& vec, int low, int up)
 2 {
 3     int pivot = vec[up];
 4     int i = low - 1;
 5 
 6     for(int j = low; j < up; ++j)
 7     {
 8         if(vec[i] < pivot)
 9         {
10             ++i;
11             std::swap(vec[i], vec[j]);
12         }
13     }
14     std::swap(vec[i+1], vec[up]);
15 
16     return i+1;
17 }
18 
19 void QuickSort(vector<int>& vec, int low, int up)
20 {
21     if(low < up)
22     {
23         int mid = Partition(vec, low, up);
24 
25         QuickSort(vec, low, mid - 1);
26         QuickSort(vec, mid + 1, up);
27     }
28 }
29 
30 void Sort(vector<int>& vec)
31 {
32     QuickSort(vec, 0, vec.size() - 1);
33 }

 

template <typename T>
int BinSearch(std::vector<T>& array, T key)
{
    int left = 0;
    int right = array.size();

    while (left < right)
    {
        int mid = (left + right) >> 1; // 中点

        if (array[mid] < key)
        {
            left = mid;
        }
        else if (key < array[mid])
        {
            right = mid;
        }
        else
        {
            return mid;
        }
    }

    return -1; // 查找失败
}

 

posted @ 2016-09-12 22:01  Ricardo  阅读(569)  评论(0)    收藏  举报