吾尝终日而思矣，不如须臾之所学也

**标准模板库（Standard Template Library,STL）是标准C++库的一部分。STL具有非常强大的功能，在开发大型复杂的应用程序时非常有用。**下面简单的介绍一下STL的三个基本组成部分：1.容器：对象的集合。包括vector,stack,queue,deque,list,set,map等。2.算法：STL算法是对容器进行处理的函数，例如copy,sort,search,me

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。算法思想：我们用两个指针分别指向数组的第一个元素和最后一个元素。按照题目中旋转规则，第一个元素应该是大于或者等于最后一个元素的（这其实不完全对，还有特例，后面再加以讨论）。接着我们可以找到数

输入一个整数和一颗二元树。从数的根节点开始往下访问一直到叶节点所经过的所有节点形成一条路径。打印出和输入整数相等的所有路径。 例如，输入整数20和如下二元树 10 6 14 4 8 12 16 则打印出

请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。例如把9表示成二进制是1001，有2位是1。因此，如果输入9，该函数输出2。下面介绍三种解法，并分析优缺点：解法一：先判断整数二进制表示中最右边一位是不是1.接着把输入的整数右移一位，此时原来处于从右边数起第二位被移到最右边了，再判断是不是1，这样每次移动一位，直到整个整数变成0为止。现在问题变成了怎么判断一个整数的最右边是不是1。只要把

题目：输入数字n，按顺序打印出从1到最大的n位十进制数。比如输入3，则打印出1、2、3一直到最大的999。这道题目看着很简单，最简单的思想就是先求出最大的n位数，然后用一个循环从1开始逐个打印，代码很简单:void Print1ToMaxOfNDigits_1(int n){ int number=1; int i=0; while(i++<n) { number

题目：请实现函数ComplexListNode* Clone(ComplexListNode* pHead),复制一个复杂链表。在复杂链表中，每个结点除了有一个m_pNext指针指向下一个结点外，还有一个m_pSibling指向链表中的任意结点或者NULL。结点定义如下：struct ComplexListNode{ int m_nValue; ComplexListNode*

题目：输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。要求不能创建任何新的节点，只调整指针的指向。转换成 4=6=8=12=14=16#include <stdio.h>#include <iostream>using namespace std;struct BSTreeNode{ int m_nValue; BSTreeNode *m_pLeft; BST

算法思想很简单： 我们定义两个指针，第一个指针初始化时指向数组的第一个数字，它只向后移动。第二个指针初始化时指向数组的最后一个数字，它只向前移动。在两个指针相遇之前，第一个指针总是位于第二个指针的前面。如果第一个指针指向的数字是偶数，第二个指针指向的数字是奇数，则交换这两个数字#include<iostream>using namespace std;void ReorderOddEven(i

程序算法思想很简单，不作过多的介绍，直接上核心代码：typedef struct ListNode{ int m_nValue; ListNode* m_pNext;};//递归解法ListNode* Merge(ListNode* pHead1,ListNode* pHead2){ if(pHead1==NULL) { return pHead2

题目：输入两颗二叉树A和B，判断B是不是A的子结构算法思想很简单：首先在A中找到和B的根节点的值一样的节点R，然后再判断树A中以R为根节点的子树是不是包含和树B一样的结构。bool HasSubTree(BinaryTreeNode* pRoot1,BinaryTreeNode* pRoot2){ bool result=false; if(pRoot1!=NULL && pRoo

求一颗树的镜像的过程：我们先前序遍历这棵树的每个节点，如果遍历到的结点有子结点，就交换它的两个子结点。当交换完所有非叶子节点的左右子节点之后，就得到了树的镜像。代码如下：void MirrorRecursively(BinaryTreeNode* pNode){ if(pNode==NULL) { return; } if(pNode->m_pLeft==NUL

题目：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。例如：如果输入如下矩阵：1 2 3 45 6 7 89 10 11 1213 14 15 16则打印出数字：1 2 3 4 8 12 16 15

题目：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。例如序列1，2, 3, 4，5是某栈的压栈序列，序列4,5,3,2,1是该压栈序列的一个弹出序列，但4，3,5,1,2就不可能是该压栈序列的弹出序列。算法思想：如果下一个弹出的数字刚好是栈顶数字，那么直接弹出。如果下一个弹出的数字不在栈顶，我们把压栈序列中还没有入栈的数字压入辅助栈，直到把下一个需要弹出的数字压

问题描述：从上到下打印出二叉树的每个结点，同一层的结点按照从左到右的顺序打印。例如下图中的二叉树 ，则依次打印出8,6,10,5,7,9,11思路分析：按层打印的顺序决定了应该先打印根节点，所以我们从树的根节点开始分析，为了接下来能够打印值为8的结点的两个子结点，我们应该在遍历到该结点时把值为6和10的两个结点保存到一个容器里，现在容器内就有两个结点了。按照从左到右的打印，我们先取出值为6的结点，打

一、字符串的全排列题目：输入一个字符串，打印出该字符串中字符的所有排列。例如输入字符串abc，则打印出由字符a,b,c所能排列出来的所有字符串abc，acb,bac,bca,cab,cba。算法思想： 我们现在来看这个例子，分为如下三组：a b c——a c bb a c——b c ac b a——c a b我们求整个字符串的排列，可以看成两步：首先求所有可能出现在第一个位置的字符，即把第一个字符

题目描述：给出一个由n个结点组成的二叉树，根结点编号为1，所有结点的原始颜色为白色，现在对某一个结点进行染黑操作，执行操作后，由该结点为根结点的子树所有结点染黑，请问执行操作后有多少个结点变成黑色。保证输入合法，可以构成一颗二叉树，且编号不重复，操作的结点编号在二叉树存在。保证输入顺序是二叉树的先序遍历顺序，除去根结点编号。输入：第一行输入n(0随后n-1行代表除了根结点以

x^y:实现不进位的加法，那么我们接下来只要把进位后的数据加上就可以了x&y:这个操作即是找出相同位，因为只有当1&1=1，这种情况加法才会产生进位(x&y)<<1:x与y相加后产生进位，那么应该在该位前一位+1，即左移一位int Add（int x,int y）{ if(0==y) { return x; } int sum=x^y; int carry

题目：如下为类型CMyString 的声明，请为该类型添加赋值运算符函数class CMyString{ public: CMyString(char* pData=NULL); CMyString(const CMyString& str); ~CMyString(); private: char* m_pData;};此时应该注意如下几点：1.返回值

1、什么是Hash?Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。HASH

算法原理： 判断相邻的两个字母是否连续可以通过他们的差值是否为1来判断 即 if(str[i]-str[i-1]==1)#include <stdio.h>#include <stdlib.h>int main(int argc, char *argv[]) { char str[100]; int i=1; int count=0; printf("Input

约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1,2,3....n分别表示）围坐在一张圆桌周围。从编号为K的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的人又出列；依此规律重复下去，直到圆桌周围的人全部出列。思路1：考虑利用链表来解决#include<list>#include<cstdlib>#include<iostream>using namespa

定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。要求函数min,push,以及pop的时间复杂度都是O(1)。算法思想：考虑增加一个辅助的堆栈，每次往原堆栈push数据时，同时将最小数据push到辅助堆栈中。具体原理如图所示：首先定义一个栈结构题：typedef struct{ int data[STACK_SIZE]; int top; int min;}Mi

题目： 输入一个整形数组，数组里有正数也有负数。 数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。 求所有子数组的和的最大值。要求时间复杂度为O(n)。 例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2， 因此输出为该子数组的和18。算法思想：每次加上数组中的一个正数时，和会增加，加上一个负数时，和会减小。如果当前的

数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个大小的数组，有时需要5 0个数组的大小， 难于统一。我们只能够根据可能的最大需求来定义数组，常常会造成一定存储空间的浪费。 我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链

题目：实现一个函数，把字符串中的每个空格替换成“%20”。例如输入“We are happy.”,则输出”We%20are%20happy.”题目很简单，直接上代码#include<iostream>using namespace std;void Replace(char string[],int length){ if(string==NULL || length<0) {

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并输出它的头结点。在介绍算法之前，首先讲解一下树的几种遍历方式：1.前序遍历：先访问根节点，再访问左子节点，最后访问右子节点。2.中序遍历：先访问左子节点，再访问根节点

题目：用两个栈实现一个队列。队列的声明如下，清实现它的两个函数appendTail和deleteHead，分别完成在队列尾部插入节点和在队列头部删除节点的功能。思想很简单，直接上代码:#include<iostream>#include<stack>#include<exception>using namespace std;template<typename T> class Cqueue{

题目：输入n个整数，输出其中最小的K个 例如输入1,2,3,4,5,6,7,8这8个数字，则最小的4个数字为1,2,3和4思路1：显而易见，最简单的思路就是把输入的这组数据进行排序，然后输入最前面的K个数就行了，下面直接给出代码，代码比较简单，不多做解释#include<iostream>using namespace std;void swap(int &x,int &y){ int

这个可以和上一篇文章<<用两个栈实现队列>>对比着来学习。算法思想很简单，直接上代码吧：#include<iostream>#include<queue>using namespace std;template<typename T> class CStack{private: queue<T> q1; queue<T> q2; int nCount;public:

快速排序的描述：分解：数组A[p..r]被划分为两个（可能为空）子数组A[p..q-1]和A[q+1..r]，使得A[p..q-1]中的每一个元素都小于等于A[q]，A[q+1..r]中的每一个元素都大于等于A[q]。其中，计算下标q也是划分过程中的一部分解决：通过递归调用快速排序，对子数组A[p..q-1]和A[q+1..r]进行排序。合并：因为子数组都是原址排序的，所以不需要合并操作:A[p..

1、暴力匹配算法假设我们现在面临这样一个问题，有一个文本串 S 和一个模式串 P，现在要查找P在S中的位置，那么应该如何查找呢？我们很容易就想到暴力匹配的方法，假设现在文本串S匹配到 i 位置,模式串 P 匹配到 j 位置，则有：1.如果当前字符匹配成功（即S[i] == P[j]），则i++，j++，继续匹配下一个字符；2.如果失配（即S[i]! = P[j]），令i = i - (j - 1)

给出两个单向链表的头指针，比如h1,h2。判断这两个链表是否相交。为了简化问题，我们假设两个链表均不带环。问题扩展： 1.如果链表可能有环列？2.如果需要求出两个链表相交的第一个节点列？//链表结构体typedef struct ListNode{ int value; ListNode *next;}ListNode;//方法一：链表无环(判断两个单链表是否存在交点)bool i

这个就很简单了，直接发代码吧！#include<iostream>#include<string>using namespace std;string reverse(string s){ for(int i=0,j=s.length()-1;i<j;++i,--j) { char c=s[i]; s[i]=s[j]; s[j]=c

假设你有一个用1001个整数组成的数组，这些整数是任意排列的，但是你知道所有的整数都在1到1000(包括1000)之间。此外，除一个数字出现两次外，其他所有数字只出现一次。假设你只能对这个数组做一次处理，用一种算法找出重复的那个数字。如果你在运算中使用了辅助的存储方式，那么你能找到不用这种方式的算法吗?方法一：使用辅助存储方式使用hash存储方式，以1到1000作为hash表的索引，遍历原数组，统计

题目描述：给出n（0输入：第一行输入n,m第二行输入n个数，范围为[0,10^9]随后m行每行输入一个p输出：输出存在满足要求的子集的查询个数样例输入5 24 2 2 4 48 9样例输出1算法思想很简单，直接上代码#include #include #include #include #include #include #include #include us