雪儿的专栏

二叉搜索树的情况：           由于二叉搜索树是排过序的，位于左子树的结点都比父结点小，而位于右子树的结点都比父结点大，我们只需从树的根节点开始和两个输入的结点进行比较。如果当前结点的值比两个节点的值都大，那么最低的共同父结点一定是在当前结点的左子树上，于是下一步遍历当前结点的左子结点，如果当前结点的值比两个结点的值都小，那么最低共同结点一定在当前结点的又子树中，于是下一步遍历当前结点

题目：一个台阶总共有n级，如果一次可以跳1级，也可以跳两级。求总共有多少总跳法。并分析算法的时间复杂度。

把5张牌看成由5个数字组成的数组。大小王定义为0。bool IsContinuous(int* numbers, int length){if (numbers == NULL || length return false;qsort(numbers, length, sizeof(int), compare);int numberOfZero = 0;int

解法一：基于递归求骰子点数void PrintProbability(int number){if (number return;int maxSum = number*g_maxValue;int* PrintProbability = new int[maxSum - number + 1];for (int i = number; i pProba

int LastRemaining(unsigned int n, unsigned int m){if (n return -1;unsigned int i = 0;list numbers;for (i = 0; i numbers.push_back(i);list::iterator current = numbers.begin();while (n

void Reverse(char* pBegin, char* pEnd){ if (pBegin == NULL || pEnd == NULL)return;while (pBegin {char temp = *pBegin;*pBegin = *pEnd;*pEnd = temp;pBegin++, pEnd--;}}char*

半段查找。int GetFirstK(int* data, int length, int k, int start, int end){if (start > end)return -1;int middleIndex = (start + end) / 2;int middleData = data[middleIndex];if (middleData == k)

注：在排序的数组（或者部分排序的数组）中查找一个数字或者统计某个数字出现的次数，尝试用二分查找算法。哈希表的主要优点是我们利用它能够在O(1)时间查找某一元素，是效率最高的查找方式。哈希表的缺点：需要额外的空间来实现哈希表。        二叉排序树查找算法对应的数据结构是二叉搜索树。快速排序代码如下：

题目：用C++设计一个不能被继承的类。class SealedClass1{public:static SealedClass1* GetInstance(){return new SealedClass1();}static void DeleteInstance(SealedClass1* pInstance){delete pInstance;

int Add(int num1, int num2){int sum, carry;do{sum = num1^num2;carry = (num1&num2) num1 = sum;num2 = carry;} while (num2 != 0);return num1;}

void FindNumsAppearOnce(int data[], int length, int* num1, int* num2){if (data == NULL || length return;int resultExclusiveOR = 0;for (int i = 0; i resultExclusiveOR ^= data[i];unsigned

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) : (nRigh

代码如下：int Min(int* numbers, int length){if (numbers == NULL || length throw new std::exception("Invalid parameters");int index1 = 0;int index2 = length - 1;int indexMid = index1;while (

题目一：写一个函数，输入n，求斐波那契（Fibonacci）数列的第n项。斐波那契数列的定义如下：效率很低的解法如下：long long Fibonacci(unsigned int n){      if(n           return 0;      if(n==1)           return 1;       return F

过程：int MoreThanHalfNum(int* numbers, int length){if (CheckInvalidArray(numbers, length))return 0;int middle = length >> 1;int start = 0;int end = length - 1;int index = Partition(numbe

bool IsUgly(int number){while (number % 2 == 0)number /= 2;while (number % 3 == 0)number /= 3;while (number % 5 == 0)number /= 5;return (number == 1) ? true : false;}接下来只需要按顺序判断每

的输出是？    答案：构造函数的初始化列表字符串转化为整形的代码：enum Status{ kValid = 0,kInvalid };int g_nStatus = kValid;int StrToInt(const char* str){g_nStatus = kInvalid;long long num = 0;if (str != NULL

删除一个元素的步骤如下：        当stack2不为空时，在stack2中的栈顶元素是最先进入队列的元素，可以弹出。如果stack2为空时，我们把stack1中的元素逐个弹出并压入stack2。由于先进入队列的元素被压入到stack1的底端，经过弹出和压入之后就处于stack2的顶端了，又可以直接弹出。

题目10：解法一：右移　int NumberOf1(int n){        int count=0;        while(n)        {              if(n&1)                     count++;             n=n>>1;        }         return cou

链表结点定义如下：struct  ListNode{       int  m_nValue;        ListNode* m_pNext;};      由于本题是单链表，所以求倒数第k个即是求第n-k+1个结点。但需要遍历两次单链表。遍历一次的方法如下：ListNode* FindKthToTail(ListNode* pListHead, uns

题目：      输入数字n，按顺序打印出从1到最大的n位十进制数。比如输入3，则打印出1,2,3一直到最大的3位数即999。       解决这个问题需要表达一大数。最常用也是最容易的方法是用字符串或者数组表达大数。 在字符串上模拟数字加法的解法       Increment代码如下：bool Increment(char* number){bool

Struct ListNode{         int  m_nKey;         ListNode*  m_pNext;};ListNode* ReverseList(ListNode* pHead){ListNode* pReversedHead = NULL;ListNode* pNode = pHead;ListNode* pPrev =

struct ListNode{       int  m_nValue;       ListNode*  m_pNext;};void DeleteNode(ListNode** pListHead,ListNode* pToBeDeleted);        并不是一定需要得到被删除的结点的前一个结点，可以将被删除结点的后一个结点的内容复制到被删除结点，然后

解法一：不好的解法double Power(double base,int exponent){       double result=1.0;        for(int i=1;i              result*=base;        return result;}解法一没有考虑指数为0和负数的情况，只考虑了指数为正数的情况。解法二：全面但

题目：    有两个序列a,b，大小都为n,序列元素的值任意整数，无序；要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。例如:   var a=[100,99,98,1,2, 3];var b=[1, 2, 3, 4,5,40];这个题目的原型是之前做过的ACM动态规划多米诺骨牌（DOMINO）

class Temp{public:Temp(){ ++N; Sum += N; }static void Reset(){ N = 0; Sum = 0; }static unsigned int GetSum(){ return Sum; }private:static unsigned int N;static unsigned int Sum;};u

bool FindNumbersWithSum(int data[], int length, int sum, int* num1, int* num2){bool found = false;if (length return found;int ahead = length - 1;int behind = 0;while (ahead > behind){

void PrintMatrixClockwisely(int **numbers, int columns, int rows){if (numbers == NULL || columns return;int start = 0;while (columns > start * 2 && rows > start * 2){PrintMatrixInCircle(

void MirrorRecursively(BinaryTreeNode* pNode){if ((pNode == NULL) || (pNode->m_pLeft == NULL&&pNode->m_pRight))return;BinaryTreeNode *pTemp = pNode->m_pLeft;pNode->m_pLeft = pNode->m_pRight;

bool HasSubtree(BinaryTreeNode* pRoot1, BinaryTreeNode*pRoot2){bool result = false;if (pRoot1 != NULL&&pRoot2 != NULL){if (pRoot1->m_nValue == pRoot2->m_nValue){result = DoesTreeHaveTree

bool VerifySquenceOfBST(int sequence[], int length){if (sequence == NULL || length return false;int root = sequence[length - 1];//在二叉搜索树中左子树的结点小于根结点int i = 0;for (; i {if (sequence[i

当代码试图访问空指针指向的内存时程序就会崩溃，从而导致鲁棒性问题。所以要对空链表单独处理。ListNode* Merge(ListNode* pHead1, ListNode* pHead2){if (pHead1 == NULL)return pHead2;else if (pHead2 == NULL)return pHead1;ListNode* pMergedH

代码如下：void PrintFromTopBottom(BinaryTreeNode* pTreeRoot){if (!pTreeRoot)return;std::deque dequeTreeNode;dequeTreeNode.push_back(pTreeRoot);while (dequeTreeNode.size()){BinaryTreeNode

bool IsPopOrder(const int* pPush, const int* pPop, int nLength){bool bPossible = false;if (pPush != NULL&&pPop != NULL&&nLength > 0){const int* pNextPush = pPush;const int* pNextPop = pPop

代码如下：m_data是数据栈，而m_min是辅助栈template void StackWithMin::push(const T& value){m_data.push(value);if (m_min.size() == 0 || value {m_min.push(value);}elsem_min.push(m_min.top());}temp

void Permutation(char*  pStr){if (pStr == NULL)return;Permutation(pStr, pStr);}void Permutation(char* pStr, char* pBegin){if (*pBegin == '\0'){printf("%s\n", pStr);}else{fo

解法一：解法二：void CloneNodes(ComplexListNode* pHead){ComplexListNode* pNode = pHead;while (pNode != NULL){ComplexListNode* pCLoned = new ComplexListNode();pCloned->m_nValue = pN

实现单例模式： 只能生成一个实例的类是实现了单例模式的类型。不好的解法一：只适用于单线程环境由于要求只能生成一个实例，因此我们必须把构造函数设为私有函数以禁止他人创建实例。我们可以定义一个静态的实例，在需要的时候创建该实例。下面定义类型Singleton1就是基于这个思路的实现。       上述代码在singleton的静态属性instance中，只有在insta

题目：        在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

题目：请实现一个函数，把字符串中的每个空格替换成”%20“。例如输入”We are happy.“则”We%20are%20happy.“解法一：时间复杂度为O（n2）的解法注：其中浅灰色表示需要移动一次的字符，深灰色表示需要移动两次的字符。        假设字符串的长度是N，对每个空格字符，需要移动后面O（n）个字符，因此对含有O（n）个空格字符的字符串而言