剑桥offer（11~20）
11.题目描述
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
class Solution {
public:
int NumberOf1(int n) {
int count = ;
unsigned int num = n;
while (num != ) {
if ((num & ) == ){
count++;
}
num = num >> ;
}
return count;
}
};
12题目描述
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
class Solution {
public:
double Power(double base, int exponent) {
double result=;
if (exponent == ){
return ;
}
else{
if (abs(exponent) == ){
return base;
}
result = base;
for (int i = ; i <= abs(exponent); i++){
result *= base;
}
}
if (exponent > ){
return result;
}
else{
return / result;
}
}
};
13.题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
class Solution {
public:
void reOrderArray(vector<int> &array) {
for (int i = ; i < array.size(); i++){
if(array[i]%==){
for(int j=i+;j< array.size();j++){
if((array[j]%==)){
int tmp = array[j];
for(int k =j;k>i;k--){
array[k]= array[k-];
}
array[i]=tmp;
break;
}
}
}
}
}
};
14.题目描述
输入一个链表，输出该链表中倒数第k个结点。
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) { ListNode*head = pListHead;
ListNode*nodeK=pListHead;
int len=;//链表总长
int index=;// if(k<=){
return NULL;
}
while(head!=NULL){
len++;
head=head->next;
}
if(k>len){
return NULL;
}
index = len-k; while(index--){
nodeK = nodeK->next;
}
return nodeK; }
};
15.题目描述
输入一个链表，反转链表后，输出链表的所有元素。
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
ListNode* ReverseList(ListNode* pHead) { ListNode* h = NULL;
ListNode* p = pHead;
while(p){
ListNode* tmp = p -> next;
p -> next = h;
h = p;
p = tmp;
}
return h;
} };
16.题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
/*
{
ListNode *head = NULL, *node = NULL;
while (pHead1 || pHead2){
if (((pHead1 == NULL) && (pHead2 != NULL)) || pHead1->val >= pHead2->val){
if (head){
node->next = pHead2;
node = pHead2;
}
else{
node = pHead2;
head = pHead2;
}
pHead2 = pHead2->next;
}
else if (((pHead2 == NULL) && (pHead1 != NULL)) || pHead1->val <= pHead2->val){
if (head){
node->next = pHead1;
node = pHead1;
}
else{
node = pHead1;
head = pHead1;
}
pHead1 = pHead1->next;
}
}
node->next=NULL;
return head;
}
*/
{
ListNode *head = NULL, *node = NULL;
if (pHead1 == NULL)
return pHead2;
if (pHead2 == NULL)
return pHead1;
while (pHead1 && pHead2){
if ( pHead1->val >= pHead2->val){
if (head){
node->next = pHead2;
node = pHead2;
}
else{
node = pHead2;
head = pHead2;
}
pHead2 = pHead2->next;
}
else if ( pHead1->val <= pHead2->val){
if (head){
node->next = pHead1;
node = pHead1;
}
else{
node = pHead1;
head = pHead1;
}
pHead1 = pHead1->next;
}
}
if (pHead1 == NULL){
node->next = pHead2;
}
if (pHead2 == NULL){
node->next = pHead1;
}
return head;
}
};
11.题目描述
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
思路：A包含B，遍历A，当A的一个节点和B相等，就一直遍历，直到B的节点为NULL。
12.题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。
思路：使用swap函数
13.题目描述
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
思路：添加数据，删除第一行数据，然后逆转矩阵，直到最后。
http://www.cnblogs.com/yuguangyuan/p/5915442.html
主要是使用了vector的方法：删除erase，清空clear，指定大小resize，添加元素push_back.
14.题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。
思路：觉得这个题，我没有理解。
class Solution {
stack<int> data;
stack<int> mindata;
public:
void push(int value) {
data.push(value);
if (mindata.size() <= ){
mindata.push(value);
}
else if (value < mindata.top()){
mindata.push(value);
}
else if (value >= mindata.top()){
mindata.push(mindata.top());
}
}
void pop() {
data.pop();
mindata.pop();
}
int top() {
return mindata.top();
}
int min() {
return mindata.top();
}
};
15.题目描述
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
思路：
class Solution {
public:
bool IsPopOrder(vector<int> pushV,vector<int> popV) {
stack<int>tmp;
int size = pushV.size();
if(size == ) return false;
for(int i=,j=;i<size;){
tmp.push(pushV[i++]);
while(j<size && tmp.top() == popV[j]){
j++;
tmp.pop();
}
}
return tmp.empty();
}
};
16题目描述
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
思路：使用队列存放各个节点，因为不是递归的调用，所以大胆的按顺序放入队列，然后出列即可。
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
vector<int> PrintFromTopToBottom(TreeNode *root) {
queue<TreeNode*>q;
vector<int>v;
TreeNode *node = root;
v.clear();
if(root == NULL){
return v;
}
q.push(node);
while(!q.empty()){
node = q.front();
q.pop();
if(!node){
continue;
}
v.push_back(node->val);
q.push(node->left);
q.push(node->right);
}
return v;
}
};
17.题目描述
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
思路:非递归的，去掉根后，前一个相当于根，这样就能一直循环下去了。
//非递归
//非递归也是一个基于递归的思想：
//左子树一定比右子树小，因此去掉根后，数字分为left，right两部分，right部分的
//最后一个数字是右子树的根他也比左子树所有值大，因此我们可以每次只看有子树是否符合条件
//即可，即使到达了左子树左子树也可以看出由左右子树组成的树还想右子树那样处理 //对于左子树回到了原问题，对于右子树，左子树的所有值都比右子树的根小可以暂时把他看出右子树的左子树
//只需看看右子树的右子树是否符合要求即可
class Solution {
public:
bool VerifySquenceOfBST(vector<int> sequence) {
int size = sequence.size();
if(==size)return false; int i = ;
while(--size)
{
while(sequence[i++]<sequence[size]);
while(sequence[i++]>sequence[size]); if(i<size)return false;
i=;
}
return true;
}
}; BST的后序序列的合法序列是，对于一个序列S，最后一个元素是x （也就是根），如果去掉最后一个元素的序列为T，那么T满足：T可以分成两段，前一段（左子树）小于x，后一段（右子树）大于x，且这两段（子树）都是合法的后序序列。完美的递归定义 : ) 。
class Solution {
bool judge(vector<int>& a, int l, int r){
if(l >= r) return true;
int i = r;
while(i > l && a[i - ] > a[r]) --i;
for(int j = i - ; j >= l; --j) if(a[j] > a[r]) return false;
return judge(a, l, i - ) && (judge(a, i, r - ));
}
public:
bool VerifySquenceOfBST(vector<int> a) {
if(!a.size()) return false;
return judge(a, , a.size() - );
}
};
18.题目描述
输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
思路：每一轮递归返回到父结点时，当前路径也应该回退一个结点。（不好理解）
class Solution {
vector<vector<int> >allRes;
vector<int> tmp;
void dfsFind(TreeNode * node , int left){
tmp.push_back(node->val);
if(left-node->val == && !node->left && !node->right)
allRes.push_back(tmp);
else {
if(node->left) dfsFind(node->left, left-node->val);
if(node->right) dfsFind(node->right, left-node->val);
}
tmp.pop_back();
}
public:
vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
if(root) dfsFind(root, expectNumber);
return allRes;
}
};
19题目描述
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
思路1：先建一个next的链表，再加上random链。
/*
struct RandomListNode {
int label;
struct RandomListNode *next, *random;
RandomListNode(int x) :
label(x), next(NULL), random(NULL) {
}
};
*/ class Solution { public:
RandomListNode* searchNode(RandomListNode* pHead, int value){
RandomListNode* FHead = pHead;
if(!FHead)
return NULL;
while (FHead&&FHead->label != value){
FHead = FHead->next;
}
if (FHead&&FHead->label == value)
return FHead;
else
return NULL;
} public:
RandomListNode* Clone(RandomListNode* pHead)
{
if(!pHead)
return NULL;
RandomListNode* pHead1 = pHead;
RandomListNode* newHead = NULL;
RandomListNode* FHead = NULL; //首先构造一个正顺序的链表
while (pHead1 != NULL){ RandomListNode *node = new RandomListNode(pHead1->label);
if (newHead == NULL){
newHead = node;
FHead = node;
}
else{
FHead->next = node;
FHead = FHead->next;
}
pHead1 = pHead1->next;
} pHead1 = pHead;
FHead = newHead;
while (pHead1 != NULL){
if(pHead1->random){
FHead->random = searchNode(newHead, (int)pHead1->random->label);
}
FHead = FHead->next;
pHead1 = pHead1->next;
}
return newHead;
}
};
思路2：
/*
struct RandomListNode {
int label;
struct RandomListNode *next, *random;
RandomListNode(int x) :
label(x), next(NULL), random(NULL) {
}
};
*/
class Solution {
public:
//复制原始链表的任一节点N并创建新节点N'，再把N'链接到N的后边
void CloneNodes(RandomListNode* pHead)
{
RandomListNode* pNode=pHead;
while(pNode!=NULL)
{
RandomListNode* pCloned=new RandomListNode();
pCloned->label=pNode->label;
pCloned->next=pNode->next;
pCloned->random=NULL; pNode->next=pCloned; pNode=pCloned->next;
}
}
//如果原始链表上的节点N的random指向S，则对应的复制节点N'的random指向S的下一个节点S'
void ConnectRandomNodes(RandomListNode* pHead)
{
RandomListNode* pNode=pHead;
while(pNode!=NULL)
{
RandomListNode* pCloned=pNode->next;
if(pNode->random!=NULL)
pCloned->random=pNode->random->next;
pNode=pCloned->next;
}
}
//把得到的链表拆成两个链表，奇数位置上的结点组成原始链表，偶数位置上的结点组成复制出来的链表
RandomListNode* ReConnectNodes(RandomListNode* pHead)
{
RandomListNode* pNode=pHead;
RandomListNode* pClonedHead=NULL;
RandomListNode* pClonedNode=NULL; //初始化
if(pNode!=NULL)
{
pClonedHead=pClonedNode=pNode->next;
pNode->next=pClonedNode->next;
pNode=pNode->next; }
//循环
while(pNode!=NULL)
{
pClonedNode->next=pNode->next;
pClonedNode=pClonedNode->next;
pNode->next=pClonedNode->next;
pNode=pNode->next;
} return pClonedHead; }
//三步合一
RandomListNode* Clone(RandomListNode* pHead)
{
CloneNodes(pHead);
ConnectRandomNodes(pHead);
return ReConnectNodes(pHead);
}
};
class Solution {
public:
/*
1、复制每个节点，如：复制节点A得到A1，将A1插入节点A后面
2、遍历链表，A1->random = A->random->next;
3、将链表拆分成原链表和复制后的链表
*/
RandomListNode* Clone(RandomListNode* pHead)
{
if(!pHead) return NULL;
RandomListNode *currNode = pHead;
while(currNode){
RandomListNode *node = new RandomListNode(currNode->label);
node->next = currNode->next;
currNode->next = node;
currNode = node->next;
}
currNode = pHead;
while(currNode){
RandomListNode *node = currNode->next;
if(currNode->random){
node->random = currNode->random->next;
}
currNode = node->next;
}
//拆分
RandomListNode *pCloneHead = pHead->next;
RandomListNode *tmp;
currNode = pHead;
while(currNode->next){
tmp = currNode->next;
currNode->next =tmp->next;
currNode = tmp;
}
return pCloneHead;
}
};
20.题目描述
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
思路：就是中序遍历，然后加入链表。
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
TreeNode* Convert(TreeNode* pRootOfTree)
{
stack<TreeNode*> stack;
TreeNode*root=NULL; TreeNode *p = pRootOfTree;
TreeNode *pre=NULL;
bool isFirst=true;
//栈不空或者p不空时循环
while (p || !stack.empty()){
while (p != NULL){
//存入栈中
stack.push(p);
//遍历左子树
p = p->left;
}
p = stack.top();
stack.pop();
if(isFirst){
root=p;
pre = root;
isFirst=false;
}else
{
pre->right = p;
p->left = pre;
pre = p;
}
p = p->right;
}//while
return root;
}
};
递归
//直接用中序遍历
public class Solution {
TreeNode head = null;
TreeNode realHead = null;
public TreeNode Convert(TreeNode pRootOfTree) {
ConvertSub(pRootOfTree);
return realHead;
} private void ConvertSub(TreeNode pRootOfTree) {
if(pRootOfTree==null) return;
ConvertSub(pRootOfTree.left);
if (head == null) {
head = pRootOfTree;
realHead = pRootOfTree;
} else {
head.right = pRootOfTree;
pRootOfTree.left = head;
head = pRootOfTree;
}
ConvertSub(pRootOfTree.right);
}
}
剑桥offer（11~20）的更多相关文章
- ⛅剑指 Offer 11. 旋转数组的最小数字
20207.22 LeetCode 剑指 Offer 11. 旋转数组的最小数字 把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转.输入一个递增排序的数组的一个旋转,输出旋转数组的最小 ...
- [剑指 Offer 11. 旋转数组的最小数字]
[剑指 Offer 11. 旋转数组的最小数字] 把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转.输入一个递增排序的数组的一个旋转,输出旋转数组的最小元素.例如,数组 [3,4,5, ...
- java实现《剑指offer》（二）11~20 更新中
11.二进制中1的个数 输入一个整数,输出该数二进制表示中1的个数.其中负数用补码表示. (1)最优解 public class Solution { public int NumberOf1(int ...
- 原生JavaScript技巧大收集(11~20)-(终于又被我找到这篇文章了)
11.原生JavaScript加入收藏夹 function AddFavorite(sURL, sTitle) { try { window.external.addFavorite(sURL, sT ...
- 20道C#练习题（二）11——20题
11.一个游戏,前20关是每一关自身的分数,1-30关每一关是10分,31-40关,每一关是20分,1-49关,每一关是30分,第50关是100分,输入你现在闯到的关卡数,求你现在拥有的分数.利用if ...
- 【Java】 剑指offer(11) 矩阵中的路径
本文参考自<剑指offer>一书,代码采用Java语言. 更多:<剑指Offer>Java实现合集 题目 请设计一个函数,用来判断在一个矩阵中是否存在一条包含某字符串所有字 ...
- 剑指offer（20）包含min函数的栈
题目描述 定义栈的数据结构,请在该类型中实现一个能够得到栈最小元素的min函数. 题目分析 首先一开始我们分析得到最小值肯定要比较嘛,和栈里面的数据一一比较,但是栈这种数据结构,你又只能和栈顶弹出来的 ...
- 剑桥offer(31~40)
31.题目描述 统计一个数字在排序数组中出现的次数. 思路:找到最低和最高,相减 class Solution { public: int GetNumberOfK(vector<int> ...
- 软件工程项目组Z.XML会议记录 2013/11/20
软件工程项目组Z.XML会议记录 [例会时间]2013年11月20日星期三21:00-22:00 [例会形式]小组讨论 [例会地点]学生公寓3号楼会客厅 [例会主持]李孟 [会议记录]李孟 会议整体流 ...
随机推荐
- 【system.folder】使用说明
对象:system.folder 说明:提供一系列针对文件夹的操作 目录: 方法 返回 说明 system.folder.exists(folderPath) [True | False] 检测指定文 ...
- spark相关脚本解析
spark-shell/spark-submit/pyspark等关系如下: #spark-submit 逻辑: ########################################### ...
- [C++] Class (part 1)
The fundamental ideas behind classes are data abstraction and encapsulation. Data abstraction is a p ...
- Python面向对象-类成员
类的成员可以分为三大类:字段.方法和属性: 注:所有成员中,只有普通字段的内容保存对象中,即:根据此类创建了多少对象,在内存中就有多少个普通字段.而其他的成员,则都是保存在类中,即:无论对象的多少,在 ...
- HDU 1007 Quoit Design（计算几何の最近点对）
Problem Description Have you ever played quoit in a playground? Quoit is a game in which flat rings ...
- Zen Coding && Emmet-Sublime 安装
Sublime Text 插件之:Emmet,旧版称:ex-Zen Coding 更名之后增加了CSS3和HTML5许多新特性.项目地址也从 code.google 移 github. 安装: Pac ...
- Python的top-level脚本为什么在磁盘上没有对应的字节码？
在Python中,如果你使用python script.py这样的方式运行Python脚本,那么script.py就被称为top-level脚本.对于Python来说,这个脚本的字节码是不会写入到磁盘 ...
- Generating a PDF in Codeigniter using mPDF
https://arjunphp.com/generating-a-pdf-in-codeigniter-using-mpdf/
- maven仓库中添加自定义的包jar包
mvn install:install-file -DgroupId=impl -DartifactId=center -Dversion=1.0 -Dpackaging=jar -Dfile=D:\ ...
- Nautilus-Share-Message: Called "net usershare info" but it failed: Failed to
See what nautilus processes are running : ps aux | grep nautilus Kill all nautilus processes you see ...