劍指offer題目
1.二叉樹映象
python:
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 返回映象樹的根節點
def Mirror(self, root):
if root == None:
return
self.Mirror(root.left)
self.Mirror(root.right)
root.left,root.right = root.right,root.left
C++:
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
void Mirror(TreeNode *pRoot) {
if (pRoot) {
Mirror(pRoot->left);
Mirror(pRoot->right );
TreeNode *temp=pRoot->left;
pRoot->left=pRoot->right;
pRoot->right=temp;
}
}
};
2.判斷連結串列中是否包含環,輸出環入口節點,否則輸出NULL
思路:
該題使用一種巧妙的方法,使用兩個步長分別是1和2的指標
python
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def EntryNodeOfLoop(self, pHead):
if pHead== None or pHead.next == None:
return None
fast = slow = pHead
while(fast and fast.next):
slow = slow.next
fast = fast.next.next
if slow == fast:
fast = pHead
while(fast!=slow):
fast = fast.next
slow = slow.next
return fast
return None
C++
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};
*/
class Solution {
public:
ListNode* EntryNodeOfLoop(ListNode* pHead)
{
if ((pHead->next==NULL)||(pHead==NULL)) return NULL;
ListNode* fast = pHead;
ListNode* slow = pHead;
bool isCycle = false;
while((fast!=NULL)&&(slow!=NULL)){
fast=fast->next;
slow=slow->next;
if (fast->next==NULL)return NULL;
fast=fast->next;
if(fast==slow){isCycle=true;break;}
}
if(!isCycle)return NULL;
fast=pHead;
while(fast!=slow){
fast=fast->next;
slow=slow->next;
}
return fast;
}
};
3.刪除連結串列重複節點
python
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def deleteDuplication(self, pHead):
# write code here
if(pHead==None):
return None
if(pHead.next==None):
return pHead
val = pHead.val
p = pHead.next
if(val!=p.val):
pHead.next=self.deleteDuplication(p)
return pHead
else:
while (p and (val==p.val)):
p=p.next
return self.deleteDuplication(p)
c++
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};
*/
class Solution {
public:
ListNode* deleteDuplication(ListNode* pHead)
{
if (!pHead) return 0;
if (!pHead->next) return pHead;
int val = pHead->val;
ListNode* p = pHead->next;
if (p->val != val) {
pHead->next = deleteDuplication(p);
return pHead;
} else {
while (p && p->val == val) p = p->next;
return deleteDuplication(p);
}
}
};
4.反轉連結串列
使用python array與c++ STL自帶的reverse函式即可
python
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
# 返回從尾部到頭部的列表值序列,例如[1,2,3]
def printListFromTailToHead(self, listNode):
# write code here
ret = []
head = listNode
while(head):
ret.append(head.val)
head = head.next
ret.reverse()
return ret
c++
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* ListNode(int x) :
* val(x), next(NULL) {
* }
* };
*/
class Solution {
public:
vector<int> printListFromTailToHead(ListNode* head) {
vector<int> myvector;
while(head!=NULL){myvector.push_back(head->val);head=head->next;}
reverse(myvector.begin(),myvector.end());
return myvector;
}
};
5.斐波那契數列
python
# -*- coding:utf-8 -*-
class Solution:
def Fibonacci(self, n):
# write code here
if n==0:
return 0;
elif n==1:
return 1;
else:
a0=0;
a1=1;
for i in range(n-1):
a2=a0+a1;
a0=a1;
a1=a2;
return a2
C++
class Solution {
public:
int Fibonacci(int n) {
if (n ==0) return 0;
else if(n == 1) return 1;
else{
int a0 = 0;
int a1 = 1;
int a2;
for (int i=0;i<n-1;i++){
a2 = a0 + a1;
a0 = a1;
a1 = a2;
}
return a2;
}
}
};
6.青蛙跳臺階,一次跳1或2階,共n階,幾種跳法
思路:
f(1)=1
f(2)=2
…
f(n)=f(n-1)+f(n-2)
注意:遞迴效率低,重複呼叫函式,儘量使用迭代。
python
# -*- coding:utf-8 -*-
class Solution:
def jumpFloor(self, number):
# write code here
if number==1:
return 1
elif number==2:
return 2
else:
a0=1
a1=2
for i in range(number-2):
a2=a0+a1
a0=a1
a1=a2
return a2
c++
class Solution {
public:
int jumpFloor(int number) {
if (number==0)return 0;
else if (number==1)return 1;
else if (number==2)return 2;
else
return jumpFloor(number-1)+jumpFloor(number-2);
}
};
7.變態跳臺階,一次可以跳1~n階
思路:
f(1)=1
f(2)=f(1)+1
f(3)=f(2)+f(1)+1=2*f(2)
…
f(n)=2*f(n-1)
python
# -*- coding:utf-8 -*-
class Solution:
def jumpFloorII(self, number):
# write code here
a0=1
for i in range(number-1):
a0=a0*2
return a0
C++
class Solution {
public:
int jumpFloorII(int number) {
int a0 = 1;
for(int i=0;i<number-1;i++){
a0=a0*2;
}
return a0;
}
};
8.矩陣覆蓋
用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形,總共有多少種方法
思路:依舊斐波那契
python
# -*- coding:utf-8 -*-
class Solution:
def rectCover(self, number):
# write code here
if number==1:
return 1
elif number==2:
return 2
elif number==0:
return 0
else:
a0=1
a1=2
for i in range(number-2):
a2=a0+a1
a0=a1
a1=a2
return a2
c++
class Solution {
public:
int rectCover(int number) {
if(number==1)return 1;
else if(number==2)return 2;
else if(number==0)return 0;
else{
int a0=1;
int a1=2;
int a2;
for(int i=0;i<number-2;i++){
a2=a0+a1;
a0=a1;
a1=a2;
}
return a2;
}
}
};
9.字串轉整數
將一個字串轉換成一個整數(實現Integer.valueOf(string)的功能,但是string不符合數字要求時返回0),要求不能使用字串轉換整數的庫函式。 數值為0或者字串不是一個合法的數值則返回0
python
# -*- coding:utf-8 -*-
class Solution:
def StrToInt(self, s):
# write code here
symbol=1
num=0
if s=='':
return 0
for i in s:
if i=='+':
symbol=1
elif i=='-':
symbol=-1
elif i>'0' and i<'9':
num=num*10+int(i)
else:
return 0
return symbol*num
c++
class Solution {
public:
int StrToInt(string str) {
int symbol = 1;
int num=0;
for (int i=0;i<str.size();i++){
if (str[i]=='+')symbol=1;
else if(str[i]=='-')symbol=-1;
else if((str[i]>'0')&&(str[i]<'9'))num=num*10+(str[i]-'0');
else return 0;
}
return symbol*num;
}
};
10.平衡二叉樹的判斷
思路:BST的定義為|height(lefttree)−height(righttree)|<=1且兩個子樹均為BST,原問題拆分為計算樹高度和判斷高度差
python
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def IsBalanced_Solution(self, pRoot):
# write code here
if pRoot==None:
return True
h1=self.Get_Tree_Height(pRoot.left)
h2=self.Get_Tree_Height(pRoot.right)
if(h1-h2)<=1 and(h2-h1)<=1:
return True
else:
return False
def Get_Tree_Height(self, pRoot):
if pRoot==None:
return 0
else:
return max(self.Get_Tree_Height(pRoot.left),self.Get_Tree_Height(pRoot.right))+1
c++
class Solution {
public:
int TreeDepth(TreeNode *pRoot)
{
if (pRoot == NULL)
return 0;
int left = TreeDepth(pRoot->left);
int right = TreeDepth(pRoot->right);
return (left > right) ? (left + 1) : (right + 1);
}
bool IsBalanced_Solution(TreeNode* pRoot) {
if (pRoot == NULL)
return true;
int left = TreeDepth(pRoot->left);
int right = TreeDepth(pRoot->right);
int diff = left - right;
if (diff > 1 || diff < -1)
return false;
return IsBalanced_Solution(pRoot->left) && IsBalanced_Solution(pRoot->right);
}
};
11.和為S的連續正數序列
輸出所有和為S的連續正數序列。序列內按照從小至大的順序,序列間按照開始數字從小到大的順序
思考:S%奇數==0 或者S%偶數==偶數/2 就說明有這個連續序列,但是注意是正數序列,可能會出現越界情況
python
# -*- coding:utf-8 -*-
class Solution:
def FindContinuousSequence(self, tsum):
# write code here
k = 2
ret = []
for k in range(2,tsum):
if k%2==1 and tsum%k==0:
tmp = []
mid = tsum/k
if mid-k/2>0:
for i in range(mid-k/2,mid+k/2+1):
tmp.append(i)
ret.append(tmp[:])
elif k%2==0 and (tsum%k)*2==k:
mid = tsum/k
tmp = []
if mid-k/2+1>0:
for i in range(mid-k/2+1,mid+k/2+1):
tmp.append(i)
ret.append(tmp[:])
ret.sort()
return ret
c++
class Solution {
public:
vector<vector<int> > FindContinuousSequence(int sum) {
int l = 1,r = 1,sumx = 1;
vector<vector<int> > ans;
while(l <= r){
r ++;
sumx += r;
while(sumx > sum){
sumx -= l;
l ++;
}
if(sumx == sum && l != r){
vector<int> tmp;
for(int i = l;i <= r;i ++) tmp.push_back(i);
ans.push_back(tmp);
}
}
return ans;
}
};
12.左旋轉字串
對於一個給定的字元序列S,請你把其迴圈左移K位後的序列輸出。
python
# -*- coding:utf-8 -*-
class Solution:
def LeftRotateString(self, s, n):
# write code here
if s=='':
return s
mov=n%len(s)
news=s[mov:]+s[:mov]
return news
c++
class Solution {
public:
string LeftRotateString(string str, int n) {
int lstr=str.size();
if (lstr==0)return str;
int mov=n%lstr;
string newstr;
for(int i = mov;i<lstr;i++)newstr.push_back(str[i]);
for(int i = 0;i<mov;i++)newstr.push_back(str[i]);
return newstr;
}
};
13.數字在排序陣列中出現的次數
思路:二分查詢
python
# -*- coding:utf-8 -*-
class Solution:
def GetNumberOfK(self, data, k):
# write code here
start = 0
end = len(data)-1
while(start<=end):
mid = (start+end)/2
if data[mid]==k:
cnt = 0
tmp = mid
while(tmp>=0 and data[tmp]==k):
cnt+=1
tmp-=1
tmp = mid+1
while(tmp<len(data) and data[tmp]==k):
cnt+=1
tmp+=1
return cnt
elif data[mid]>k:
end = mid-1
else:
start = mid+1
return 0
C++
class Solution {
public:
int GetNumberOfK(vector<int> data ,int k) {
if(data.size()==0)return 0;
int len=data.size();
int KeyIndex=0;
KeyIndex=BinarySearch(data,0,len-1,k);
if(KeyIndex==-1) return 0;
int sumber=1;
int m=KeyIndex-1;
int n=KeyIndex+1;
while(m>=0&&data[m]==k)
{
m--;sumber++;
}
while(n<len&&data[n]==k)
{
n++; sumber++;
}
return sumber;
}
int BinarySearch(vector<int> data, int low, int high, int k){
while (low<=high){
int m = (high + low) / 2;
if (data[m] == k)return m;
else if (data[m] < k) low = m+ 1;
else high = m - 1;}
return -1;
}
};
14.陣列中只出現一次的數字
思路:在其他題目中,要求時間複雜度為O(n),排除先排序;空間複雜度要求O(1),排除hash思路。考慮到對於一個int型別變數a,a與0的異或為本身,與自身的異或為0,因此可以將所有數字依次異或,這樣偶數次數的數字被消除,僅剩一次的數字。但本題中有兩個這樣的數字,因此需要將兩個數字分離成兩堆。在將所有數字異或後,所得結果即所求兩個數字的異或值,因此可從兩個數字的異或值中第一位不是0的位出手,將所有數字根據此位是否為1分為兩堆,兩堆分別求異或值結果即所求兩數。
python
class Solution:
# 返回[a,b] 其中ab是出現一次的兩個數字
def FindNumsAppearOnce(self, array):
# write code here
ans,a1,a2,flag= 0,0,0,1
for num in array:
ans = ans ^ num
while(ans):
if ans%2 == 0:
ans = ans >>1
flag = flag <<1
else:
break
for num in array:
if num & flag:
a1 = a1 ^ num
else:
a2 = a2 ^ num
return a1,a2
c++
class Solution {
public:
void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
if (data.size() < 2)
return;
int resultExclusiveOR = 0;
for (int i = 0; i < data.size(); ++ i)
resultExclusiveOR ^= data[i];
unsigned int indexOf1 = FindFirstBitIs1(resultExclusiveOR);
*num1 = *num2 = 0;
for (int j = 0; j < data.size(); ++ j){
if(IsBit1(data[j], indexOf1))
*num1 ^= data[j];
else
*num2 ^= data[j];
}
}
unsigned int FindFirstBitIs1(int num){
int indexBit = 0;
while (((num & 1) == 0) && (indexBit < 32)){
num = num >> 1;
indexBit++;}
return indexBit;
}
bool IsBit1(int num, unsigned int indexBit){
num = num >> indexBit;
return (num & 1);}
};
15.翻轉單詞順序列
將句子中由空格間隔的各詞彙順序翻轉。
python
# -*- coding:utf-8 -*-
class Solution:
def ReverseSentence(self, s):
# write code here
ret = s.split(" ")
ret.reverse()
return ' '.join(ret)
c++
class Solution {
public:
string ReverseSentence(string str) {
int len = str.size();
int start = 0;
for(int i = 0; i < len; i ++){
if(str[i] == ' '){
reverse(str.begin()+start, str.begin()+i);
start = i+1;
}
if(i == len-1){
reverse(str.begin()+start, str.end());
}
}
reverse(str.begin(), str.end());
return str;
}
};
16.二叉樹深度
python
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def TreeDepth(self, pRoot):
# write code here
if(pRoot==None):
return 0
h1 = self.TreeDepth(pRoot.left);
h2 = self.TreeDepth(pRoot.right);
if h1>h2:
return h1+1
else:
return h2+1
c++
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
int TreeDepth(TreeNode* pRoot)
{
if (pRoot==NULL)return 0;
int depth1 = TreeDepth(pRoot->left);
int depth2 = TreeDepth(pRoot->right);
int depth = (depth1 > depth2 ? depth1 : depth2)+1;
return depth;
}
};
17.和為S的兩個數字
輸入一個遞增排序的陣列和一個數字S,在陣列中查詢兩個數,是的他們的和正好是S,如果有多對數字的和等於S,輸出兩個數的乘積最小的。
思路:採用兩個指標分別從陣列兩端向中間推進,最先滿足條件的兩個數乘積最小。
python
# -*- coding:utf-8 -*-
class Solution:
def FindNumbersWithSum(self, array, tsum):
# write code here
a1=0
a2=-1
while(a1-a2<len(array)):
if(array[a1]+array[a2]<tsum):
a1+=1
elif(array[a1]+array[a2]>tsum):
a2-=1
else:
return [array[a1],array[a2]]
return[]
c++
class Solution {
public:
vector<int> FindNumbersWithSum(vector<int> array,int sum) {
int len = array.size();
vector<int>twonum;
if (len<=1)return twonum;
int v1=0,v2=len-1;
while(v1!=v2){
if((array[v1]+array[v2])<sum)v1++;
else if((array[v1]+array[v2])>sum)v2--;
else {twonum.push_back(array[v1]);twonum.push_back(array[v2]);break;}
}
return twonum;
}
};
18.順時針列印矩陣
python
# -*- coding:utf-8 -*-
class Solution:
# matrix型別為二維列表,需要返回列表
def printMatrix(self, matrix):
# write code here
m=len(matrix)
ans=[]
if m==0:
return ans
n=len(matrix[0])
w1=0;w2=n-1;h1=0;h2=m-1;
while(True):
if((w1>w2)or(h1>h2)):
break;
for i in range(w1,w2+1):
ans.append(matrix[h1][i])
h1=h1+1
if((w1>w2)or(h1>h2)):
break;
for i in range(h1,h2+1):
ans.append(matrix[i][w2])
w2=w2-1
if((w1>w2)or(h1>h2)):
break;
for i in range(w1,w2+1):
ans.append(matrix[h2][n-2-i])
h2=h2-1
if((w1>w2)or(h1>h2)):
break;
for i in range(h1,h2+1):
ans.append(matrix[m-1-i][w1])
w1=w1+1
return ans
c++
class Solution {
public:
vector<int> printMatrix(vector<vector<int>> matrix) {
int row=matrix.size();
int col=matrix[0].size();
vector<int> result;
if(row==0||col==0)
return result;
int left=0,right=col-1,top=0,btm=row-1;
while(left<=right&&top<=btm)
{
for(int i=left;i<=right;i++)
result.push_back(matrix[top][i]);
if(top<btm)
for(int i=top+1;i<=btm;i++)
result.push_back(matrix[i][right]);
if(top<btm&&left<right)
for(int i=right-1;i>=left;i--)
result.push_back(matrix[btm][i]);
if(top+1<btm&&left<right)
for(int i=btm-1;i>=top+1;i--)
result.push_back(matrix[i][left]);
left++;right--;top++;btm--;
}
return result;
}
};
19.二叉樹的下一個結點
給定一個二叉樹和其中的一個結點,請找出中序遍歷順序的下一個結點並且返回。注意,樹中的結點不僅包含左右子結點,同時包含指向父結點的指標。
思路:中序遍歷,根據其是否含有右子樹、若無則返回父節點等系列條件判斷
python
class Solution:
def GetNext(self, pNode):
# write code here
# left root right
if pNode == None:
return None
if pNode.right:
tmp = pNode.right
while(tmp.left):
tmp = tmp.left
return tmp
p = pNode.next
while(p and p.right==pNode):
pNode = p
p = p.next
return p
c++
/*
struct TreeLinkNode {
int val;
struct TreeLinkNode *left;
struct TreeLinkNode *right;
struct TreeLinkNode *next;
TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) {
}
};
*/
class Solution {
public:
TreeLinkNode* GetNext(TreeLinkNode* pNode)
{
if(pNode->right!=NULL){
TreeLinkNode *temp=pNode->right;
while(temp->left!=NULL)temp=temp->left;
return temp;
}
else{
TreeLinkNode *temp=pNode;
while(temp->next!=NULL){
if(temp==temp->next->left)return temp->next;
else{temp=temp->next;}
}
return NULL;
}
}
};
20.
相關推薦
劍指Offer題目:字符串的排列
wap toc java res add font 16px turn return 題目描述:
輸入一個字符串,按字典序打印出該字符串中字符的所有排列。例如輸入字符串abc,則打印出由字符a,b,c所能排列出來的所有字符串abc,acb,bac,bca,cab和cba。
劍指Offer題目索引
兩個 打印 平衡二叉樹 代碼 知識 循環 加減乘 復雜 字符串 數組
數組中重復的數字
二維數組中的查找
構建乘積數組
字符串
替換空格
字符流中第一個不重復的字符
表示數值的字符串
遞歸和循環
斐波那契數列
跳臺階
變態跳臺階
矩形覆蓋
鏈表
從尾到頭打印鏈表
刪除鏈表中
劍指offer題目系列一
過程 一個數 1-1 二維數組 等於 style 所有 RR htm 本篇介紹《劍指offer》第二版中的四個題目:找出數組中重復的數字、二維數組中的查找、替換字符串中的空格、計算斐波那契數列第n項。
這些題目並非嚴格按照書中的順序展示的,而
劍指offer題目系列三(鏈表相關題目)
eight 信息 賦值 n) 內容 指針 alt 延續 合並兩個排序的鏈表 本篇延續上一篇劍指offer題目系列二,介紹《劍指offer》第二版中的四個題目:O(1)時間內刪除鏈表結點、鏈表中倒數第k個結點、反轉鏈表、合並兩個排序的鏈表。同樣,這些題目並非嚴
[持久更新] 劍指offer題目Python做題記錄
array tno 節點 gif tlist 思路 實現 span elf 第一題
題目:在一個二維數組中,每一行都按照從左到右遞增的順序排序,每一列都按照從上到下遞增的順序排序。請完成一個函數,輸入這樣的一個二維數組和一個整數,判斷數組中是否含有該整數。
思路:先
劍指offer題目答案集合
package org.nix.learn.offer;
import org.junit.jupiter.api.Test;
import sun.rmi.transport.tcp.TCPChannel;
import java.util.*;
import java
劍指offer題目
1.二叉樹映象
python:
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
#
【面試】劍指offer題目解析及tips速查(不斷更新中)
4、二維陣列中的查詢x:陣列從左到右遞增,從上到下遞增。P38
tips:右上角開始查詢,x小左移,x大下移。
tips+:陣列為空(空指標),行列<=0情況;左移和下移越界情況;引數為指標,根據記憶體儲存規則訪問陣列元素。
5、替換空格:實現函式將一個字串中所有空格替
牛客網劍指offer—題目一在一個二維陣列中,每一行都按照從左到右遞增的順序排序,每一列都按照從上到下遞增的順序排序。請完成一個函式,輸入這樣的一個二維陣列和一個整數,判斷陣列中是否含有該整數
在一個二維陣列中,每一行都按照從左到右遞增的順序排序,每一列都按照從上到下遞增的順序排序。請完成一個函式,輸入這樣的一個二維陣列和一個整數,判斷陣列中是否含有該整數。
思路:因為是隻需判斷有無該整數,所以用bool函式,返回false或true
假設是這樣一個數組
劍指offer題目分類
一、線性表
1、陣列
面試題3:二維陣列中的查詢
面試題14:調整陣列順序使得奇數位於偶數前面
面試題29:陣列中出現超過一半的數字
面試題30:最小的k個數
面試題33:把陣列排成最小的數
面試題36:陣列中的逆序對
面試題40:數字在排序陣列中出現的次數
面試題51:陣
劍指offer題目java實現
Problem2:實現Singleton模式
題目描述:設計一個類,我們只能生成該類的一個例項
1 package Problem2;
2
3 public class SingletonClass {
4
5 /*
6 * 題目描述:設計一個類,我們只能生成
劍指offer題目描述 輸入一個整數陣列,實現一個函式來調整該陣列中數字的順序,使得所有的奇數位於陣列的前半部分,所有的偶數位於位於陣列的後半部分,並保證奇數和奇數,偶數和偶數之間的相對位置不變。
牛客網劍指offer線上程式設計:
方法一:利用兩個指標,實現了是陣列奇數在前偶數在後,但通過不了測試用例,因為改變了奇數和奇數,偶數和偶數之間的相對位置
class Solution {
public:
void reOrderArray(vector<in
劍指offer算法編程題目部分匯總(解法略)
面試題 搜索 中序遍歷 順時針 路徑 奇數 第一個 重復 不同 總結一下本書中遇到的大部分面試題。面試題3:二維數組中的查找
題目:在一個二維數組中,每一行都按照從左到右的遞增順序排列,每一列都按照從上到下遞增的順序排列,請完成一個函數,輸入這樣的一個整數,判斷數組中是否含
《劍指Offer》題目——位運算
ati 劍指offer 多少 amp nes 位運算 規則 -s n) 題目描述:輸入一個整數,輸出該數二進制表示中1的個數。其中負數用補碼表示。
題目分析:無論使用什麽方式,最關鍵的就是要考慮負數的處理方式
public class NumberOfOne {
《劍指Offer》題目:樹的子結構
bool root 子結構 boolean res pub 二叉樹 amp turn 題目描述:樹的子結構
輸入兩棵二叉樹A,B,判斷B是不是A的子結構。(ps:我們約定空樹不是任意一個樹的子結構)
題目分析:此題可以拆成兩題,1.在二叉樹中查找是否存在某個結點;2.判斷兩
《劍指Offer》題目:合並兩個排序的鏈表
合成 sorted 合並 邊界情況 logs pub st2 next null 題目描述:輸入兩個單調遞增的鏈表list1,list2,輸出兩個鏈表合成後的鏈表,當然我們需要合成後的鏈表滿足單調不減規則。
題目分析:
1.對於鏈表題目,首先考慮邊界情況,即鏈表為空的情況,
《劍指Offer》題目:鏈表中倒數第k個結點
倒數 -- 輸出 col ota pan code 輸入 tno 題目描述:輸入一個鏈表,輸出該鏈表中倒數第k個結點
題目分析:因為不能直接從鏈表的尾部遍歷,所以要分兩步走:
第一步:從鏈表的頭部開始遍歷,直至鏈表的尾部,統計出鏈表結點的個數
第二步:根據鏈表結點的個數,計
《劍指Offer》題目:調整數組順序使奇數位於偶數前面
code ont else 指向 偶數 span cnblogs for emp 題目描述:調整數組順序使奇數位於偶數前
輸入一個整數數組,實現一個函數來調整該數組中數字的順序,使得所有的奇數位於數組的前半部分,所有的偶數位於位於數組的後半部分,並保證奇數和奇數,偶數和偶數
劍指Offer - 後面再做的題目
blog odin interview https 劍指offer coder class int odi https://www.nowcoder.com/practice/96bd6684e04a44eb80e6a68efc0ec6c5?tpId=13&tqId
leetcode 70. 爬樓梯【遞迴】【Easy】&& 劍指Offer面試題10 題目2:青蛙跳臺階問題
題目:
假設你正在爬樓梯。需要 n 階你才能到達樓頂。
每次你可以爬 1 或 2 個臺階。你有多少種不同的方法可以爬到樓頂呢?
注意:給定 n 是一個正整數。
示例 1:
輸入: 2
輸出: 2
解釋: 有兩種方法可以爬到樓頂。
1. 1
劍指Offer題目:字符串的排列
wap toc java res add font 16px turn return 題目描述: 輸入一個字符串,按字典序打印出該字符串中字符的所有排列。例如輸入字符串abc,則打印出由字符a,b,c所能排列出來的所有字符串abc,acb,bac,bca,cab和cba。
劍指Offer題目索引
兩個 打印 平衡二叉樹 代碼 知識 循環 加減乘 復雜 字符串 數組 數組中重復的數字 二維數組中的查找 構建乘積數組 字符串 替換空格 字符流中第一個不重復的字符 表示數值的字符串 遞歸和循環 斐波那契數列 跳臺階 變態跳臺階 矩形覆蓋 鏈表 從尾到頭打印鏈表 刪除鏈表中
劍指offer題目系列一
過程 一個數 1-1 二維數組 等於 style 所有 RR htm 本篇介紹《劍指offer》第二版中的四個題目:找出數組中重復的數字、二維數組中的查找、替換字符串中的空格、計算斐波那契數列第n項。 這些題目並非嚴格按照書中的順序展示的,而
劍指offer題目系列三(鏈表相關題目)
eight 信息 賦值 n) 內容 指針 alt 延續 合並兩個排序的鏈表 本篇延續上一篇劍指offer題目系列二,介紹《劍指offer》第二版中的四個題目:O(1)時間內刪除鏈表結點、鏈表中倒數第k個結點、反轉鏈表、合並兩個排序的鏈表。同樣,這些題目並非嚴
[持久更新] 劍指offer題目Python做題記錄
array tno 節點 gif tlist 思路 實現 span elf 第一題 題目:在一個二維數組中,每一行都按照從左到右遞增的順序排序,每一列都按照從上到下遞增的順序排序。請完成一個函數,輸入這樣的一個二維數組和一個整數,判斷數組中是否含有該整數。 思路:先
劍指offer題目答案集合
package org.nix.learn.offer; import org.junit.jupiter.api.Test; import sun.rmi.transport.tcp.TCPChannel; import java.util.*; import java
劍指offer題目
1.二叉樹映象 python: # -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None #
【面試】劍指offer題目解析及tips速查(不斷更新中)
4、二維陣列中的查詢x:陣列從左到右遞增,從上到下遞增。P38 tips:右上角開始查詢,x小左移,x大下移。 tips+:陣列為空(空指標),行列<=0情況;左移和下移越界情況;引數為指標,根據記憶體儲存規則訪問陣列元素。 5、替換空格:實現函式將一個字串中所有空格替
牛客網劍指offer—題目一在一個二維陣列中,每一行都按照從左到右遞增的順序排序,每一列都按照從上到下遞增的順序排序。請完成一個函式,輸入這樣的一個二維陣列和一個整數,判斷陣列中是否含有該整數
在一個二維陣列中,每一行都按照從左到右遞增的順序排序,每一列都按照從上到下遞增的順序排序。請完成一個函式,輸入這樣的一個二維陣列和一個整數,判斷陣列中是否含有該整數。 思路:因為是隻需判斷有無該整數,所以用bool函式,返回false或true 假設是這樣一個數組
劍指offer題目分類
一、線性表 1、陣列 面試題3:二維陣列中的查詢 面試題14:調整陣列順序使得奇數位於偶數前面 面試題29:陣列中出現超過一半的數字 面試題30:最小的k個數 面試題33:把陣列排成最小的數 面試題36:陣列中的逆序對 面試題40:數字在排序陣列中出現的次數 面試題51:陣
劍指offer題目java實現
Problem2:實現Singleton模式 題目描述:設計一個類,我們只能生成該類的一個例項 1 package Problem2; 2 3 public class SingletonClass { 4 5 /* 6 * 題目描述:設計一個類,我們只能生成
劍指offer題目描述 輸入一個整數陣列,實現一個函式來調整該陣列中數字的順序,使得所有的奇數位於陣列的前半部分,所有的偶數位於位於陣列的後半部分,並保證奇數和奇數,偶數和偶數之間的相對位置不變。
牛客網劍指offer線上程式設計: 方法一:利用兩個指標,實現了是陣列奇數在前偶數在後,但通過不了測試用例,因為改變了奇數和奇數,偶數和偶數之間的相對位置 class Solution { public: void reOrderArray(vector<in
劍指offer算法編程題目部分匯總(解法略)
面試題 搜索 中序遍歷 順時針 路徑 奇數 第一個 重復 不同 總結一下本書中遇到的大部分面試題。面試題3:二維數組中的查找 題目:在一個二維數組中,每一行都按照從左到右的遞增順序排列,每一列都按照從上到下遞增的順序排列,請完成一個函數,輸入這樣的一個整數,判斷數組中是否含
《劍指Offer》題目——位運算
ati 劍指offer 多少 amp nes 位運算 規則 -s n) 題目描述:輸入一個整數,輸出該數二進制表示中1的個數。其中負數用補碼表示。 題目分析:無論使用什麽方式,最關鍵的就是要考慮負數的處理方式 public class NumberOfOne {
《劍指Offer》題目:樹的子結構
bool root 子結構 boolean res pub 二叉樹 amp turn 題目描述:樹的子結構 輸入兩棵二叉樹A,B,判斷B是不是A的子結構。(ps:我們約定空樹不是任意一個樹的子結構) 題目分析:此題可以拆成兩題,1.在二叉樹中查找是否存在某個結點;2.判斷兩
《劍指Offer》題目:合並兩個排序的鏈表
合成 sorted 合並 邊界情況 logs pub st2 next null 題目描述:輸入兩個單調遞增的鏈表list1,list2,輸出兩個鏈表合成後的鏈表,當然我們需要合成後的鏈表滿足單調不減規則。 題目分析: 1.對於鏈表題目,首先考慮邊界情況,即鏈表為空的情況,
《劍指Offer》題目:鏈表中倒數第k個結點
倒數 -- 輸出 col ota pan code 輸入 tno 題目描述:輸入一個鏈表,輸出該鏈表中倒數第k個結點 題目分析:因為不能直接從鏈表的尾部遍歷,所以要分兩步走: 第一步:從鏈表的頭部開始遍歷,直至鏈表的尾部,統計出鏈表結點的個數 第二步:根據鏈表結點的個數,計
《劍指Offer》題目:調整數組順序使奇數位於偶數前面
code ont else 指向 偶數 span cnblogs for emp 題目描述:調整數組順序使奇數位於偶數前 輸入一個整數數組,實現一個函數來調整該數組中數字的順序,使得所有的奇數位於數組的前半部分,所有的偶數位於位於數組的後半部分,並保證奇數和奇數,偶數和偶數
劍指Offer - 後面再做的題目
blog odin interview https 劍指offer coder class int odi https://www.nowcoder.com/practice/96bd6684e04a44eb80e6a68efc0ec6c5?tpId=13&tqId
leetcode 70. 爬樓梯【遞迴】【Easy】&& 劍指Offer面試題10 題目2:青蛙跳臺階問題
題目: 假設你正在爬樓梯。需要 n 階你才能到達樓頂。 每次你可以爬 1 或 2 個臺階。你有多少種不同的方法可以爬到樓頂呢? 注意:給定 n 是一個正整數。 示例 1: 輸入: 2 輸出: 2 解釋: 有兩種方法可以爬到樓頂。 1. 1