微软数据结构与算法100题1

#include "stdafx.h" #include <string> #include <stack> #include <iostream> using namespace std; int _tmain(int argc, _TCHAR* argv[]) { string str; getline(cin, str); int i = 0, j= 0, length = str.length(); stack<string> s; while(j < length) { if (isspace(str[j])) { s.push(str.substr(i, j-i)); i = j+1; } j++; } s.push(str.substr(i)); while (!s.empty()) { cout<<s.top()<<" "; s.pop(); } cout<<"/n"; return 0; }

 

 

 

// reverse.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> using namespace std; /************************************************************************/ /* 题目：输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数， 使得它们的和正好是输入的那个数字.要求时间复杂度是O(n)。如果有多对数字的和等于输入的数字， 输出任意一对即可。例如输入数组1、2、4、7、11、15 和数字15。由于4+11=15，因此输出4 和11.*/ /************************************************************************/ /************************************************************************/ /*思路：两个指针标识符low，high。low在低端，high在高端，判断low ，high指向元素的 和与目标和的大小来移动low，high。*/ /************************************************************************/ void findTwoNumber(int arr[], int n, int &low, int &high, int target); int main() { int arr[] = {1, 2, 4, 7, 11, 12, 15}; int target = 15; int low = 0, high = 0; int size = sizeof(arr) / sizeof(int); findTwoNumber(arr, size, low, high, target); cout<<arr[low]<<" + "<<arr[high]<<" = "<<target<<endl; } void findTwoNumber(int arr[], int n, int &low, int &high, int target) { low = 0; high = n-1; while(low < high) { if (arr[low] + arr[high] < target) { low++; } else if (arr[low] + arr[high] > target) { high--; } else { break; } } }

 

 

 

 

 

 

#include "stdafx.h" #include <iostream> using namespace std; //链表结点 struct ListNode { int m_nKey; ListNode* m_pNext; }; ListNode *makeList(int n); ListNode *getKth(ListNode * head, int k); void printList(ListNode *head); int main() { ListNode *headNode = NULL; headNode = makeList(10); cout<<"链表为:"<<endl; printList(headNode); for (int i=1; i <= 10; i++) { cout<<"倒数第"<<i<<"个元素为"<<(getKth(headNode, i)->m_nKey)<<endl; } return 0; } /************************************************************ ************/ /* 函数功能：获取单链表倒数第K个元素 */ /************************************************************************/ ListNode *getKth(ListNode * tnode, int k) { ListNode *first, *sencond; first = sencond = tnode; for (int i=0; i<k; i++) { sencond = sencond->m_pNext; } while (sencond != NULL) { sencond = sencond->m_pNext; first = first->m_pNext; } return first; } /************************************************************************/ /* 函数功能：创建含有n个元素的单链表 */ /************************************************************************/ ListNode *makeList(int n) { ListNode *head = NULL; ListNode *temp = NULL; for (int i=10; i>0; i--) { temp = new ListNode; temp->m_nKey = i; temp->m_pNext = head; head = temp; } return head; } /************************************************************************/ /* 函数功能：输出链表的元素 */ /************************************************************************/ void printList(ListNode *head) { while (head != NULL) { cout<<head->m_nKey<<" "; head = head->m_pNext; } cout<<endl; }

 

 

 

 

 

// reverse.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> #include <cassert> #include <algorithm> #include <stack> using namespace std; struct BSTreeNode // a node in the binary search tree (BST) { int m_nValue; // value of node BSTreeNode *m_pLeft; // left child of node BSTreeNode *m_pRight; // right child of node }; void createBSTree(BSTreeNode *&root, int arr[], int n); void insertElement(BSTreeNode *&root, int element); void middleOutPut(BSTreeNode *root); void mirrorTreeRecursive(BSTreeNode *root); void mirrorTreeIteration(BSTreeNode *root); int main() { int arr[] = {8, 6, 10, 5, 7, 9, 11}; BSTreeNode *root = NULL; int n = sizeof(arr) / sizeof(int); cout<<"原数组为:/n"; copy(arr, arr + n, ostream_iterator<int>(cout, " ")); cout<<endl; createBSTree(root, arr, n); cout<<"中序输出:/n"; middleOutPut(root); cout<<endl; // mirrorTreeRecursive(root); mirrorTreeIteration(root); cout<<"镜像后为:/n"; middleOutPut(root); cout<<endl; return 0; } /************************************************************************/ /*函数功能：向二叉查找树中插入元素 */ /************************************************************************/ void insertElement(BSTreeNode *&root, int element) { if (NULL == root) { root = new BSTreeNode; root->m_nValue = element; root->m_pLeft = NULL; root->m_pRight = NULL; } else if (root->m_nValue < element) { insertElement(root->m_pRight, element); } else { insertElement(root->m_pLeft, element); } } /************************************************************************/ /* 函数功能：中序输出二叉查找树 */ /************************************************************************/ void middleOutPut(BSTreeNode *root) { if(root != NULL) { middleOutPut(root->m_pLeft); cout<<root->m_nValue<<" "; middleOutPut(root->m_pRight); } } /************************************************************************/ /* 函数功能：创建二叉查找树,参数arr[]为数组, n为数组元素的个数 */ /************************************************************************/ void createBSTree(BSTreeNode *&root, int arr[], int n) { for (int i=0; i<n; i++) { insertElement(root, arr[i]); } } /************************************************************************/ /* 函数功能：递归方法来产生二元查找树的镜像树 思路：就是递归翻转树，有子树则递归翻转子树*/ /************************************************************************/ void mirrorTreeRecursive(BSTreeNode *root) { BSTreeNode *temp = NULL; if (root != NULL) { temp = root->m_pRight; root->m_pRight = root->m_pLeft; root->m_pLeft = temp; } if (root->m_pLeft != NULL) { mirrorTreeRecursive(root->m_pLeft); } if (root->m_pRight != NULL) { mirrorTreeRecursive(root->m_pRight); } } /************************************************************************/ /* 函数功能：迭代方法产生二叉查找树的镜像树 思路：由于递归的本质是编译器生成了一个函数调用的栈，因此用循环来完成同样任务时最简单的办法就是用一个辅助栈来模拟递归。 首先我们把树的头结点放入栈中。在循环中，只要栈不为空，弹出栈的栈顶结点，交换它的左右子树。 如果它有左子树，把它的左子树压入栈中； 如果它有右子树，把它的右子树压入栈中。*/ /************************************************************************/ void mirrorTreeIteration(BSTreeNode *root) { stack<BSTreeNode*> s; s.push(root); while (!s.empty()) { BSTreeNode *top = s.top(); BSTreeNode *temp = NULL; temp = top->m_pRight; top->m_pRight = top->m_pLeft; top->m_pLeft = temp; s.pop(); if (top->m_pLeft != NULL) { s.push(top->m_pLeft); } if (top->m_pRight != NULL) { s.push(top->m_pRight); } } }

 

 

 

快速求斐波那契数列第N项

 

#include "stdafx.h" #include <iostream> using namespace std; int Fibonacci(int n); int _tmain(int argc, _TCHAR* argv[]) { for (int i=0; i<10; i++) { cout<<i<<" "<<Fibonacci(i)<<endl; } return 0; } int Fibonacci(int n) { int sum = 0; if (0 == n) { return 0; } else if ( (1 == n) || (2 == n) ) { return 1; } else { int a = 1; int b = 1; for (int i=3; i<=n; i++) { sum = a + b; a = b; b = sum; } return sum; } } 

 

 

 

 

 

 

 

 

// wy.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> #include <cassert> using namespace std; int StringToInt(char *str); int main() { cout<<StringToInt("123")<<endl; cout<<StringToInt("+456")<<endl; cout<<StringToInt("-789")<<endl; } int StringToInt(char *str) { assert( str != NULL ); char *temp = str; //查看第一个字符来判断正负 bool fuhao = false; if (*temp == '-') { fuhao = true; temp++; } else if(*temp == '+') { temp++; } int sum = 0; while (*temp != '/0') { if (*temp >= '0' && *temp <= '9') { sum = sum * 10 + (*temp - '0'); temp++; } else { sum = 0; break; } } if (fuhao == true) { return -sum; } else { return sum; } } 

 

 

 

一个单链表的类，实现链表的反转 和链表的合并

 

// wy.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> using namespace std; //单链表类 class SingleList { public: SingleList(){ head = NULL; } void InsertElement(int element); void OutPutList(); void ReserveList(); void MergeList(SingleList &other); private: typedef struct Node { int nodeValue; Node *p_Next; }Node; Node *head; }; int main() { SingleList list1, list2; for (int i=0; i<10; i++) { list1.InsertElement(i); list2.InsertElement(10 + i); } cout<<"list1: "; list1.OutPutList(); cout<<endl; cout<<"反转后: "; list1.ReserveList(); list1.OutPutList(); cout<<endl; cout<<"list2: "; list2.OutPutList(); cout<<endl; list1.MergeList(list2); cout<<"合并后: "; list1.OutPutList(); cout<<endl; } /************************************************************************/ /* 函数功能：向单链表中插入元素(倒着插入的，每个元素都是在表头插入的)*/ /************************************************************************/ void SingleList::InsertElement(int element) { Node *node = new Node; node->nodeValue = element; node->p_Next = head; head = node; } /************************************************************************/ /* 函数功能：输出单链表 */ /************************************************************************/ void SingleList::OutPutList() { Node *temp = head;//不能直接使用head，会改变其位置的 while (temp != NULL) { cout<<temp->nodeValue<<" "; temp = temp->p_Next; } } /************************************************************************/ /* 函数功能：单链表就地反转 思路：将后面每一个节点都插入到头结点之前*/ /************************************************************************/ void SingleList::ReserveList() { Node *q = head; //用来判断是否转换完 Node *p = q->p_Next;//用来存放当前要移动的元素 while(q->p_Next != NULL) { q->p_Next = p->p_Next; p->p_Next = head; head = p; p = q->p_Next; } } /************************************************************************/ /* 函数功能：合并两个单链表 */ /************************************************************************/ void SingleList::MergeList(SingleList &other) { Node *temp = head; //找到第一链表的尾部 while(temp->p_Next != NULL) { temp = temp->p_Next; } temp->p_Next = other.head; other.head = NULL; //销毁第二个链表 } 

 

 

写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)

功能：在字符串中找出连续最长的数字串，并把这个串的长度返回，并把这个最长数字串付给其中一个函数参数outputstr 所指内存。

例如："abcd12345ed125ss123456789"的首地址传给intputstr 后，函数将返回9，outputstr 所指的值为123456789

 

 

// wy.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> using namespace std; int continumax(char *outputstr,char *intputstr); int main() { char *input = "abcd12345ed125ss123456789"; char output[20] = {0}; int num = continumax(output, input); cout<<num<<endl; cout<<output<<endl; } /************************************************************************/ /* 函数功能：在字符串中找出连续最长的数字串，并把这个串的长度返回， 并把这个最长数字串付给其中一个函数参数outputstr 所指内存。 例如："abcd12345ed125ss123456789"的首地址传给intputstr 后，函数将返回9， outputstr 所指的值为123456789 */ /************************************************************************/ int continumax(char *outputstr,char *intputstr) { int max = 0; char *p = intputstr; char *q = NULL; //用来存储每次发现的第一个数字(0-9) while(*p != '/0') { if (isdigit(*p)) { int sum = 0; q = p; //发现第一个数字，记下其位置q //去找数字的结束位置p while (isdigit(*p)) { sum++; p++; } if (sum >= max) { max = sum; memcpy(outputstr, q, max);// 将找到的最长字符串拷贝到outputstr中 } q = p; } else { p++; } } return max; } 

 

 

58.从尾到头输出链表。

题目：输入一个链表的头结点，从尾到头反过来输出每个结点的值。链表结点定义如下：

struct ListNode

{

 

      int       m_nKey;

 

      ListNode* m_pNext;

};

 

分析：这是一道很有意思的面试题。

该题以及它的变体经常出现在各大公司的面试、笔试题中。

// wy.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> #include <cassert> using namespace std; struct ListNode { int m_nKey; ListNode* m_pNext; }; ListNode* MakeList(ListNode* &head); void ReverseOutPutList(ListNode *head); void OutPutList(ListNode *head); int main() { ListNode *head = NULL; head = MakeList(head); assert(head != NULL); cout<<"反序输出:"<<endl; ReverseOutPutList(head); cout<<endl; cout<<"正序输出:"<<endl; OutPutList(head); cout<<endl; } ListNode* MakeList(ListNode* &head) { ListNode *t; ListNode *temp = NULL; for (int i=0; i<10; i++) { t = new ListNode; t->m_nKey = i + 1; t->m_pNext = NULL; if (head == NULL) { head = t; temp = head; } else { head->m_pNext = t; head = t; } } return temp; } void ReverseOutPutList(ListNode *head) { if (head->m_pNext == NULL) { cout<<head->m_nKey<<" "; } else { ReverseOutPutList(head->m_pNext); cout<<head->m_nKey<<" "; } } void OutPutList(ListNode *head) { while (head != NULL) { cout<<head->m_nKey<<" "; head = head->m_pNext; } } 

 

 

不能被继承的类。

题目：用C++设计一个不能被继承的类。

 

分析：这是Adobe公司2007年校园招聘的最新笔试题。

这道题除了考察应聘者的C++基本功底外，还能考察反应能力，是一道很好的题目。

 

 

用C++设计一个不能被继承的类，这是一道笔试题，不仅考查了C++基本功底外，还能考察反应能力，是一道很好的题目。 　　用过Java的人都知道，在JAVA中定义了关键字final ，被final 修饰的类不能被继承。但在C++ 中没有final这个关键字，要实现这个要求还是需要花费一些精力。 　　首先想到的是在C++ 中，子类的构造函数会自动调用父类的构造函数。同样，子类的析构函数也会自动调用父类的析构函数。要想一个类不能被继承，我们只要把它的构造函数和析构函数都定义为私有函数。那么当一个类试图从它那继承的时候，必然会由于试图调用构造函数、析构函数而导致编译错误。 　　可是这个类的构造函数和析构函数都是私有函数了，我们怎样才能得到该类的实例呢?这难不倒我们，我们可以通过定义静态来创建和释放类的实例。基于这个思路，我们可以写出如下的代码： class Parent { public: static Parent *GetClassObject() { return new Parent(); } static void DestoryClassObject(Parent *pInstance) { if (pInstance != NULL) { delete pInstance; pInstance = NULL; } } private: Parent(){} ~Parent(){} }; 这个类是不能被继承，但在总觉得它和一般的类有些不一样，使用起来也有点不方便。比如，我们只能得到位于堆上的实例，而得不到位于栈上实例。 　　能不能实现一个和一般类除了不能被继承之外其他用法都一样的类呢?办法总是有的，不过需要一些技巧。 

c++中为什么static成员函数不能声明为const

这是C++的规则

const修饰符用于表示函数不能修改成员变量的值，该函数必须是含有this指针的类成员函数，函数调用方式为thiscall

而类中的static函数本质上是全局函数，调用规约是__cdecl或__stdcall,不能用const来修饰它

类的static成员函数和const成员函数

static成员的特性 

　　static成员函数没有this指针。

　　static成员函数不能被声明为const。

　　static成员函数也不能被声明为虚函数。

　　static成员函数可以直接访问所属类的static成员，但不能直接使用非static成员。

　　static数据成员的类型，可以是该成员所属的类类型。非static成员被限定声明为其自身类对象的指针或引用。 

　　static数据成员可以作为成员函数的默认实参。非static数据成员，不能用作成员函数的默认实参，因为它的值不能独立于所属对象而使用。分析：静态成员函数如果未初始化，系统自动会给它初始化为某个缺省值(如int初始化为0, 指针初始化为NULL等)。 所以一旦定义，其值已确定，可以作为类成员函数的缺省参数。

 　　当在类的外部定义static成员时，无须重复指定static关键字。static关键字只能用于类定义体内部的声明中，定义不能标示为static。

 

　　static数据成员必须在类定义体的外部定义正好一次。不像普通的数据成员，static成员不是通过类构造函数进行初始化，而是应该在定义时初始化。一般将static数据成员的定义放在包含类的非内联成员函数定义的文件中。 

　　一般的讲，static数据成员和普通数据成员一样，不能在类的定义体中初始化。static数据成员一般在定义时候初始化。这个规则的一个例外是，只要初始化式是一个常量表达式，const static 数据成员就可以在类的定义体中初始化（Perimer上只写了const static 整形，经过测试发现string也可以）：

 

 

 

 

在O（1）时间内删除链表结点。

题目：给定链表的头指针和一个结点指针，在O(1)时间删除该结点。链表结点的定义如下：

struct ListNode

{

 

      int        m_nKey;

 

      ListNode*  m_pNext;

 

};

 

函数的声明如下：

void DeleteNode(ListNode* pListHead, ListNode* pToBeDeleted);

 

http://blog.youkuaiyun.com/xianliti/archive/2010/06/11/5665179.aspx

 

 

 

 

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

题目：输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，

所有偶数位于数组的后半部分。要求时间复杂度为O(n)。

 

// wy.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> #include <cassert> using namespace std; void AdjustArrayOrder(int arr[], int n); inline bool IsEvenNumber(int n) { return (n % 2 == 0); } inline void Swap(int &a, int &b) { int temp = a; a = b; b = temp; } int main() { int arr[10]; for (int i=0; i<5; i++) { arr[i] = 2 * i; arr[5+i] = 2*i + 1; } AdjustArrayOrder(arr, 10); for (int i=0; i<10; i++) { cout<<arr[i]<<" "; } cout<<endl; } /************************************************************************/ /* 函数功能：调整数组顺序使奇数位于偶数前面，时间复杂度为O(n) */ /************************************************************************/ void AdjustArrayOrder(int arr[], int n) { int low = 0; int high = n - 1; while (low <= high) { while (!IsEvenNumber(arr[low])) { low++; } if (low >= high) { break; } while (IsEvenNumber(arr[high])) { high--; } if (low >= high) { break; } Swap(arr[low], arr[high]); } } 

 

 

 

52.二元树的深度。

题目：输入一棵二元树的根结点，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

例如：输入二元树：

 

                                            10

                                          /     /

                                        6        14

                                      /         /   /

                                    4         12     16

 

输出该树的深度3。

 

二元树的结点定义如下：

struct SBinaryTreeNode // a node of the binary tree

{

      int               m_nValue; // value of node

      SBinaryTreeNode  *m_pLeft;  // left child of node

      SBinaryTreeNode  *m_pRight; // right child of node

};

分析：这道题本质上还是考查二元树的遍历。

// wy.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> using namespace std; struct SBinaryTreeNode // a node of the binary tree { int m_nValue; // value of node SBinaryTreeNode *m_pLeft; // left child of node SBinaryTreeNode *m_pRight; // right child of node }; void insertElement(SBinaryTreeNode *&root, int element); void createBSTree(SBinaryTreeNode *&root, int arr[], int n); int depthBSTres(SBinaryTreeNode *root); int main() { int arr[] = {10, 6, 14, 4, 12, 16, 19}; SBinaryTreeNode *root = NULL; int n = sizeof(arr) / sizeof(int); createBSTree(root, arr, n); cout<<depthBSTres(root)<<endl; } /************************************************************************/ /*函数功能：向二叉查找树中插入元素 */ /************************************************************************/ void insertElement(SBinaryTreeNode *&root, int element) { if (NULL == root) { root = new SBinaryTreeNode; root->m_nValue = element; root->m_pLeft = NULL; root->m_pRight = NULL; } else if (root->m_nValue < element) { insertElement(root->m_pRight, element); } else { insertElement(root->m_pLeft, element); } } /************************************************************************/ /* 函数功能：创建二叉查找树,参数arr[]为数组, n为数组元素的个数 */ /************************************************************************/ void createBSTree(SBinaryTreeNode *&root, int arr[], int n) { for (int i=0; i<n; i++) { insertElement(root, arr[i]); } } /************************************************************************/ /* 函数功能：输出二叉查找树的深度(叶子节点的深度为1) */ /************************************************************************/ int depthBSTres(SBinaryTreeNode *root) { if (root == NULL) { return 0; } else { return max(depthBSTres(root->m_pLeft), depthBSTres(root->m_pRight)) + 1; } } 

53.字符串的排列。

题目：输入一个字符串，打印出该字符串中字符的所有排列。

例如输入字符串abc，则输出由字符a、b、c所能排列出来的所有字符串abc、acb、bac、bca、cab和cba。

分析：这是一道很好的考查对递归理解的编程题，

因此在过去一年中频繁出现在各大公司的面试、笔试题中。

#include "stdafx.h" #include <iostream> #include <cassert> using namespace std; /********************************************************************** **/ /* 函数描述：用递归的方法求全排列（若有重复元素就不对了） 如str="abcc"，这样输出的就不对。*/ /********************************************************************** **/ void AllOrder(char str[], int low, int n); void Swap(char &a, char &b) { char temp = a; a = b; b = temp; } int main() { char str[] = "abc"; int n = strlen(str); cout<<n<<endl; AllOrder(str, 0, n); } /********************************************************************** **/ /* 函数功能：求数组str的全排列 算法思想：假设我们求permute(abc)的全排列。permute(abc)的全排列 =a+permute(bc)和b+permute(ac)和c+permute(ab）=. 依次类推。所以就可以用递归做。而将abc拆分成a+bc，b+ac，c+ab的过程就是上 面的： for(int j=k; j<=m; j++) { Swap(list[k],list[j]); Perm(list, k+1, m); Swap(list[k],list[j]); } 这个过程。做好以后还要换回来，恢复原状，接着做。 当最后只有1个字母的时候，即k=m的时候，只有一种情况，因而输出。*/ /********************************************************************** **/ void AllOrder(char str[], int low, int n) { if(low == n - 1) { for (int i=0; i<n; i++) { cout<<str[i]; } cout<<endl; } else { for (int i=low; i<n; i++) { Swap(str[i], str[low]); AllOrder(str, low + 1, n); Swap(str[i], str[low]); } } } 

第二种方法：使用stl中的算法函数——stl全排列next_permutation(a,a+n)是对当前序列按字典顺序排序

http://apps.hi.baidu.com/share/detail/17354187

#include "stdafx.h" #include <iostream> #include <algorithm> using namespace std; int main() { char str[] = "abc"; int n = strlen(str); copy(str, str+n, ostream_iterator<char>(cout,"")); cout<<endl; sort(str, str+n); while (next_permutation(str, str+n)) { copy(str, str+n, ostream_iterator<char>(cout,"")); cout<<endl; } } 

 

 

51.和为n连续正数序列。

题目：输入一个正数n，输出所有和为n连续正数序列。

 

例如输入15，由于1+2+3+4+5=4+5+6=7+8=15，所以输出3个连续序列1-5、4-6和7-8。

分析：这是网易的一道面试题。

 

 

// wy.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream> using namespace std; int Sum(int arr[], int n); void SequenceOfSum(int n); int main() { SequenceOfSum(7); } /************************************************************************/ /* 函数功能：计算数组arr中元素的和 */ /************************************************************************/ int Sum(int arr[], int n) { int sum = 0; for (int i=0; i<n; i++) { sum += arr[i]; } return sum; } /************************************************************************/ /* 函数功能:输入一个正数n，输出所有和为n连续正数序列 例如输入15，由于1+2+3+4+5=4+5+6=7+8=15，所以输出3个连续序列1-5、4-6和7-8。*/ /************************************************************************/ void SequenceOfSum(int n) { int len = n/2; int *result = new int[len]; //存放满足结果的连续元素 memset(result, 0, sizeof(int)*len); int *arr = new int[n];//存放从1到n的连续元素 for (int i=0; i<n; i++) { arr[i] = i + 1; } for (int i=0; i<=len; i++)//连续元素的起始位置 { int index = 0; memset(result, 0, sizeof(int)*len); for (int j=i; j<=len+1; j++) //j存放的是连续元素的终止位置 { int temp = Sum(result, len) + arr[j]; if (temp < n)//若temp小于n继续判断下一个 { result[index] = arr[j]; index++; } else if (temp == n)//若满足则输出，进行下一个循环 { cout<<(i+1)<<"-"<<(j+1)<<endl; break; } else//若不满足，直接跳出循环，进行一个 { break; } } } }  

 

 

 

47.创新工场：

求一个数组的最长递减子序列 比如{9，4，3，2，5，4，3，2}的最长递减子序列为{9，5，4，3，2}

#include <iostream> using namespace std; /* 47.创新工场： 求一个数组的最长递减子序列 比如{9，4，3，2，5，4，3，2}的最长递减子序列为{9，5，4，3，2} */ void MaxSubSequence(int arr[], int n); int main() { int arr[] = {0, 1, 9, 4, 3, 2, 1, 5, 4, 3, 2}; int n = sizeof(arr) / sizeof(n); MaxSubSequence(arr, n); } void MaxSubSequence(int arr[], int n) { int i , j; int low = 0;//存放下限 int high = 0; //存放上限 int length = 0;//存放当前的长度 int max = 0;//存放最大值 for(i=0; i<n; ++i) { for(j=i; j<n; ++j) { if( arr[j+1] > arr[j]) break; } length = j + 1 - i; if(length > max) //若当前长度大于最大值max，进行替换 { low = i; high = j + 1; max = length; } i = j; } for(int k=low; k<high; ++k) cout<<arr[k]<<" "; cout<<endl; }  

49.一道看上去很吓人的算法面试题：

如何对n个数进行排序，要求时间复杂度O(n)，空间复杂度O(1)

就是考查计数排序的！！！！！！

#include <iostream> #include <algorithm> #include <iterator> using namespace std; /* http://hex.javaeye.com/blog/319860 */ void CountingSort(int arr[], int out[], int n, int k); int myRand() { return rand()%20; } int main() { int arr[10]; int out[10]; generate_n(arr, 10, myRand); copy(arr, arr+10, ostream_iterator<int>(cout, " ")); cout<<endl; int k = *max_element(arr, arr+10); cout<<"max element: "<<k<<endl; CountingSort(arr, out, 10, k+1); copy(out, out+10, ostream_iterator<int>(cout, " ")); cout<<endl; } /* 函数功能：计数排序（参数arr为输入的数组，out为输出的数组，n为数组arr中元素个数，k为数组arr中元素的最大值+1） */ void CountingSort(int arr[], int out[], int n, int k) { int *temp = new int[k]; memset(temp, 0, k*sizeof(int)); int i; for(i=0; i<n; i++) //统计各元素出现的次数 temp[arr[i]]++; for(i=1; i<k; i++) //对统计结果进行累加 temp[i] += temp[i-1]; for(i=n-1; i>=0; i--) { out[temp[arr[i]] - 1] = arr[i]; temp[arr[i]] -= 1; } delete []temp; } 

 

 

 

42.请修改append函数，利用这个函数实现：

两个非降序链表的并集，1->2->3 和 2->3->5 并为 1->2->3->5

另外只能输出结果，不能修改两个链表的数据。

 

 

#include "stdafx.h" #include <iostream> #include <list> #include <algorithm> using namespace std; template <typename T> void Append(list<T> a, list<T> b); int MyRand() { return (rand() % 30); } int main() { list<int> a; list<int> b; generate_n(back_inserter(a), 5, MyRand); generate_n(back_inserter(b), 5, MyRand); a.sort(); b.sort(); cout<<"a:"; copy(a.begin(), a.end(), ostream_iterator<int>(cout, " ")); cout<<endl; cout<<"b:"; copy(b.begin(), b.end(), ostream_iterator<int>(cout, " ")); cout<<endl; Append(a, b); } /************************************************************************/ /* 函数功能：合并两个有序的链表(若单一一个链表中的重复元素不能清楚) */ /************************************************************************/ template <typename T> void Append(list<T> a, list<T> b) { list<T>::iterator iter1 = a.begin(); list<T>::iterator iter2 = b.begin(); while((iter1 != a.end()) && (iter2 != b.end())) { if(*iter1 < *iter2) { cout<<*iter1<<" "; ++iter1; } else if(*iter1 > *iter2) { cout<<*iter2<<" "; ++iter2; } else { cout<<*iter1<<" "; ++iter1; ++iter2; } } while(iter1 != a.end()) { cout<<*iter1++<<" "; } while(iter2 != b.end()) { cout<<*iter2++<<" "; } cout<<endl; }