面试必会函数源代码

笔试面试必会代码

链表：

在链表中找到第一个含有某值的节点并删除该结点

从头到尾打印链表

合并两个排序链表

反转链表

链表中倒数第k个结点

O(1)时间删除链表结点

复杂链表的复制

两个链表的第一个公共结点

 

二叉树：

深度优先遍历

广度优先遍历

求二叉树的深度和宽度或者面积

重建二叉树

判断树a是不是树b的子结构

二叉树镜像

从上往下打印二叉树

二叉树的后序遍历序列

二叉树中和为某一值的路径

二叉搜索树变成双向链表

 

字符串：

Strstr(kmp)

Strcmp

Strcpy

Memcpy

字典树

线段树

后缀树判断最长重复子串

字符串中替换空格

字符串的全排列

翻转单词顺序/左旋转字符串

字符串转化成整数

 

其他数据结构：

两个栈实现队列

两个队列实现一个栈

包含min函数的栈

栈的压入弹出序列

 

算法：

Quick sort

二进制中1的个数

二维数组中的数的查找

旋转数组中的最小数字

打印1到最大n位数（数组模拟）

调整数组顺序使奇数位于偶数前面

顺时针打印矩阵

数组中次数超过一半的数字

最小的k个数

数组排成最小的数

丑数

数组中第一个只出现一个的字符

数组中的逆序对

数在数组中出现的次数

数组中一个只出现一次的数字（其他都出现两次）

数组中两个只出现一次的数字（其他都出现两次）

数组中三个只出现一次的数字（其他都出现两次）

数组中和威s额两个数字/和为s的连续正数序列

N个骰子的点数

扑克牌的顺子

圆圈中最后剩下的数字（约瑟夫环）

 

动态规划：

求一个序列的最大连续子序列乘积

连续数组的最大和

 

 

C++特性：

不用for while if else switch case 以及 ?: 求1+2+……+n的的和

深拷贝与浅拷贝

设计一个不能被继承的类

内存分配的代码

手动修改栈空间

不用sizeof如何判断操作系统是16位还是32位

大小端

不用+号进行加法运算

不用/号进行除法运算

 

设计模式：

实现一个单例模式

必看书籍

必看：

《剑指offer》 《编程之美》 《程序员面试笔试宝典》

选看：

《算法导论》 《tcp/ip详解 卷一》 《unix环境高级编程》 《算法导论》 《编程珠玑》

c++：

《effective C++》

java：

《effective java》 《java编程思想》

python：

《python基础教程》 《Head First Python》

一、写在前面

        继上一次发表了一片关于参加秋招的学弟学妹们如何准备找工作的博客之后，反响很大，顾在此整理一下，以便大家复习。好多源自july的这篇博客，也有很多是我自己整理的。希望大家能够一遍一遍的写，直到能够秒杀为止。

二、stl模板函数

    1、strcpy

char * strcpy( char *strDest, const char *strSrc )
{
    if(strDest == strSrc) { return strDest; }
    assert( (strDest != NULL) && (strSrc != NULL) );
    char *address = strDest;
    while( (*strDest++ = * strSrc++) != '\0' );
    return address;
}

    2、strncpy

"font-size:18px;">char *strncpy(char *strDes, const char *strSrc, unsigned int count)
{
    assert(strDes != NULL && strSrc != NULL);
    char *address = strDes;
    while (count-- && *strSrc != '\0')
        *strDes++ = *strSrc++;
    *strDes = '\0';
    return address;
}

    3、strcmp

int strcmp(const char *s, const char *t)
{
    assert(s != NULL && t != NULL);
    while (*s && *t && *s == *t)
    {
        ++ s;
        ++ t;
    }
    return (*s - *t);
}

    4、strcat

char *strcat(char *strDes, const char *strSrc)
{
    assert((strDes != NULL) && (strSrc != NULL));
    char *address = strDes;
    while (*strDes != '\0')
        ++ strDes;
    while ((*strDes ++ = *strSrc ++) != '\0')
        NULL;
    return address;
}

    5、strlen

int strlen(const char *str)
{
    assert(str != NULL);
    int len = 0;
    while (*str ++ != '\0')
        ++ len;
    return len;
}

    6、strstr

char *strstr(const char *strSrc, const char *str)
{
    assert(strSrc != NULL && str != NULL);
    const char *s = strSrc;
    const char *t = str;
    for (; *strSrc != '\0'; ++ strSrc)
    {
        for (s = strSrc, t = str; *t != '\0' && *s == *t; ++s, ++t)
            NULL;
        if (*t == '\0')
            return (char *) strSrc;
    }
    return NULL;
}

    7、strncat

char *strncat(char *strDes, const char *strSrc, unsigned int count)
{
    assert((strDes != NULL) && (strSrc != NULL));
    char *address = strDes;
    while (*strDes != '\0')
        ++ strDes;
    while (count -- && *strSrc != '\0' )
        *strDes ++ = *strSrc ++;
    *strDes = '\0';
    return address;
}

    8、strncmp

int strncmp(const char *s, const char *t, unsigned int count)
{
    assert((s != NULL) && (t != NULL));
    while (*s && *t && *s == *t && count --)
    {
        ++ s;
        ++ t;
    }
    return (*s - *t);
}

    9、memcpy

void *memcpy(void *dest, const void *src, unsigned int count)
{
    assert((dest != NULL) && (src != NULL));
    void *address = dest;
    while (count --)
    {
        *(char *) dest = *(char *) src;
        dest = (char *) dest + 1;
        src = (char *) src + 1;
    }
    return address;
}

    10、memccpy

void *memccpy(void *dest, const void *src, int c, unsigned int count)
{
    assert((dest != NULL) && (src != NULL));
    while (count --)
    {
        *(char *) dest = *(char *) src;
        if (* (char *) src == (char) c)
            return ((char *)dest + 1);
        dest = (char *) dest + 1;
        src = (char *) src + 1;
    }
    return NULL;
}

    11、memcmp

int memcmp(const void *s, const void *t, unsigned int count)
{
    assert((s != NULL) && (t != NULL));
    while (*(char *) s && *(char *) t && *(char *) s == *(char *) t && count --)
    {
        s = (char *) s + 1;
        t = (char *) t + 1;
    }
    return (*(char *) s - *(char *) t);
}

    12、memmove

//@big：
//要处理src和dest有重叠的情况，不是从尾巴开始移动就没问题了。
//一种情况是dest小于src有重叠，这个时候要从头开始移动，
//另一种是dest大于src有重叠，这个时候要从尾开始移动。
void *memmove(void *dest, const void *src, unsigned int count)
{
    assert(dest != NULL && src != NULL);
    char* pdest = (char*) dest;
    char* psrc = (char*) src;

    //pdest在psrc后面，且两者距离小于count时，从尾部开始移动. 其他情况从头部开始移动
    if (pdest > psrc && pdest - psrc < count)
    {
        while (count--)
        {
            *(pdest + count) = *(psrc + count);
        }
    } else
    {
        while (count--)
        {
            *pdest++ = *psrc++;
        }
    }
    return dest;
}

    13、memset

void *memset(void *str, int c, unsigned int count)
{
    assert(str != NULL);
    void *s = str;
    while (count --)
    {
        *(char *) s = (char) c;
        s = (char *) s + 1;
    }
    return str;
}

三、atoi && itoa

    1、atoi

//代码自己所写，不对地方请及时指正，谢谢！
//inf用来标记作为判断是否越界
//atoiFlag作为是否是正确结果的返回值
const __int64 inf = (0x7fffffff);
int atoiFlag;
int atoi(const char* ch)
{
    ASSERT(ch != NULL);
    atoiFlag = false;
    while (*ch == ' ' || *ch == '\t')
        ch ++;
    int isMinus = 1;
    if (*ch == '-')
    {
        isMinus = -1;
        ch ++;
    }
    else if (*ch == '+')
    {
        ch ++;
    }
    //判断非法
    if (!(*ch <= '9' && *ch >= '0'))
        return 0;
    __int64 ans = 0;
    while (*ch && *ch <= '9' && *ch >= '0')
    {
        ans *= 10;
        ans += *ch - '0';
        //判断越界
        if (ans > inf)
        {
            return inf;
        }
        ch ++;
    }
    ans *= isMinus;
    atoiFlag = true;
    return (int)ans;
}

//如何使用
int main()
{
    char a[100];
    while (scanf("%s", a) != EOF)
    {
        int ans = atoi(a);
        if (atoiFlag)
            printf("%d\n", ans);
        else if (ans == inf)
            puts("The data of crossing the line");
        else
            puts("Not is a integer");
    }
    return 0;
}

    2、itoa

#include
#include
char *myitoa(int num,char *str,int radix);
int main()
{
    int number = -123456;
    char string[25];
    myitoa(number, string, 16);
    printf("integer = %d string = %s\n", number, string);
    return 0;
}
/* 实现itoa函数的源代码 */
char *myitoa(int num,char *str,int radix)
{
    /* 索引表 */
    char index[]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    unsigned unum; /* 中间变量 */
    int i=0,j,k;
    /* 确定unum的值 */
    if(radix==10&&num<0) /* 十进制负数 */
    {
        unum=(unsigned)-num;
        str[i++]='-';
    }
    else unum=(unsigned)num; /* 其他情况 */
    /* 逆序 */
    do
    {
        str[i++]=index[unum%(unsigned)radix];
        unum/=radix;
    }while(unum);
    str[i]='\0';
    /* 转换 */
    if(str[0]=='-') k=1; /* 十进制负数 */
    else k=0;
    /* 将原来的“/2”改为“/2.0”，保证当num在16~255之间，radix等于16时，也能得到正确结果 */
    char temp;
    for(j=k;j<=(i-k-1)/2.0;j++)
    {
        temp=str[j];
        str[j]=str[i-j-1];
        str[i-j-1]=temp;
    }
    return str;
}

四、kmp  &&  quicksort

    1、kmp

void getNext(const char* p, int next[])
{
    next[0] = -1;
    int index = 0;
    int p_l = strlen(p);
    for (int i=1; i
    {
        index = next[i-1];
        while (index >= 0 && p[index+1] != p[i])
        {
            index = next[index];
        }
        if (p[index+1] == p[i])
        {
            next[i] = index + 1;
        }
        else
        {
            next[i] = -1;
        }
    }
}

int kmp(const char* t, const char* p)
{
    const int t_l = strlen(t);
    const int p_l = strlen(p);
    int Next = new int[p_l + 1];
    getNext(p, Next);
    int p_index = 0, t_index = 0;

    int cnt = 0;

    while (p_index < p_l && t_index < t_l)
    {
        if (t[t_index] == p[p_index])
        {
            t_index ++;
            p_index ++;
        }
        else if (p_index == 0)
        {
            t_index ++;
        }
        else
        {
            p_index = Next[p_index-1] + 1;
        }
        if (p_index == p_l)
        {
            cnt ++;
            p_index = Next[p_index-1] + 1;
        }
    }
    delete[] Next;
    return cnt;
}

    2、quicksort

#include
#include
#include

int partion(int a[], int p, int r)
{
    srand((unsigned)time(NULL));
    int e = rand()%(r-p+1)+p;
    int tmp = a[e];
    a[e] = a[r];
    a[r] = tmp;
    int x = a[r];
    int i, j;
    i = p;
    for (j=p; j
    {
        if (a[j] <= x)
        {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
            i ++;
        }
    }
    tmp = a[r];
    a[r] = a[i];
    a[i] = tmp;
    return i;
}

void QuickSort(int a[], int p, int r)
{
    if (p < r)
    {
        int q = partion(a, p, r);
        QuickSort(a, p, q-1);
        QuickSort(a, q+1, r);
    }
}

int main()
{
    int a[] = {1,2,3,-1,5,-9,10,33,0};
    QuickSort(a, 0, 8);
    for (int i=0; i<9; i++)
    {
        printf("%d\t", a[i]);
    }
    return 0;
}