牛客剑指offer编程题目C++实现

置顶 已于 2022-03-15 00:04:07 修改
阅读量2.3k 收藏 19
点赞数 3
分类专栏： 数据结构与算法 文章标签： c++ leetcode 排序算法
于 2019-08-22 21:20:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu502617169/article/details/90573483
版权

目录

1. 数组中重复的数字

数组中重复的数字

class Solution {
public:
    // Parameters:
    //        numbers:     an array of integers
    //        length:      the length of array numbers
    //        duplication: (Output) the duplicated number in the array number
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    bool duplicate(int numbers[], int length, int* duplication) {
        if(numbers==NULL||length<=0) return false;
        for(int i=0;i<length;++i){
            while(numbers[i]!=i){
                if(numbers[i]==numbers[numbers[i]]){
                    *duplication=numbers[i];
                    return true;
                }
                swap(numbers,i,numbers[i]);
            }
        }
        return false;
    }
    void swap(int nums[],int i,int j){
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
};

2. 二维数组中的查找

二维数组中的查找

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if(array.size()!=0){
            int row=0,col=array[0].size()-1;
            while(row<int(array.size())&&col>=0){
                if(array[row][col]==target) return true;
                else if(array[row][col]>target) 
                    --col;
                else
                    ++row;
            }
        }
        return false;
    }
};

3. 替换空格

替换空格

class Solution {
public:
	void replaceSpace(char *str,int length) {
        if(str==NULL) return;
        int iCountofblanks=0;
        int iOriginalLengths=0;
        for(int i=0;str[i]!='\0';++i){
            ++iOriginalLengths;
            if(str[i]==' ') ++iCountofblanks;
        }
        
        int iLen=iOriginalLengths+2*iCountofblanks;
        if(iLen+1>length) return;
        
        int iP1=iOriginalLengths,iP2=iLen;
        while(iP1<iP2){
            if(str[iP1]==' '){
                str[iP2--]='0';
                str[iP2--]='2';
                str[iP2--]='%';
            }
            else{
                str[iP2--]=str[iP1];
            }
            --iP1;
        }
	}
};

4. 从尾到头打印链表

从尾到头打印链表

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> vPrint;
        stack<int>  stkPrint;
        ListNode* p1=head;
        while(p1!=NULL){
            stkPrint.push(p1->val);
            p1=p1->next;
        }
        while(!stkPrint.empty()){
            vPrint.push_back(stkPrint.top());
            stkPrint.pop();
        }
        return vPrint;
    }
};

5. 重建二叉树

重建二叉树

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        if(pre.empty()) return NULL;
        vector<int> leftpre,leftvin,rightpre,rightvin;
        auto iterator_p1=pre.begin();
        auto iterator_p2=vin.begin();
        TreeNode* head(new TreeNode(*iterator_p1++));
        
        while(*iterator_p2!=head->val){
            leftpre.push_back(*iterator_p1++);
            leftvin.push_back(*iterator_p2++);
        }
        
        iterator_p2++;
        
        while(iterator_p2!=vin.end()){
            rightpre.push_back(*iterator_p1++);
            rightvin.push_back(*iterator_p2++);
        }
        head->left=reConstructBinaryTree(leftpre,leftvin);
        head->right=reConstructBinaryTree(rightpre,rightvin);
        return head;
    }
};

6. 二叉树的下一个结点

二叉树的下一个结点

/*
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* next=pNode->right;
            while(next->left!=NULL){
                next=next->left;
            }
            return next;
        }
        else{
            while(pNode->next!=NULL){
                TreeLinkNode* parent=pNode->next;
                if(parent->left==pNode) return parent;
                pNode=parent;
            }
        }
        return NULL;
    }
};

7. 用两个栈实现队列

用两个栈实现队列

class Solution
{
public:
    void push(int node) {
        while(!stack2.empty()){
            stack1.push(stack2.top());
            stack2.pop();
        }
        stack1.push(node);
    }

    int pop() {
        while(!stack1.empty()){
            stack2.push(stack1.top());
            stack1.pop();
        }
        int a=stack2.top();
        stack2.pop();
        return a;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

8. 斐波那契数列

斐波那契数列

class Solution {
public:
    Solution(){
        fib[0]=0;
        fib[1]=1;
        for(int i=2;i<len;++i){
            fib[i]=fib[i-2]+fib[i-1];
        }
    }
    int Fibonacci(int n) {
        return fib[n];
    }
private:
    int len=40;
    int *fib=new int[len];
};

9.矩形覆盖

矩形覆盖

class Solution {
 public:
    int rectCover(int number) {
        if(number<3) return number;
        int pre1=2,pre2=1,result=0;
        for(int i=3;i<=number;++i){
            result=pre2+pre1;
            pre2=pre1;
            pre1=result;
        }
        return result;
    }
};

10. 跳台阶

跳台阶

class Solution {
public:
    int jumpFloor(int number) {
                if(number<3) return number;
        int pre1=2,pre2=1,result=0;
        for(int i=3;i<=number;++i){
            result=pre2+pre1;
            pre2=pre1;
            pre1=result;
        }
        return result;
    }
};

11. 变态跳台阶

变态跳台阶

动态规划

class Solution {
public:
    int jumpFloorII(int number) {
        int* temp=new int[number]();
       
        for(int i=0;i<number;++i){
            temp[i]=1;
            for(int j=0;j<i;++j){
                temp[i]+=temp[j];
            }
        }
        return temp[number-1];
    }
};

数学推倒

class Solution {
public:
    int jumpFloorII(int number) {
        return pow(2,number-1);
    }
};

12.旋转数组的最小数字

旋转数组的最小数字

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.empty()) return 0;
        int l=0,h=rotateArray.size()-1;
        while(l<h){
            int m=(l+h)/2;
            if(rotateArray[m]<rotateArray[h])
                h=m;
            else
                l=m+1;
        }
        return rotateArray[l];
    }
};

矩阵中的路径

13.矩阵中的路径

矩阵中的路径

class Solution {
    int next[4][2]={{0,-1},{0,1},{-1,0},{1,0}};
    int trows;
    int tcols;
    
    bool backcompare(char* matrix,bool* marked,char* str,int num,int i,int j){
	if(str[num]=='\0') return true;
        if(i<0||i>=trows||j<0||j>=tcols||marked[i*tcols+j]||matrix[i*tcols+j]!=str[num]) return false;
        marked[i*tcols+j]=true;
	
        for(int* a:next){
            if(backcompare(matrix,marked,str,num+1,i+a[0],j+a[1]))
                return true;
        }
        
        marked[i*tcols+j]=false;
        return false;
    }
    
public:
    bool hasPath(char* matrix, int rows, int cols, char* str)
    {
        if(rows==0||cols==0) return false;
        trows=rows;
        tcols=cols;
        bool* marked=new bool[trows*tcols]{false};
        for(int r=0;r<trows;++r){
            for(int c=0;c<tcols;++c){
                if(backcompare(matrix,marked,str,0,r,c))
                    return true;
            }
        }
        delete[] marked;
        return false;
    }
};

14.机器人的运动范围

机器人的运动范围

class Solution {
public:
    int next[4][2]={{0,-1},{0,1},{-1,0},{1,0}};
    int trows;
    int tcols;
    int tthreshold;
    int *sum_array;
    int cnt=0;
public:
    int movingCount(int threshold, int rows, int cols)
    {
        trows=rows;
        tthreshold=threshold;
        tcols=cols;
        form_sum_array();
	//建立一个rows*cols大小的数组，初始化为false
	bool *marked=new bool[rows*cols]{false};
	DFS(marked,0,0);
	return cnt;
    }
    
    void form_sum_array(){
      sum_array=new int[std::max(trows,tcols)+1];
      for(int i=0;i<std::max(trows,tcols);++i){
	int n=i;
	while(n>0){
	  sum_array[i]+=n%10;
	  n=n/10;
	}
      }
    }
    
    void DFS(bool *marked,int r,int c){
      if(r<0||r>=trows||c<0||c>=tcols||marked[r*tcols+c]) return;
      marked[r*tcols+c]=true;
      if(sum_array[r]+sum_array[c]>tthreshold) return;
      cnt++;
      for(auto i : next){
	    DFS(marked,r+i[0],c+i[1]);
      }
    }
};

15.剪绳子

剪绳子

动态规划

class Solution {
    int *maxinteger;
public:
    int integerBreak(int n) {
        maxinteger=new int[n+1]{0};
        maxinteger[1]=1;
        for(int i=2;i<=n;++i){
            for(int j=1;j<i;++j){
                maxinteger[i]=std::max(maxinteger[i],std::max(j*(i-j),maxinteger[i]*((i-j))));
            }
        }
        return maxinteger[n];
    }
};

贪心

class Solution {
public:
    int integerBreak(int n) {
        if(n<2) return 0;
        if(n==2) return 1;
        if(n==3) return 2;
        int timesof3=n/3;
        if(n%3==1) timesof3--;
        int timesof2=(n-timesof3*3)/2;
        return pow(3,timesof3)*pow(2,timesof2);
    }
};

16.数值的整数次方

数值的整数次方

class Solution {
public:
    double Power(double base, int exponent) {
        if(exponent==0) return 1;
        if(exponent==1) return base;
        bool negative=false;
        if(exponent<0){
            negative=true;
            exponent=-exponent;
        }
        double pow=Power(base*base,exponent/2);
        if(exponent%2!=0) pow=base*pow;
        return negative?1/pow:pow;
    }
};

17.删除链表中重复的结点

链接

class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if(pHead==NULL||pHead->next==NULL)
            return pHead;
	ListNode *nex=pHead->next;
	if(pHead->val==nex->val){
	  while(nex!=NULL&&pHead->val==nex->val)
	    nex=nex->next;
	  return deleteDuplication(nex);
	}else{
	  pHead->next=deleteDuplication(nex);
	  return pHead;
	}

        return pHead;
    }
};

18. 正则表达式匹配

链接

class Solution {
public:
    bool match(char* str, char* pattern)
    {
     if(str==NULL||pattern==NULL)
         return false;
     int stridx=0,patidx=0;
     
     patlen=countsize(pattern);
     strglen=countsize(str);
     return matchcore(str,stridx,pattern,patidx);
    }
    
    bool matchcore(char* str,int stridx,char* pattern,int patidx){
        if(stridx==strglen&&patidx==patlen) return true;
        if(patidx==patlen&&stridx<strglen) return false;
        
        if(patidx+1<patlen&&pattern[patidx+1]=='*'){
            if(stridx!=strglen&&(str[stridx]==pattern[patidx]||pattern[patidx]=='.')){
                return matchcore(str,stridx,pattern,patidx+2)||matchcore(str,stridx+1,pattern,patidx+2)||
                    matchcore(str,stridx+1,pattern,patidx);
            }else{
                return matchcore(str,stridx,pattern,patidx+2);
            }
        }
        
        if(stridx!=strglen&&(str[stridx]==pattern[patidx]||pattern[patidx]=='.')){
            return matchcore(str,stridx+1,pattern,patidx+1);
        }else{
            return false;
        }
        return false;
    }
    
    int countsize(char* a){
        int i=0;
        while(a[i]) i++;
        return i;
    }
    
    int strglen=0,patlen=0;
};

19. 表示数值的字符串

链接

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

链接

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        int cntodd=0;
        for(int& i: array){
            if(i%2==1) cntodd++;
        }
        vector<int> copyarr(array);
        int i=0,j=cntodd;
        for(int&inum: copyarr){
            if(inum%2==0) array[j++]=inum;
            else array[i++]=inum;
        }
        
    }
};

21. 链表中倒数第k个结点

链接

class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        ListNode* fastp=pListHead;
        int i=k;
        while(fastp!=NULL&&i!=0){
            fastp=fastp->next;
            i--;
        }
        if(i!=0) return NULL;
        ListNode* slowp=pListHead;
        while(fastp!=NULL){
            fastp=fastp->next;
            slowp=slowp->next;
        }
        return slowp;
    }
};

22.链表中环的入口结点

链接

class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {
        if(pHead==NULL||pHead->next==NULL) return NULL;
        ListNode *fastp=pHead,*slowp=pHead;
        do{
            fastp=fastp->next->next;
            slowp=slowp->next;
        }while(fastp!=NULL&&slowp!=fastp);
        if(fastp==NULL) return NULL;
        fastp=pHead;
        while(slowp!=fastp){
            fastp=fastp->next;
            slowp=slowp->next;
        }
        return fastp;
        
    }
};

23. 顺时针打印矩阵

链接

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> vReturn;
        int r1=0,r2=matrix.size()-1,c1=0,c2=matrix[0].size()-1;
        while(r1<=r2&&c1<=c2){
            if(r1<=r2&&c1<=c2){
                for(int i=c1;i<=c2;i++) vReturn.push_back(matrix[r1][i]);
                r1++;
            }
            if(r1<=r2&&c1<=c2){
                for(int i=r1;i<=r2;i++) vReturn.push_back(matrix[i][c2]);
                c2--;
            }
            
            if(r1<=r2&&c1<=c2){
                for(int i=c2;i>=c1;i--) vReturn.push_back(matrix[r2][i]);
                r2--;
            }
            
            if(r1<=r2&&c1<=c2){
                for(int i=r2;i>=r1;i--) vReturn.push_back(matrix[i][c1]);
                c1++;
            }
        }
        return vReturn;
    }
};

24包含min函数的栈

链接

class Solution {
    stack<int> minstack,originstack;
public:
    void push(int value) {
        originstack.push(value);
        minstack.push(minstack.empty()?value:std::min(minstack.top(),value));
    }
    void pop() {
        originstack.pop();
        minstack.pop();
    }
    int top() {
        return originstack.top();
    }
    int min() {
        return minstack.top();
    }
};

25.栈的压入、弹出序列

链接

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        stack<int> temstack;
        for(int pushnum=0,popnum=0;pushnum<pushV.size();pushnum++){
            temstack.push(pushV[pushnum]);
            while(popnum<pushV.size()&&!temstack.empty()&&temstack.top()==popV[popnum]){
                temstack.pop();
                popnum++;
            }
        }
        return temstack.empty();
    }
};

26.从上往下打印二叉树

链接

class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> vResult;
        if(root==NULL) return vResult;
        deque<TreeNode*> vTemp;
        vTemp.push_back(root);
        while(!vTemp.empty()){
            TreeNode* each=vTemp.front();
            vTemp.pop_front();
            
            vResult.push_back(each->val);
            if(each->left!=NULL) vTemp.push_back(each->left);
            if(each->right!=NULL) vTemp.push_back(each->right);
        }
        return vResult;
    }
};

27. 把二叉树打印成多行

链接

class Solution {
public:
        vector<vector<int> > Print(TreeNode* pRoot) {
            vector<vector<int> > vResult;
            if(pRoot==NULL) return vResult;
            deque<TreeNode*> vTemp;
            vTemp.push_back(pRoot);
            
            while(!vTemp.empty()){
                int num_l=vTemp.size();
                vector<int> vResult1;
                while(num_l-->0){
                    TreeNode* each=vTemp.front();
                    vTemp.pop_front();
                    vResult1.push_back(each->val);
                    if(each->left!=NULL) vTemp.push_back(each->left);
                    if(each->right!=NULL) vTemp.push_back(each->right);
                }
                vResult.push_back(vResult1);
            }
            return vResult;
        }
    
};

28.按之字形顺序打印二叉树

链接

class Solution {
public:
        vector<vector<int> > Print(TreeNode* pRoot) {
            vector<vector<int> > vResult;
            if(pRoot==NULL) return vResult;
            deque<TreeNode*> vTemp;
            vTemp.push_back(pRoot);
            bool printFromLeft=false;
            while(!vTemp.empty()){
                int num_l=vTemp.size();
                vector<int> vResult1;
                printFromLeft=!printFromLeft;
                while(num_l-->0){
                    if(printFromLeft){
                        TreeNode* each=vTemp.front();
                        vTemp.pop_front();
                        vResult1.push_back(each->val);
                        if(each->left!=NULL) vTemp.push_back(each->left);
                        if(each->right!=NULL) vTemp.push_back(each->right);
                    }else{
                        TreeNode* each=vTemp.back();
                        vTemp.pop_back();
                        vResult1.push_back(each->val);
                        if(each->right!=NULL) vTemp.push_front(each->right);
                        if(each->left!=NULL) vTemp.push_front(each->left);
                    }

                }
                vResult.push_back(vResult1);
            }
            return vResult;
        }
    
};

29.二叉搜索树的后序遍历序列

链接

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.empty()) return false;
        if(sequence.size()==1) return true;
        int sizeSequence=sequence.size();
        int val=sequence[sizeSequence-1];
        int loc=0,searchnum=0;
        while(sequence[searchnum]<val) searchnum++;
        loc=searchnum;
        while(sequence[searchnum]>val) searchnum++;
        if(searchnum!=sizeSequence-1) return false;
        vector<int> a(sequence.begin(),sequence.begin()+loc),b(sequence.begin()+loc,sequence.begin()+searchnum);
        if(loc==0)
            return VerifySquenceOfBST(b);
        if(loc==sizeSequence-1)
            return VerifySquenceOfBST(a);
        else return VerifySquenceOfBST(a)&&VerifySquenceOfBST(b);
    }
};

30.二叉树中和为某一值的路径

链接

class Solution {
public:
    vector<vector<int> > vvResult;
    
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        vector<int> vPath;
        FindPath1(root,expectNumber,vPath);
        return vvResult;
    }
    
    void FindPath1(TreeNode* root,int expectNumber,vector<int> vPath) {
        if(root==NULL) return;
        expectNumber-=root->val;
        vPath.push_back(root->val);
        if(expectNumber==0&&root->left==NULL&&root->right==NULL){
            vvResult.push_back(vPath);
        }else{
            FindPath1(root->left,expectNumber,vPath);
            FindPath1(root->right,expectNumber,vPath);
        }

        return;
    }
};

31.复杂链表的复制

链接

class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(pHead==NULL) return NULL;
        RandomListNode* pCur=pHead;
        //插入
        while(pCur!=NULL){
            RandomListNode* pTemp=new RandomListNode(pCur->label);
            pTemp->next=pCur->next;
            pCur->next=pTemp;
            pCur=pTemp->next;
        }
        
        pCur=pHead;
        RandomListNode* pClone;
        while(pCur!=NULL){
            pClone=pCur->next;
            if(pCur->random!=NULL){
                pClone->random=pCur->random->next;
            }
            pCur=pClone->next;
        }
        
        pCur=pHead;
        RandomListNode* pCloneHead=pHead->next;
        while(pCur->next!=NULL){
            RandomListNode* pnext=pCur->next;
            pCur->next=pnext->next;
            pCur=pnext;
        }
        return pCloneHead;
    }
};

32.二叉搜索树与双向链表

链接

class Solution {
public:
    TreeNode* head=NULL;
    TreeNode* pre=NULL;
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        reorder(pRootOfTree);
        return head;
    }
    void reorder(TreeNode* root){
        if(root==NULL) return;
        reorder(root->left);
        root->left=pre;
        if(pre!=NULL){
            pre->right=root;
        }
        pre=root;
        if(head==NULL){
            head=root;
        }
        reorder(root->right);
    }
};

33.序列化二叉树

链接

class Solution {
public:
    vector<int> vStr;
    
    char* Serialize(TreeNode *root) {
        vStr.clear();
        dfs1(root);
        int v_size=vStr.size();
        int *res=new int[v_size];
        for(int i=0;i<v_size;i++) res[i]=vStr[i];
        return (char*)res;
    }
    
    void dfs1(TreeNode * root){
        if(!root) vStr.push_back(0xFFFFFFFF);
        else{
            vStr.push_back(root->val);
            dfs1(root->left);
            dfs1(root->right);
        }
        return;
    }
    
    TreeNode* dfs2(int* &root){
        if(*root==0xFFFFFFFF){
            root++;
            return NULL;
        }
        
        TreeNode* t=new TreeNode(*root);
        root++;
        t->left=dfs2(root);
        t->right=dfs2(root);
        return t;
    }
    
    TreeNode* Deserialize(char *str) {
        int *p=(int *)str;
        return dfs2(p);
    }

};

34.数组中出现次数超过一半的数字

链接

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        int numSize=int(numbers.size());
        
        int majority=numbers[0];
        for(int i=1,cnt=1;i<numSize;i++){
            cnt=numbers[i]==majority?cnt+1:cnt-1;
            if(cnt==0){
                majority=numbers[i];
                cnt=1;
            }
        }
        int cnt=0;
        for(int& i :numbers){
            if(i==majority) cnt++;
        }
        return cnt>numSize/2?majority:0;
    }
};

35.字符串的排列

链接

class Solution {
public:
    vector<string> Permutation(string str) {
        vector<string> result;
        if(str.length()==0) return result;
        Permutation1(str,result,0);
        sort(result.begin(),result.end());
        return result;
    }
    void Permutation1(string str,vector<string>& result,int begin){
        if(begin==str.length()-1){
            if(find(result.begin(),result.end(),str)==result.end())
                result.push_back(str);
        }
        else{
            for(int i=begin;i<str.length();i++){
                swap(str[i],str[begin]);
                Permutation1(str,result,begin+1);
                swap(str[i],str[begin]);
            }
        }
        }
    void swap(char& i,char&j){
        char temp=i;
        i=j;
        j=temp;
    }
    
};

36.最小的K个数

链接

排序

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> result;
        if(input.size()==0||k>input.size()) return result;
        sort(input.begin(),input.end());
        for(int i=0;i<k;i++){
            result.push_back(input[i]);
        }
        return result;
    }
};

partition

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> result;
        if(input.size()==0||k>input.size()) return result;
        int l=0,h=input.size()-1;
        int index;
        while(l<h){
            index=partition(input,l,h);
            if(index==k) break;
            else if(index>k) h=index-1;
            else l=index+1;
        }
        for(int i=0;i<index;i++){
            result.push_back(input[i]);
        }
        return result;
    }
    
    int partition(vector<int>& input,int l,int h){
        int p=input[l];
        int i=l,j=h;
        while(i<j){
            while(i<j&&input[i]<p) i++;
            while(i<j&&input[j]>p) j--;
            swap(input[i],input[j]);
        }
        return i;
    };
    void swap(int& a,int&b){
        int temp=a;
        a=b;
        b=temp;
    }
};

最小堆

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> result;
        if(input.size()==0||k>input.size()) return result;
        for(int i=0;i<k;i++) result.push_back(input[i]);
        make_heap(result.begin(),result.end());
        for(int i=k;i<input.size();i++){
            if(input[i]<result.front()){
                pop_heap(result.begin(),result.end());
                result.pop_back();

                result.push_back(input[i]);
                push_heap(result.begin(),result.end());
            }
        }
        sort_heap(result.begin(),result.end());
        return result;
    }
};

链接

链接

链接

链接

链接
认真的虎
关注
专栏目录
牛客网剑指Offer题解C++ (3/10)
mrbacker的博客
03-28 399
一、调整整数数组使奇数位于偶数前面 题目描述 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。 算法思想 这题我的想法是遍历数组，遇到偶数就将该偶数后面的前移移位，并将该偶数移到最后面，给一个值标记第一个偶数移的位置，当遍历到第一个偶数就完成了。 cla...
牛客 剑指offer_编程题 详细题解 （已完结）
weixin_44211980的博客
01-31 4589
文章目录剑指offer_编程题【1.二维数组中的查找】【2.替换空格】C++JAVA【3.从尾到头打印链表】【4.重建二叉树】【5.用两个栈实现队列】【6.旋转数组的最小数字】暴力Sort二分法【7.斐波那契数列】【8.跳台阶】【9.变态跳台阶】 剑指offer_编程题 【1.二维数组中的查找】 【题目描述】 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都...
【牛客网】剑指offer编程题：跳台阶（C++）
Orange_Panda1997的博客
04-19 245
思路： 1、当number为 1时，只有一种跳法； 2、当number为 2时，有两种跳法； 3、当number大于等于 3时，因为青蛙可以跳一步或者两步，那样dp[3] = dp[2]+ dp[1]；可以得到： dp[number] = dp[number-1] + dp[number-2]； //使用递归方法 ...
《剑指offer》题目 C++详细题解
qq_64446981的博客
08-05 657
这个过程，会让[left，right]区间缩小，这个过程中，left永远在原数组前半部分，right永远在原数组的后半部分，而范围会一直缩小，当left和right相邻时，left指向的位置，就是最小元素的位置，但是，因为题目说的是非递减，也就意味着数据允许重复，因为有重复值，就可能会有a[left] == a[mid] ==a[right]的情况，此时我们就不能用单纯的二分算法模板来写这个题目，我们此时需要单独处理一下有重复值的情况，我们上面是采用的右端点进行判断，同时我们也可以使用左端点进行判断。
剑指Offer之C++实现
xy913741894的博客
03-16 1772
代码可见我的github
牛客网C++刷题《剑指offer》
超级大洋葱的博客
03-15 355
JZ1 二维数组中的查找 class Solution { public: bool Find(int target, vector<vector<int> > array) { //判断数字是否为空 if(array.size()==0 || array[0].size() == 0) return false; for(const auto &vec : array)
剑指Offer算法题（C++）
Melo琦
06-19 480
面试题1：整数除法基础知识：整数的数据类型包括 32位int(-2^31 ~ 2^31 -1) ， 16位short (-2^15 ~ 2^15 -1)思路： 一个很直观的想法是基于减法实现除法。例如，为了求 19/2 可以从 19 中不断减去 2，那么减去 9 个 2 以后就剩下 1，可以得到 19/2 = 9，但是效率很低，当被除数是 n,除数是 1 的时候，算法复杂度最差为 O(n)。如果将上述解法做一些调整，当被除数大于除数时，继续判断是不是大于除数的 2 倍？ 4 倍？ 8 倍？....如果被除数
offer_牛客_剑指offer_剑指Offer算法题编程代码解析汇总_
10-02
在编程领域，尤其是在面试准备过程中，"剑指Offer"是一本备受推崇的书籍，它集合了大量的算法题目，旨在提升程序员在解决实际问题中的能力。牛客网作为国内知名的在线编程训练平台，也提供了丰富的剑指Offer题目供...
剑指offer题解(C++).docx
07-17
《剑指Offer题解》是针对面试准备的一份宝贵资源，由Sidney.Tan精心整理，结合了牛客网上的讨论、《剑指Offer》书中的解法以及个人的编程实践，提供了全面的代码和思路解析。这份文档按照牛客网上的题目顺序，覆盖了...
此资源是剑指OFFER的题解(C++)，由本人在刷剑指OFFER题的期间整理
最新发布
08-09
此资源是剑指OFFER的题解(C++)，由本人在刷剑指OFFER题的期间整理，其中有整理牛客网讨论区的代码+剑指OFFER书中的代码+自己编写的代码，方法很全，且附有解析和思路，很方便大家在刷题时参考。 资源中题目顺序参照...
剑指offer.md
02-02
剑指offer算法题编程，全部AC并且带有代码注释，原文中引出了其牛客上的地址，方便自己提交；财通Markdown编写文档，排版良好
剑指offer（C++）1
08-04
剑指offer（C++）1
剑指offer（牛客网）
04-09
根据牛客网上的目录来的，这个也是我在网上找到的，算是给自己留个备份。似乎一定要设置积分才能上传。
剑指offer源代码C++
10-22
剑指offer的C++源码，如果觉得源文件比较奇怪，没法用，干脆就用notepad直接查看C++源码即可。最重要的是要自己动手编写源代码！！
牛客网剑指offer总结（一）（c++）
guet+第4组+2021
06-15 218
创建新链表存储合并后的链表，从头到尾循环读取两个链表每个结点的值并比较大小，按照排序顺序存储到新链表，当其中一个链表读取完毕，随后将另一个链表剩下未被读取的结点值直接存储到新链表即可。在旧链表的每个节点之后都添加一个结点，其新的结点值与旧链表的结点值相同，随后按照旧链表的链接方向，在新节点上进行链接，最后从中拆分出新链表即可。找到当前链表结点的前驱节点及后继节点，将当前节点的前驱节点与后继节点进行交换即可，循环整条链表的每个节点。借助一个数组，将链表结点值存放到这个数组中，随后将数组反向输出。
剑指offer刷题笔记（牛客网C++）
weixin_42344264的博客
05-20 1357
4、二维数组中的查找 1、暴力查找：循环遍历，O(n2) 2、利用递增的规律，右上或左下查找：当最右上的数字大于查找值时，将此列删除；如果小于查找值时，将此行删除；如果等于，则查找结束。N=max(m,n), O(N) class Solution { public: bool Find(int target, vector<vector<int> > array) { // 获取二维数组的行列 int rows = array.size();
剑指offer 代码实现 C++
zhyh1435589631的专栏
07-30 6701
临近找工作的季节， 赶紧把牛课网上的剑指offer部分的代码重新码了一遍 http://www.nowcoder.com/ta/coding-interviews?page=1将代码托管到了 csdn 上工程地址： https://code.csdn.net/zhyh1435589631/sword_offer3/tree/master其中遇到一个问题， 就是感觉 git 提交的工程文件中不能
[leetcode]剑指offer(C++版题解)
qq_52608074的博客
04-12 2569
剑指offer第一天剑指 Offer 09. 用两个栈实现队列剑指 Offer 30. 包含min函数的栈有待更新。。。。 第一天 剑指 Offer 09. 用两个栈实现队列 ->点这里进入leetcode 这道题的意思就是让我们使用两个栈实现一个队列， 简单复习一下： 栈：先进后出（栈顶进出元素） 队列：先进先出（队列头出元素，队列尾进元素） 我们会发现栈可以做到队列尾进元素，但是如何让栈底出元素是一个问题 我们会想到将一个栈的元素依次出栈放到另外一个栈中的时候，他的元素是不是会倒过来，例如：
剑指offer c++
fahaiL的博客
06-30 289
在一个字符串(1<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置 class Solution { public: int FirstNotRepeatingChar(string str) { int length = str.size(); if (length == 0) {
C/C++编程基础：static与const深度解析
在C/C++编程中，`static`和`const`是两个重要的关键字，它们分别具有独特的功能和用途。理解这两个关键字的含义和使用方式对于编写高质量的C++代码至关重要。 `static`关键字主要用于改变标识符的链接属性，将外部...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值