剑指Offer-第6章 面试中的各项能力

最新推荐文章于 2024-05-23 18:18:28 发布
最新推荐文章于 2024-05-23 18:18:28 发布
阅读量46 收藏
点赞数
文章标签： 面试 数据结构与算法
原文链接：http://www.cnblogs.com/xkfz007/archive/2012/11/07/2758257.html
版权

 

clip_image002

#if 0
int GetFirstK(int* data, int length, int k, int start, int end);
int GetLastK(int* data, int length, int k, int start, int end);

int GetNumberOfK(int* data, int length, int k) {
    if(data==0||length<=0)
        return 0;
    int first=GetFirstK(data,length,k,0,length-1);
    int last=GetLastK(data,length,k,0,length-1);
    if(first>=0&&last>=0)
        return last-first+1;
    return 0;
}
int GetFirstK(int* data, int length, int k, int start, int end){
    if(start>end)
        return -1;
    int mid=(start+end)/2;
    if(data[mid]==k){
        if(mid==0||mid>0&&data[mid-1]!=k)
            return mid;
        end=mid-1;
    }
    else if(data[mid]>k)
        end=mid-1;
    else
        start=mid+1;
    return GetFirstK(data,length,k,start,end);
}
int GetLastK(int* data, int length, int k, int start, int end){
    if(start>end)
        return -1;
    int mid=(start+end)/2;
    if(data[mid]==k){
        if(mid==length-1||mid<length-1&&data[mid+1]!=k)
            return mid;
        start=mid+1;
    }
    else if(data[mid]>k)
        end=mid-1;
    else
        start=mid+1;
    return GetLastK(data,length,k,start,end);
}
// ====================测试代码====================
void Test(char* testName, int data[], int length, int k, int expected)
{
    if(testName != NULL)
        printf("%s begins: ", testName);

    int result = GetNumberOfK(data, length, k);
    if(result == expected)
        printf("Passed.\n");
    else
        printf("Failed.\n");
}

// 查找的数字出现在数组的中间
void Test1()
{
    int data[] = {1, 2, 3, 3, 3, 3, 4, 5};
    Test("Test1", data, sizeof(data) / sizeof(int), 3, 4);
}

// 查找的数组出现在数组的开头
void Test2()
{
    int data[] = {3, 3, 3, 3, 4, 5};
    Test("Test2", data, sizeof(data) / sizeof(int), 3, 4);
}

// 查找的数组出现在数组的结尾
void Test3()
{
    int data[] = {1, 2, 3, 3, 3, 3};
    Test("Test3", data, sizeof(data) / sizeof(int), 3, 4);
}

// 查找的数字不存在
void Test4()
{
    int data[] = {1, 3, 3, 3, 3, 4, 5};
    Test("Test4", data, sizeof(data) / sizeof(int), 2, 0);
}

// 查找的数字比第一个数字还小，不存在
void Test5()
{
    int data[] = {1, 3, 3, 3, 3, 4, 5};
    Test("Test5", data, sizeof(data) / sizeof(int), 0, 0);
}

// 查找的数字比最后一个数字还大，不存在
void Test6()
{
    int data[] = {1, 3, 3, 3, 3, 4, 5};
    Test("Test6", data, sizeof(data) / sizeof(int), 6, 0);
}

// 数组中的数字从头到尾都是查找的数字
void Test7()
{
    int data[] = {3, 3, 3, 3};
    Test("Test7", data, sizeof(data) / sizeof(int), 3, 4);
}

// 数组中的数字从头到尾只有一个重复的数字，不是查找的数字
void Test8()
{
    int data[] = {3, 3, 3, 3};
    Test("Test8", data, sizeof(data) / sizeof(int), 4, 0);
}

// 数组中只有一个数字，是查找的数字
void Test9()
{
    int data[] = {3};
    Test("Test9", data, sizeof(data) / sizeof(int), 3, 1);
}

// 数组中只有一个数字，不是查找的数字
void Test10()
{
    int data[] = {3};
    Test("Test10", data, sizeof(data) / sizeof(int), 4, 0);
}

// 鲁棒性测试，数组空指针
void Test11()
{
    Test("Test11", NULL, 0, 0, 0);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    Test7();
    Test8();
    Test9();
    Test10();
    Test11();

    return 0;
}
#endif

clip_image004

#if 0
int TreeDepth(BinaryTreeNode* pRoot)
{
    if(pRoot == NULL)
        return 0;

    int nLeft = TreeDepth(pRoot->m_pLeft);
    int nRight = TreeDepth(pRoot->m_pRight);

    return (nLeft > nRight) ? (nLeft + 1) : (nRight + 1);
}

// ====================测试代码====================
void Test(BinaryTreeNode* pRoot, int expected)
{
    int result = TreeDepth(pRoot);
    if(expected == result)
        printf("Test passed.\n");
    else
        printf("Test failed.\n");
}

//            1
//         /      \
//        2        3
//       /\         \
//      4  5         6
//        /
//       7
void Test1()
{
    printf("Test1 begins.\n");

    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);

    ConnectTreeNodes(pNode1, pNode2, pNode3);
    ConnectTreeNodes(pNode2, pNode4, pNode5);
    ConnectTreeNodes(pNode3, NULL, pNode6);
    ConnectTreeNodes(pNode5, pNode7, NULL);

    Test(pNode1, 4);

    DestroyTree(pNode1);
}

//               1
//              /
//             2
//            /
//           3
//          /
//         4
//        /
//       5
void Test2()
{
    printf("Test2 begins.\n");

    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode1, pNode2, NULL);
    ConnectTreeNodes(pNode2, pNode3, NULL);
    ConnectTreeNodes(pNode3, pNode4, NULL);
    ConnectTreeNodes(pNode4, pNode5, NULL);

    Test(pNode1, 5);

    DestroyTree(pNode1);
}

// 1
//  \
//   2
//    \
//     3
//      \
//       4
//        \
//         5
void Test3()
{
    printf("Test3 begins.\n");

    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode1, NULL, pNode2);
    ConnectTreeNodes(pNode2, NULL, pNode3);
    ConnectTreeNodes(pNode3, NULL, pNode4);
    ConnectTreeNodes(pNode4, NULL, pNode5);

    Test(pNode1, 5);

    DestroyTree(pNode1);
}

// 树中只有1个结点
void Test4()
{
    printf("Test4 begins.\n");

    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    Test(pNode1, 1);

    DestroyTree(pNode1);
}

// 树中没有结点
void Test5()
{
    printf("Test5 begins.\n");

    Test(NULL, 0);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();

    return 0;
}


#endif

clip_image006

#if 0
// ====================方法1====================
int TreeDepth(BinaryTreeNode* pRoot){
    if(pRoot==0)
        return 0;
    int left=TreeDepth(pRoot->m_pLeft);
    int right=TreeDepth(pRoot->m_pRight);
    return (left>right?left:right)+1;
}
bool IsBalanced_Solution1(BinaryTreeNode* pRoot){
    if(pRoot==0)
        return true;
    int left=TreeDepth(pRoot->m_pLeft),
        right=TreeDepth(pRoot->m_pRight);
    int diff=left-right;
    if(diff>1||diff<-1)
        return false;
    return IsBalanced_Solution1(pRoot->m_pLeft)&&
        IsBalanced_Solution1(pRoot->m_pRight);
}

// ====================方法2====================
bool IsBalanced(BinaryTreeNode* pRoot, int* pDepth);

bool IsBalanced_Solution2(BinaryTreeNode* pRoot) {
    int depth=0;
    return IsBalanced(pRoot,&depth);
}
bool IsBalanced(BinaryTreeNode* pRoot, int* pDepth){
    if(pRoot==0){
        *pDepth=0;
        return true;
    }
    int left=0,right=0;
    if(IsBalanced(pRoot->m_pLeft,&left)&&
            IsBalanced(pRoot->m_pRight,&right)){
        int diff=left-right;
        if(diff<=1&&diff>=-1){
            *pDepth=(left>right?left:right)+1;
            return true;
        }
    }
    return false;
}
// ====================测试代码====================
void Test(char* testName, BinaryTreeNode* pRoot, bool expected)
{
    if(testName != NULL)
        printf("%s begins:\n", testName);

    printf("Solution1 begins: ");
    if(IsBalanced_Solution1(pRoot) == expected)
        printf("Passed.\n");
    else
        printf("Failed.\n");

    printf("Solution2 begins: ");
    if(IsBalanced_Solution2(pRoot) == expected)
        printf("Passed.\n");
    else
        printf("Failed.\n");
}

// 完全二叉树
//             1
//         /      \
//        2        3
//       /\       / \
//      4  5     6   7
void Test1()
{
    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);

    ConnectTreeNodes(pNode1, pNode2, pNode3);
    ConnectTreeNodes(pNode2, pNode4, pNode5);
    ConnectTreeNodes(pNode3, pNode6, pNode7);

    Test("Test1", pNode1, true);

    DestroyTree(pNode1);
}

// 不是完全二叉树，但是平衡二叉树
//             1
//         /      \
//        2        3
//       /\         \
//      4  5         6
//        /
//       7
void Test2()
{
    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);

    ConnectTreeNodes(pNode1, pNode2, pNode3);
    ConnectTreeNodes(pNode2, pNode4, pNode5);
    ConnectTreeNodes(pNode3, NULL, pNode6);
    ConnectTreeNodes(pNode5, pNode7, NULL);

    Test("Test2", pNode1, true);

    DestroyTree(pNode1);
}

// 不是平衡二叉树
//             1
//         /      \
//        2        3
//       /\         
//      4  5        
//        /
//       6
void Test3()
{
    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);

    ConnectTreeNodes(pNode1, pNode2, pNode3);
    ConnectTreeNodes(pNode2, pNode4, pNode5);
    ConnectTreeNodes(pNode5, pNode6, NULL);

    Test("Test3", pNode1, false);

    DestroyTree(pNode1);
}


//               1
//              /
//             2
//            /
//           3
//          /
//         4
//        /
//       5
void Test4()
{
    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode1, pNode2, NULL);
    ConnectTreeNodes(pNode2, pNode3, NULL);
    ConnectTreeNodes(pNode3, pNode4, NULL);
    ConnectTreeNodes(pNode4, pNode5, NULL);

    Test("Test4", pNode1, false);

    DestroyTree(pNode1);
}

// 1
//  \
//   2
//    \
//     3
//      \
//       4
//        \
//         5
void Test5()
{
    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode1, NULL, pNode2);
    ConnectTreeNodes(pNode2, NULL, pNode3);
    ConnectTreeNodes(pNode3, NULL, pNode4);
    ConnectTreeNodes(pNode4, NULL, pNode5);

    Test("Test5", pNode1, false);

    DestroyTree(pNode1);
}

// 树中只有1个结点
void Test6()
{
    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    Test("Test6", pNode1, true);

    DestroyTree(pNode1);
}

// 树中没有结点
void Test7()
{
    Test("Test7", NULL, true);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    Test7();

    return 0;
}


#endif

clip_image008

代码如下:

#if 0
unsigned int FindFirstBitIs1(int num);
bool IsBit1(int num, unsigned int indexBit);

void FindNumsAppearOnce(int data[], int length, int* num1, int* num2){
    if(data==0||length<=0)
        return;
    unsigned int s=0;
    for(int i=0;i<length;i++)
        s^=data[i];
   unsigned int pos=FindFirstBitIs1(s);
    *num1=0,*num2=0;
    for(int i=0;i<length;i++){
        if(IsBit1(data[i],pos))
            *num1^=data[i];
        else
            *num2^=data[i];
    }
}
unsigned int FindFirstBitIs1(int num){
    int pos=0;
    while(pos<sizeof(int)*4){
        if(num&(0x1<<pos))
            break;
        else
            pos++;
    }
    return pos;
}
bool IsBit1(int num,unsigned int indexBit){
    return num&(0x1<<indexBit);
}
// ====================测试代码====================
void Test(char* testName, int data[], int length, int expected1, int expected2)
{
    if(testName != NULL)
        printf("%s begins: ", testName);

    int result1, result2;
    FindNumsAppearOnce(data, length, &result1, &result2);

    if((expected1 == result1 && expected2 == result2) ||
        (expected2 == result1 && expected1 == result2))
        printf("Passed.\n\n");
    else
        printf("Failed.\n\n");
}

void Test1()
{
    int data[] = {2, 4, 3, 6, 3, 2, 5, 5};
    Test("Test1", data, sizeof(data) / sizeof(int), 4, 6);
}

void Test2()
{
    int data[] = {4, 6};
    Test("Test2", data, sizeof(data) / sizeof(int), 4, 6);
}

void Test3()
{
    int data[] = {4, 6, 1, 1, 1, 1};
    Test("Test3", data, sizeof(data) / sizeof(int), 4, 6);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();

    return 0;
}


#endif

clip_image010

代码如下:

#if 0
bool FindNumbersWithSum(int data[], int length, int sum, 
                        int* num1, int* num2) {
    if(data==0||length<=0||num1==0||num2==0)
        return false;
    int i=0,j=length-1;
    int s;
    while(i<j){
        s=data[i]+data[j];
        if(s==sum){
            *num1=data[i];
            *num2=data[j];
            return true;
        }
        else if(s<sum){
            i++;
        }
        else
            j--;
    }
    return false;
}
// ====================测试代码====================
void Test(char* testName, int data[], int length, int sum, bool expectedReturn)
{
    if(testName != NULL)
        printf("%s begins: ", testName);
    
    int num1, num2;
    int result = FindNumbersWithSum(data, length, sum, &num1, &num2);
    if(result == expectedReturn)
    {
        if(result)
        {
            if(num1 + num2 == sum)
                printf("Passed. \n");
            else
                printf("Failed. \n");
        }
        else
            printf("Passed. \n");
    }
    else
        printf("Failed. \n");
}

// 存在和为s的两个数字，这两个数字位于数组的中间
void Test1()
{
    int data[] = {1, 2, 4, 7, 11, 15};
    Test("Test1", data, sizeof(data) / sizeof(int), 15, true);
}

// 存在和为s的两个数字，这两个数字位于数组的两段
void Test2()
{
    int data[] = {1, 2, 4, 7, 11, 16};
    Test("Test2", data, sizeof(data) / sizeof(int), 17, true);
}

// 不存在和为s的两个数字
void Test3()
{
    int data[] = {1, 2, 4, 7, 11, 16};
    Test("Test3", data, sizeof(data) / sizeof(int), 10, false);
}

// 鲁棒性测试
void Test4()
{
    Test("Test4", NULL, 0, 0, false);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();

    return 0;
}


#endif

clip_image012

代码如下:

#if 0
void PrintContinuousSequence(int small, int big);

void FindContinuousSequence(int sum){
    if(sum<3)
        return;
    int t1=1,t2=2;
    int mid=(1+sum)/2;
    int curSum=t1+t2;
    while(t1<mid){
        if(curSum==sum) {
            PrintContinuousSequence(t1,t2);
            curSum-=t1;
            t1++;
        }
        else if(curSum<sum) {
            t2++;
            curSum+=t2;
        }
        else {
            curSum-=t1;
            t1++;
        }
    }
}
void PrintContinuousSequence(int small, int big)
{
    for(int i = small; i <= big; ++ i)
        printf("%d ", i);

    printf("\n");
}

// ====================测试代码====================
void Test(char* testName, int sum)
{
    if(testName != NULL)
        printf("%s for %d begins: \n", testName, sum);

    FindContinuousSequence(sum);
}

int main(int argc, char* argv[])
{
    Test("test1", 1);
    Test("test2", 3);
    Test("test3", 4);
    Test("test4", 9);
    Test("test5", 15);
    Test("test6", 100);

    return 0;
}


#endif

clip_image014

代码如下:

void Reverse(char*s,char*t){
    while(s<t){
        swap(*s,*t);
        s++,t--;
    }
}
#if 0
void ReverseSentence(char *str){
    if(str==0)
        return ;
    char *s,*t;
    int len=strlen(str);
    printf("%s\n",str);
    Reverse(str,str+len-1);
    printf("%s\n",str);
    s=t=str;
    while(*s!='\0'){
        if(*s==' '){
            s++,t++;
        }
        else if(*t==' '||*t=='\0'){
            Reverse(s,--t);
            s=++t;
        }
        else
            t++;
    }
}
// ====================测试代码====================
void Test(char* testName, char* input, char* expectedResult)
{
    if(testName != NULL)
        printf("%s begins: ", testName);

    ReverseSentence(input);

    if((input == NULL && expectedResult == NULL)
        || (input != NULL && strcmp(input, expectedResult) == 0))
        printf("Passed.\n\n");
    else
        printf("Failed.\n\n");
}

// 功能测试，句子中有多个单词
void Test1()
{
    char input[] = "I am a student.";
    char expected[] = "student. a am I";

    Test("Test1", input, expected);
}

// 功能测试，句子中只有一个单词
void Test2()
{
    char input[] = "Wonderful";
    char expected[] = "Wonderful";

    Test("Test2", input, expected);
}

// 鲁棒性测试
void Test3()
{
    Test("Test3", NULL, NULL);
}

// 边界值测试，测试空字符串
void Test4()
{
    Test("Test4", "", "");
}

// 边界值测试，字符串中只有空格
void Test5()
{
    char input[] = "   ";
    char expected[] = "   ";
    Test("Test5", input, expected);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();

    return 0;
}
#endif

clip_image016

代码如下:

#if 0

char* LeftRotateString(char* pStr, int n)
{
    if(pStr != NULL)
    {
        int nLength = static_cast<int>(strlen(pStr));
        if(nLength > 0 && n > 0 && n < nLength)
        {
            char* pFirstStart = pStr;
            char* pFirstEnd = pStr + n - 1;
            char* pSecondStart = pStr + n;
            char* pSecondEnd = pStr + nLength - 1;

            // 翻转字符串的前面n个字符
            Reverse(pFirstStart, pFirstEnd);
            // 翻转字符串的后面部分
            Reverse(pSecondStart, pSecondEnd);
            // 翻转整个字符串
            Reverse(pFirstStart, pSecondEnd);
        }
    }

    return pStr;
}

// ====================测试代码====================
void Test(char* testName, char* input, int num, char* expectedResult)
{
    if(testName != NULL)
        printf("%s begins: ", testName);

    char* result = LeftRotateString(input, num);

    if((input == NULL && expectedResult == NULL)
        || (input != NULL && strcmp(result, expectedResult) == 0))
        printf("Passed.\n\n");
    else
        printf("Failed.\n\n");
}

// 功能测试
void Test1()
{
    char input[] = "abcdefg";
    char expected[] = "cdefgab";

    Test("Test1", input, 2, expected);
}

// 边界值测试
void Test2()
{
    char input[] = "abcdefg";
    char expected[] = "bcdefga";

    Test("Test2", input, 1, expected);
}

// 边界值测试
void Test3()
{
    char input[] = "abcdefg";
    char expected[] = "gabcdef";

    Test("Test3", input, 6, expected);
}

// 鲁棒性测试
void Test4()
{
    Test("Test4", NULL, 6, NULL);
}

// 鲁棒性测试
void Test5()
{
    char input[] = "abcdefg";
    char expected[] = "abcdefg";

    Test("Test5", input, 0, expected);
}

// 鲁棒性测试
void Test6()
{
    char input[] = "abcdefg";
    char expected[] = "abcdefg";

    Test("Test6", input, 7, expected);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();

    return 0;
}

#endif

clip_image018

#if 0
// ====================方法一====================
void Probability(int n, int current, int sum, int* pProbabilities);

void PrintProbability_Solution1(int n) {
    if(n<=0)
        return;
    int maxSum=6*n;
//    int sz=6*n-n+1;
    int *pro=new int[maxSum+1];
    for(int i=1;i<=maxSum;i++)
        pro[i]=0;

    for(int i=1;i<=6;i++)
        Probability(n,n,i,pro);
    
    double total=pow((double)6,n);
    for(int i=n;i<=maxSum;i++){
        double p=pro[i]/total;
        printf("%d: %e\n",i,p);
    }
    delete[] pro;
}
void Probability(int n,int c,int sum,int *pro){
    if(c==1){
        pro[sum]++;
    }
    else{
        for(int i=1;i<=6;i++)
            Probability(n,c-1,i+sum,pro);
    }
}
void PrintProbability_Solution2(int n) {
    if(n<=0)
        return;
    int *pro[2];
    pro[0]=new int[6*n+1];
    pro[1]=new int[6*n+1];
    for(int i=0;i<=6*n;i++)
        pro[0][i]=pro[1][i]=0;
    int flag=0;
    for(int i=1;i<=6;i++)
        pro[flag][i]=1;
    for(int k=2;k<=n;k++){
        for(int i=0;i<k;i++)
            pro[1-flag][i]=0;
        for(int i=k;i<=6*k;i++){
            int cnt=0;
            for(int j=1;j<=i&&j<=6;j++)
                cnt+=pro[flag][i-j];
            pro[1-flag][i]=cnt;
        }
        flag=1-flag;
    }
    double total=pow((double)6,n);
    for(int i=n;i<=6*n;i++) {
        double p=pro[flag][i]/total;
        printf("%d: %e\n",i,p);
    }
    delete[] pro[0];
    delete[] pro[1];
}
// ====================测试代码====================
void Test(int n)
{
    printf("Test for %d begins:\n", n);
    
    printf("Test for solution1\n");
    PrintProbability_Solution1(n);

    printf("Test for solution2\n");
    PrintProbability_Solution2(n);

    printf("\n");
}

int main(int argc, char* argv[])
{
    Test(1);
    Test(2);
    Test(3);
    Test(4);
    
    Test(11);

    Test(0);

    return 0;
}

#endif

clip_image020

代码如下:

#if 0
bool IsContinuous(int* a, int n) {
    if(a==0||n<=0)
        return false;
    int cnt_zero=0;
    int gap=0;
    for(int i=0;i<n;i++)
        if(a[i]==0)
            cnt_zero++;
    sort(a,a+n);
    int i=cnt_zero;
    for(;i<n-1;i++){
        if(a[i]==a[i+1])
            return false;
        gap+=a[i+1]-a[i]-1;
    }
    return cnt_zero>=gap;
}
// ====================测试代码====================
void Test(char* testName, int* numbers, int length, bool expected)
{
    if(testName != NULL)
        printf("%s begins: ", testName);

    if(IsContinuous(numbers, length) == expected)
        printf("Passed.\n");
    else
        printf("Failed.\n");
}

void Test1()
{
    int numbers[] = {1, 3, 2, 5, 4};
    Test("Test1", numbers, sizeof(numbers) / sizeof(int), true);
}

void Test2()
{
    int numbers[] = {1, 3, 2, 6, 4};
    Test("Test2", numbers, sizeof(numbers) / sizeof(int), false);
}

void Test3()
{
    int numbers[] = {0, 3, 2, 6, 4};
    Test("Test3", numbers, sizeof(numbers) / sizeof(int), true);
}

void Test4()
{
    int numbers[] = {0, 3, 1, 6, 4};
    Test("Test4", numbers, sizeof(numbers) / sizeof(int), false);
}

void Test5()
{
    int numbers[] = {1, 3, 0, 5, 0};
    Test("Test5", numbers, sizeof(numbers) / sizeof(int), true);
}

void Test6()
{
    int numbers[] = {1, 3, 0, 7, 0};
    Test("Test6", numbers, sizeof(numbers) / sizeof(int), false);
}

void Test7()
{
    int numbers[] = {1, 0, 0, 5, 0};
    Test("Test7", numbers, sizeof(numbers) / sizeof(int), true);
}

void Test8()
{
    int numbers[] = {1, 0, 0, 7, 0};
    Test("Test8", numbers, sizeof(numbers) / sizeof(int), false);
}

void Test9()
{
    int numbers[] = {3, 0, 0, 0, 0};
    Test("Test9", numbers, sizeof(numbers) / sizeof(int), true);
}

void Test10()
{
    int numbers[] = {0, 0, 0, 0, 0};
    Test("Test10", numbers, sizeof(numbers) / sizeof(int), true);
}

// 有对子
void Test11()
{
    int numbers[] = {1, 0, 0, 1, 0};
    Test("Test11", numbers, sizeof(numbers) / sizeof(int), false);
}

// 鲁棒性测试
void Test12()
{
    Test("Test12", NULL, 0, false);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    Test7();
    Test8();
    Test9();
    Test10();
    Test11();
    Test12();

    return 0;
}


#endif

clip_image022 clip_image024

clip_image026 clip_image028 clip_image030

代码如下:

#if 0

// ====================方法1====================
int LastRemaining_Solution1(unsigned int n, unsigned int m){
    if(n<1||m<1)
        return -1;
    list<int> lst;
    for(int i=0;i<n;i++)
        lst.push_back(i);
    list<int>::iterator current=lst.begin();
    list<int>::iterator next;
    while(lst.size()>1){
        for(int i=1;i<m;i++){
            ++current;
            if(current==lst.end())
                current=lst.begin();
        }
        next=++current;
        if(next==lst.end())
            next=lst.begin();
        --current;
        lst.erase(current);
        current=next;
    }
    return *current;
}
// ====================方法2====================
int LastRemaining_Solution2(unsigned int n, unsigned int m){
    if(n<1||m<1)
        return -1;
    int last=0;
    for(int i=2;i<=n;i++)
        last=(last+m)%i;
    return last;
}
// ====================测试代码====================
void Test(char* testName, unsigned int n, unsigned int m, int expected)
{
    if(testName != NULL)
        printf("%s begins: \n", testName);

    if(LastRemaining_Solution1(n, m) == expected)
        printf("Solution1 passed.\n");
    else
        printf("Solution1 failed.\n");

    if(LastRemaining_Solution2(n, m) == expected)
        printf("Solution2 passed.\n");
    else
        printf("Solution2 failed.\n");

    printf("\n");
}

void Test1()
{
    Test("Test1", 5, 3, 3);
}

void Test2()
{
    Test("Test2", 5, 2, 2);
}

void Test3()
{
    Test("Test3", 6, 7, 4);
}

void Test4()
{
    Test("Test4", 6, 6, 3);
}

void Test5()
{
    Test("Test5", 0, 0, -1);
}

void Test6()
{
    Test("Test6", 4000, 997, 1027);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();

    return 0;
}

#endif

clip_image032

clip_image034 clip_image036 clip_image038 clip_image040

代码如下:

#if 0
class A{
    public:
        A(){
            ++N;
            sum+=N;
        }
        static void Reset(){N=0;sum=0;}
        static int GetSum(){
            return sum;
        }
    public:
        static int N;
        static int sum;
};
int A::N=0;
int A::sum=0;

int Sum_Solution1(int n) {
    A::Reset();
    A *pa=new A[n];
    delete[] pa;
    return A::GetSum();
}
class C1;
C1* arr[2];
class C1{
    public:
    virtual int sum(int n){
        return 0;
    }
};
class C2:public C1{
    public:
        int sum(int n){
            return arr[!!n]->sum(n-1)+n;
        }
};
int Sum_Solution2(int n) {
    C1 cc1;
    C2 cc2;
    arr[0]=&cc1;
    arr[1]=&cc2;
    return arr[1]->sum(n);
}
typedef int (*fun)(int);
int f1(int n){
    return 0;
}
int Sum_Solution3(int n) {
    static fun f[2]={f1,Sum_Solution3};
    return n+f[!!n](n-1);
}
template <int n> 
struct Sum_Solution4 {
    enum {N=Sum_Solution4<n-1>::N+n};
};
template <>
struct Sum_Solution4<1>{
    enum {N=1};
};
template <>
struct Sum_Solution4<0>{
    enum {N=0};
};
// ====================测试代码====================
void Test(int n, int expected)
{
    printf("Test for %d begins:\n", n);

    if(Sum_Solution1(n) == expected)
        printf("Solution1 passed.\n");
    else
        printf("Solution1 failed.\n");

    if(Sum_Solution2(n) == expected)
        printf("Solution2 passed.\n");
    else
        printf("Solution2 failed.\n");

    if(Sum_Solution3(n) == expected)
        printf("Solution3 passed.\n");
    else
        printf("Solution3 failed.\n");
}

void Test1()
{
    const unsigned int number = 1;
    int expected = 1;
    Test(number, expected);
    if(Sum_Solution4<number>::N == expected)
        printf("Solution4 passed.\n");
    else
        printf("Solution4 failed.\n");
}

void Test2()
{
    const unsigned int number = 5;
    int expected = 15;
    Test(number, expected);
    if(Sum_Solution4<number>::N == expected)
        printf("Solution4 passed.\n");
    else
        printf("Solution4 failed.\n");
}

void Test3()
{
    const unsigned int number = 10;
    int expected = 55;
    Test(number, expected);
    if(Sum_Solution4<number>::N == expected)
        printf("Solution4 passed.\n");
    else
        printf("Solution4 failed.\n");
}

void Test4()
{
    const unsigned int number = 0;
    int expected = 0;
    Test(number, expected);
    if(Sum_Solution4<number>::N == expected)
        printf("Solution4 passed.\n");
    else
        printf("Solution4 failed.\n");
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();

    return 0;
}

#endif

clip_image042

代码如下:

#if 0
int Add(int num1, int num2) {
    int sum;
    int carry;
    do{
        sum=num1^num2;
        carry=(num1&num2)<<1;
        num1=sum;
        num2=carry;
    }while(num2!=0);
    return sum;
}
// ====================测试代码====================
void Test(int num1, int num2, int expected)
{
    int result = Add(num1, num2);
    if(result == expected)
        printf("%d + %d is %d. Passed\n", num1, num2, result);
    else
        printf("%d + %d is %d. Failed\n", num1, num2, result);
}

int main(int argc, char* argv[])
{
    Test(1, 2, 3);
    Test(111, 899, 1010);

    Test(-1, 2, 1);
    Test(1, -2, -1);

    Test(3, 0, 3);
    Test(0, -4, -4);

    Test(-2, -8, -10);
}


#endif

clip_image044

clip_image046 clip_image048 clip_image050

代码如下:

#if 0

// ====================方法一====================
class SealedClass1
{
public:
    static SealedClass1* GetInstance() 
    {
        return new SealedClass1();
    }
 
    static void DeleteInstance( SealedClass1* pInstance)
    {
        delete pInstance;
    }
 
private:
    SealedClass1() {}
    ~SealedClass1() {}
};

// 如果试图从SealedClass1继承出新的类型，
// 将会导致编译错误。
/*
class Try1 : public SealedClass1
{
public:
    Try1() {}
    ~Try1() {}
};
*/

// ====================方法二====================
template <typename T> class MakeSealed
{
    friend T;
 
private:
    MakeSealed() {}
    ~MakeSealed() {}
};
 
class SealedClass2 : virtual public MakeSealed<SealedClass2>
{
public:
    SealedClass2() {}
    ~SealedClass2() {}
};

// 如果试图从SealedClass1继承出新的类型，
// 将会导致编译错误。
/*
class Try2 : public SealedClass2
{
public:
    Try2() {}
    ~Try2() {}
};
*/

int main(int argc, char* argv[])
{
    return 0;
}

#endif

面试题49 将字符串转化为整数

#if 0
long long StrToIntCore(const char* str, bool minus);

enum Status {kValid = 0, kInvalid};
int g_nStatus = kValid;

int StrToInt(const char* str)
{
    g_nStatus = kInvalid;
    long long num = 0;

    if(str != NULL && *str != '\0') 
    {
        bool minus = false;
        if(*str == '+')
            str ++;
        else if(*str == '-') 
        {
            str ++;
            minus = true;
        }

        if(*str != '\0') 
        {
            num = StrToIntCore(str, minus);
        }
    }

    return (int)num;
}

long long StrToIntCore(const char* digit, bool minus)
{
    long long num = 0;

    while(*digit != '\0') 
    {
        if(*digit >= '0' && *digit <= '9') 
        {
            int flag = minus ? -1 : 1;
            num = num * 10 + flag * (*digit - '0');

            if((!minus && num > 0x7FFFFFFF) 
                || (minus && num < (signed int)0x80000000))
            {
                num = 0;
                break;
            }

            digit++;
        }
        else 
        {
            num = 0;
            break;
        }
    }

    if(*digit == '\0') 
    {
        g_nStatus = kValid;
    }

    return num;
}

// ====================测试代码====================
void Test(char* string)
{
    int result = StrToInt(string);
    if(result == 0 && g_nStatus == kInvalid)
        printf("the input %s is invalid.\n", string);
    else
        printf("number for %s is: %d.\n", string, result);
}

int main(int argc, char* argv[])
{
    Test(NULL);

    Test("");

    Test("123");

    Test("+123");
    
    Test("-123");

    Test("1a33");

    Test("+0");

    Test("-0");

    //有效的最大正整数, 0x7FFFFFFF
    Test("+2147483647");    

    Test("-2147483647");

    Test("+2147483648");

    //有效的最小负整数, 0x80000000
    Test("-2147483648");    

    Test("+2147483649");

    Test("-2147483649");

    Test("+");

    Test("-");

    return 0;
}

#endif

clip_image052

struct TreeNode 
{
    int                    m_nValue;    
    std::vector<TreeNode*>    m_vChildren;    
};
TreeNode* CreateTreeNode(int value)
{
    TreeNode* pNode = new TreeNode();
    pNode->m_nValue = value;

    return pNode;
}

void ConnectTreeNodes(TreeNode* pParent, TreeNode* pChild)
{
    if(pParent != NULL)
    {
        pParent->m_vChildren.push_back(pChild);
    }
}

void PrintTreeNode(TreeNode* pNode)
{
    if(pNode != NULL)
    {
        printf("value of this node is: %d.\n", pNode->m_nValue);

        printf("its children is as the following:\n");
        std::vector<TreeNode*>::iterator i = pNode->m_vChildren.begin();
        while(i < pNode->m_vChildren.end())
        {
            if(*i != NULL)
                printf("%d\t", (*i)->m_nValue);
        }

        printf("\n");
    }
    else
    {
        printf("this node is null.\n");
    }

    printf("\n");
}

void PrintTree(TreeNode* pRoot)
{
    PrintTreeNode(pRoot);

    if(pRoot != NULL)
    {
        std::vector<TreeNode*>::iterator i = pRoot->m_vChildren.begin();
        while(i < pRoot->m_vChildren.end())
        {
            PrintTree(*i);
            ++i;
        }
    }
}

void DestroyTree(TreeNode* pRoot)
{
    if(pRoot != NULL)
    {
        std::vector<TreeNode*>::iterator i = pRoot->m_vChildren.begin();
        while(i < pRoot->m_vChildren.end())
        {
            DestroyTree(*i);
            ++i;
        }

        delete pRoot;
    }
}
#if 1
bool GetNodePath(TreeNode* pRoot, TreeNode* pNode, list<TreeNode*>& path)
{
    if(pRoot == pNode)
        return true;
 
    path.push_back(pRoot);
 
    bool found = false;

    vector<TreeNode*>::iterator i = pRoot->m_vChildren.begin();
    while(!found && i < pRoot->m_vChildren.end())
    {
        found = GetNodePath(*i, pNode, path);
        ++i;
    }
 
    if(!found)
        path.pop_back();
 
    return found;
}

TreeNode* GetLastCommonNode
(
    const list<TreeNode*>& path1, 
    const list<TreeNode*>& path2
)
{
    list<TreeNode*>::const_iterator iterator1 = path1.begin();
    list<TreeNode*>::const_iterator iterator2 = path2.begin();
    
    TreeNode* pLast = NULL;
 
    while(iterator1 != path1.end() && iterator2 != path2.end())
    {
        if(*iterator1 == *iterator2)
            pLast = *iterator1;
 
        iterator1++;
        iterator2++;
    }
 
    return pLast;
}

TreeNode* GetLastCommonParent(TreeNode* pRoot, TreeNode* pNode1, TreeNode* pNode2)
{
    if(pRoot == NULL || pNode1 == NULL || pNode2 == NULL)
        return NULL;
 
    list<TreeNode*> path1;
    GetNodePath(pRoot, pNode1, path1);
 
    list<TreeNode*> path2;
    GetNodePath(pRoot, pNode2, path2);
 
    return GetLastCommonNode(path1, path2);
}

// ====================测试代码====================

void Test(char* testName, TreeNode* pRoot, TreeNode* pNode1, TreeNode* pNode2, TreeNode* pExpected)
{
    if(testName != NULL)
        printf("%s begins: \n", testName);

    TreeNode* pResult = GetLastCommonParent(pRoot, pNode1, pNode2);

    if((pExpected == NULL && pResult == NULL) || 
        (pExpected != NULL && pResult != NULL && pResult->m_nValue == pExpected->m_nValue))
        printf("Passed.\n");
    else
        printf("Failed.\n");
}

// 形状普通的树
//              1
//            /   \
//           2     3
//       /       \
//      4         5
//     / \      / |  \
//    6   7    8  9  10
void Test1()
{
    TreeNode* pNode1 = CreateTreeNode(1);
    TreeNode* pNode2 = CreateTreeNode(2);
    TreeNode* pNode3 = CreateTreeNode(3);
    TreeNode* pNode4 = CreateTreeNode(4);
    TreeNode* pNode5 = CreateTreeNode(5);
    TreeNode* pNode6 = CreateTreeNode(6);
    TreeNode* pNode7 = CreateTreeNode(7);
    TreeNode* pNode8 = CreateTreeNode(8);
    TreeNode* pNode9 = CreateTreeNode(9);
    TreeNode* pNode10 = CreateTreeNode(10);

    ConnectTreeNodes(pNode1, pNode2);
    ConnectTreeNodes(pNode1, pNode3);

    ConnectTreeNodes(pNode2, pNode4);
    ConnectTreeNodes(pNode2, pNode5);

    ConnectTreeNodes(pNode4, pNode6);
    ConnectTreeNodes(pNode4, pNode7);

    ConnectTreeNodes(pNode5, pNode8);
    ConnectTreeNodes(pNode5, pNode9);
    ConnectTreeNodes(pNode5, pNode10);

    Test("Test1", pNode1, pNode6, pNode8, pNode2);
}

// 树退化成一个链表
//               1
//              /
//             2
//            /
//           3
//          /
//         4
//        /
//       5
void Test2()
{
    TreeNode* pNode1 = CreateTreeNode(1);
    TreeNode* pNode2 = CreateTreeNode(2);
    TreeNode* pNode3 = CreateTreeNode(3);
    TreeNode* pNode4 = CreateTreeNode(4);
    TreeNode* pNode5 = CreateTreeNode(5);

    ConnectTreeNodes(pNode1, pNode2);
    ConnectTreeNodes(pNode2, pNode3);
    ConnectTreeNodes(pNode3, pNode4);
    ConnectTreeNodes(pNode4, pNode5);

    Test("Test2", pNode1, pNode5, pNode4, pNode3);
}

// 树退化成一个链表，一个结点不在树中
//               1
//              /
//             2
//            /
//           3
//          /
//         4
//        /
//       5
void Test3()
{
    TreeNode* pNode1 = CreateTreeNode(1);
    TreeNode* pNode2 = CreateTreeNode(2);
    TreeNode* pNode3 = CreateTreeNode(3);
    TreeNode* pNode4 = CreateTreeNode(4);
    TreeNode* pNode5 = CreateTreeNode(5);

    ConnectTreeNodes(pNode1, pNode2);
    ConnectTreeNodes(pNode2, pNode3);
    ConnectTreeNodes(pNode3, pNode4);
    ConnectTreeNodes(pNode4, pNode5);

    TreeNode* pNode6 = CreateTreeNode(6);

    Test("Test3", pNode1, pNode5, pNode6, NULL);
}

// 输入NULL
void Test4()
{
    Test("Test4", NULL, NULL, NULL, NULL);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();

    return 0;
}


#endif

转载于:https://www.cnblogs.com/xkfz007/archive/2012/11/07/2758257.html

weixin_34244102
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python《剑指offer》算法实现-链表中倒数第k个结点
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
剑指offer-第六章面试中的各项能力之总结
denggu8595的博客
08-31 64
转载于:https://www.cnblogs.com/hupp/p/4774021.html
剑指offer-第六章面试中的各项能力（n个骰子的点数）
denggu8595的博客
08-30 83
题目：把n个骰子扔到地上，骰子之和为S，输入n,打印s所有可能的值出现的概率。 思路：由于骰子的点数为1~6，因此n个骰子之和的大小为n~6n之间。故可以定义一个数组来存放这6n-n+1个数出现的次数。因为有n个数，每个数有六种可能，因此总的次数为6^n个。让数组中每一个可能的值出现的次数除以总次数，就可以得到对应数的概率。 转载于:https://www.cnblogs.com/h...
剑指Offer----面试题四之相关题目
烽火前秦路
05-19 502
题目： 有两个排序的数组A1和A2，内存在A1的末尾有足够多的空余空间容纳A2。请实现一个函数，把A2中所有的数字插入到A1中并且所有的数字是排序的。 思路一： 不管三七二十一，先插入，再排序。 思路二： 根据面试题四的思路，从后向前依次插入。 源代码： #include //参数分别代表：数组A，数组A中元素的个数，数组A的长度，数组B，数组B中元素的个数 void Add(in
剑指Offer--LeetCode刷题篇
需要远程指导仿真实验、代码有问题的，请后台私信或者关注公众号
10-18 1214
剑指Offer--LeetCode刷题篇
leetcode-剑指offer-程序员金典等高频面试题解析（附中文详细题解）
lqfarmer的博客
10-17 253
本项目包含 LeetCode、《剑指 Offer（第 2 版）》、《剑指 Offer（专项突击版）》、《程序员面试金典（第 6 版）》等题目的相关题解。所有题解均由多种编程语言实现，包括但不限于：Java、Python、C++、JavaScript、C#、Go，日常更新。 资源整理自网络，源地址：https://github.com/doocs/leetcode 内容涉及多次跳转，点击文末“阅读原文“”查看资源详情。 目录 内容截图 ...
剑指offer-----面试题30(最小的k个数)
扇扇来驰的博客
08-01 1778
实现思路：         实现思路类似于上一题的求解数组中出现次数超过一半的数字，这道题同样也并没有要求我们将最小的k个数按顺序输出来，因此我们可以借助于快速排序寻找主元的位置的方法来实现，因为主元位置的左边都是小于主元的，主元位置的右边都是大于主元的，我们只需要不断的调用查找主元位置的方法直到主元位于k位置就可以了，当然没进行一次partition方法，主元本身也是在变化的，这时候主元位置左
[剑指-Offer] 0. 《剑指-Offer》面试题题解汇总
Y-puyu 的博客
02-14 662
剑指-Offer 该专栏收录了学习《剑指-Offer》第二版书中的面试题，书中编程题是新大多以 LeetCode 对应系列的线上 OJ 给解答，下面会以章节的形式给出博主总结的本书中各个面试题的链接，方便对应查阅、学习。 第2章： 2.2 编程语言 [剑指-Offer] 1. 赋值运算符函数 ...
剑指offer系列——剑指 Offer 58 - II. 左旋转字符串（C/C++/Java语言）
未见花闻的博客
09-10 915
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。 剑指 Offer 58 - II. 左旋转字符串（C语言）
剑指Offer----面试题九：斐波那契数列
烽火前秦路
06-02 1481
题目： 写一个函数，输入n，求斐波那契数列（Fibonacci）的第n项，斐波那契数列的定义如下： 方法一： 第一种方法就是我们在学习C或者C++语言时接触到的递归调用，程序源代码如下： #include #include #include #include using std::cin; using std::cout; using std::endl; using s
剑指offer--Java实现
LYZ
02-25 3577
剑指offer合辑之面试01-67 《剑指offer》面试题 Java 代码的 Github 地址 《剑指offer》面试题 Markdown 版本，包含题目、分析及代码的 Github 地址 面试题2 实现单例模式 面试题3 二维数组中的查找 面试题4 替换空格 面试题5 从尾到头打印链表 面试题6 重建二叉树 面试题7 用两个栈实现队列 面试题8 旋转数组的最小数字 面试题9 斐波那契数列...
Python《剑指offer》算法实现-字符流中第一个不重复的字符
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
Python《剑指offer》算法实现-第一个只出现一次的字符
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
Python《剑指offer》算法实现-二叉搜索树的第k个结点
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
剑指offer 面试题49. 丑数
01-20
求按从小到大的顺序的第 n 个丑数。 示例: 输入: n = 10 输出: 12 解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。 说明:  1 是丑数。 n 不超过1690。 题目可以巧用动态规划。将前面求得的丑数记录下来，...
4. Java多线程面试题汇总
weixin_42173947的博客
05-17 947
Java多线程面试题汇总
Java面试总结(北京两年经验)
weixin_54673155的博客
05-18 930
自我介绍+项目介绍。
简历--个人信息--通用
stqer的博客
05-19 288
我在招聘的过程中就碰到过一份简历，一个男生，把自己 1 米 6 多点的个儿写了出来，我只能说这孩子太实在，他很可能是想向招聘者表明自己不是很高，其实，过早的暴露这些无关紧要的信息，很可能让你失去展示自己其他优点的机会，道理很简单，不是所有公司都象我们一样对身高没有要求。写名字，你得让我们知道你是张三不是李四，否则真让你面试，都不知怎么称呼你，总不能让我们一开口就说：“那谁，明天几点到哪儿面试！我们这样的公司，对党员还是很看重的，所以如果你是党员，一定要注明，在同等条件下，你绝对有优势。
【C++】多态
最新发布
malloc不出对象的博客
05-23 366
本篇文章讲解的C++中的多态，它是面向对象语言中最重要的特性之一，它能对同一行为表现出不同的形态！！
剑指offer java
09-18
《剑指offer》是一本程序猿面试的经典书籍，其中包含了很多常见的算法题和解答。在这本书中，有关跳台阶的问题有两个，分别是《剑指offer》10 矩阵覆盖和《剑指offer》9 青蛙变态跳台阶。 对于《剑指offer》10 矩阵...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值