剑桥offer(11~20)
11.题目描述
class Solution {
public:
int NumberOf1(int n) { int count = ;
unsigned int num = n;
while (num != ) {
if ((num & ) == ){
count++;
}
num = num >> ;
}
return count;
}
};
12题目描述
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.题目描述
/*
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.题目描述
12.题目描述
13.题目描述
14.题目描述
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.题目描述
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.题目描述
//非递归
//非递归也是一个基于递归的思想:
//左子树一定比右子树小,因此去掉根后,数字分为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题目描述
/*
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号楼会客厅 [例会主持]李孟 [会议记录]李孟 会议整体流 ...
随机推荐
- Objective-C 点语法 成员变量的作用域 @property和@synthesize关键字 id类型
点语法 1.利用点语法替换set方法和get方法 方法调用 Student *stu = [Student new]; [stu setAge : 18]; int age = [stu age]; ...
- Objective-C 封装 继承 多态
封装 #import <Foundation/Foundation.h> @interface Person : NSObject { //@public int _age; } - (v ...
- Java开发工程师(Web方向) - 03.数据库开发 - 第5章.MyBatis
第5章--MyBatis MyBatis入门 Abstract: 数据库框架的工作原理和使用方法(以MyBatis为例) 面向对象的世界与关系型数据库的鸿沟: 面向对象世界中的数据是对象: 关系型数据 ...
- Java开发工程师(Web方向) - 01.Java Web开发入门 - 第1章.Web应用开发概述
第1章--Web应用开发概述 Web应用开发概述 浏览器-服务器架构(BS-architecture) browser/ App ---- request ----> server ...
- NO.01---今天聊聊Vuex的简单入门
作为一款个人认为非常牛x的框架,个人使用起来得心应手,所以近期就记录一下这款框架吧. 首先说一说 Vuex 是什么? 官方给出的解释:Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式.它 ...
- LeetCode - 326, 342, 231 Power of Three, Four, and Two
1. 问题 231. Power of Two: 判断一个整数是否是2的n次方,其中n是非负整数 342. Power of Four: 判断一个整数是否是4的n次方,其中n是非负整数 326. Po ...
- Python3 数值类型与运算符
1.数值类型与进制 (1)基本类型 整型:int 浮点型:float 布尔类型:bool 复数:complex print(type(1)) print(type(1.1)) print(type(F ...
- Git 命令详解及常用命令
Git 命令详解及常用命令 Git作为常用的版本控制工具,多了解一些命令,将能省去很多时间,下面这张图是比较好的一张,贴出了看一下: 关于git,首先需要了解几个名词,如下: 1 2 3 4 Work ...
- 关于智能指针类型shared_ptr的计数问题
一.关键 每个shared_ptr所指向的对象都有一个引用计数,它记录了有多少个shared_ptr指向自己 shared_ptr的析构函数:递减它所指向的对象的引用计数,如果引用计数变为0,就会销毁 ...
- Beta版本软件使用说明
北京航空航天大学计算机学院 远航1617 小组 产品版本: Beta版本 产品名称:Crawling is going on 文档作者:杨帆 文档日期:2013/12/24 1. 引言 1.1 ...