剑指offer重点复习题目

最新推荐文章于 2022-05-04 19:07:23 发布

子非鱼_cw

最新推荐文章于 2022-05-04 19:07:23 发布

阅读量863

点赞数

CC 4.0 BY-SA版权

分类专栏： C++ 数据结构和算法

本文链接：https://blog.youkuaiyun.com/wangchao7281/article/details/76626606

数据结构和算法同时被 2 个专栏收录

16 篇文章

订阅专栏

C++

13 篇文章

订阅专栏

本文解析了多个经典算法问题，包括二叉搜索树转换为双向链表、字符串排列、计算整数区间内1的个数等，并提供了详细的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：二叉搜索树与双向链表

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

/*
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* pRoot)
    {
        if(pRoot==nullptr)return nullptr;
        TreeNode* pLast=nullptr;
        ConvertCore(pRoot,pLast);
        while(pRoot->left)pRoot=pRoot->left;
        return pRoot;
        
    }
    void ConvertCore(TreeNode* pRoot,TreeNode*& pLast){
        if(!pRoot)return;
        ConvertCore(pRoot->left,pLast);
        pRoot->left=pLast;
        if(pLast)pLast->right=pRoot;
        pLast=pRoot;
        ConvertCore(pRoot->right,pLast);
    }
};

题目：字符串的排列

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

输入描述:

输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

class Solution {
    vector<string> res;
public:
    vector<string> Permutation(string str) {
        PermutationCore(str,0);
        sort(res.begin(),res.end());
        return res;
    }
    void PermutationCore(string& str,int begin){
        if(begin==str.size()-1)res.push_back(str);
        for(int i=begin;i<str.size();++i){
            if(i!=begin && str[i]==str[begin])
                continue;
            swap(str[begin],str[i]);
            PermutationCore(str,begin+1);
            swap(str[begin],str[i]);
        }
    }
};

题目：从1到n整数中1出现的个数

求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数。

class Solution {
public:
    int NumberOf1Between1AndN_Solution(int n)
    {
        int sum=0;
        for(int i=1;i<=n;i*=10){
            int a=n/i,b=n%i;
            sum+=(a+8)/10*i+(a%10==1)*(b+1);
        }
        return sum;
    }
};

题目：把数组排成最小的数

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

class Solution {
public:
    string PrintMinNumber(vector<int> numbers) {
        string result;
        sort(numbers.begin(),numbers.end(),[](const int& a,const int& b){
            return to_string(a)+to_string(b)<to_string(b)+to_string(a);});
        for(auto n:numbers)
            result+=to_string(n);
        return result;
    }
};

题目：数组中的逆序对

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007

输入描述:

题目保证输入的数组中没有的相同的数字
数据范围：
	对于%50的数据,size<=10^4
	对于%75的数据,size<=10^5
	对于%100的数据,size<=2*10^5

class Solution {
public:    
    long long result;
    
    int InversePairs(vector<int> data) {
        if(data.empty())return -1;
        vector<int> temp(data.size());
        result=0;
        MergeSort(data,0,data.size()-1,temp);
        return (result%1000000007);
    }
    
    void MergeSort(vector<int>& data,int first,int last,vector<int>& temp){
        if(first<last){
            int mid=(first+last)/2;
            MergeSort(data,first,mid,temp);
            MergeSort(data,mid+1,last,temp);
            Merge(data,first,mid,last,temp);
        }
    }
    
    void Merge(vector<int>& data,int first,int mid,int last,vector<int>& temp){
        int i=mid,j=last,k=last-first;
        while(i>=first && j>=mid+1){
            if(data[i]>data[j]){
                result+=j-mid;
                temp[k--]=data[i--];                
            }                
            else
                temp[k--]=data[j--];
        }
        while(i>=first)
            temp[k--]=data[i--];
        while(j>=mid+1)
            temp[k--]=data[j--];
        for(int i=0;i<=last-first;++i)
            data[first+i]=temp[i];
    }
};

题目：数组中只出现一次的数字

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

class Solution {
public:
	void FindNumsAppearOnce(vector<int> data, int* num1, int *num2) {
		if (data.size()<2)return;
		int xOr = 0;
		for (size_t i = 0; i<data.size(); ++i)
			xOr ^= data[i];
		
		int index = 0;
		while ((xOr & 1) == 0) {
			++index;
			xOr = xOr >> 1;
		}
		*num1 = *num2 = 0;
		for (size_t i = 0; i<data.size(); ++i) {
			if ((data[i] >> index) & 1)
				*num1 ^= data[i];
			else
				*num2 ^= data[i];
		}
	}
};

题目：孩子们的游戏(圆圈中最后剩下的数，约瑟夫环问题)

每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0...m-1报数....这样下去....直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

class Solution {
public:
    int LastRemaining_Solution(int n, int m)
    {
        if(n<1 || m<1)return -1;
        if(n==1)return 0;
        return (LastRemaining_Solution(n-1,m)+m)%n;
    }
};

题目：滑动窗口的最大值

给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}；针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size)
    {
        vector<int> res;
        deque<int> deq;
        if(num.empty() || size==0 || num.size()<size)return res;
        for(size_t i=0;i!=num.size();++i){
            while(!deq.empty() && num[deq.back()]<num[i])
                deq.pop_back();
            while(!deq.empty() && i-deq.front()>=size)
                deq.pop_front();
            deq.push_back(i);
            if(i+1>=size)res.push_back(num[deq.front()]);
        }
        return res;
    }
};

题目：矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。例如 a b c e s f c s a d e e 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

class Solution {
public:
    bool hasPath(char* matrix, int rows, int cols, char* str)
    {
        bool* isVisited=new bool[rows*cols]();
        int pathStep=0;
        for(int i=0;i<rows;++i){
            for(int j=0;j<cols;++j){
                if(isHasPath(matrix,rows,cols,str,i,j,isVisited,pathStep))
                    return true;
            }
        }
        delete[] isVisited;
        return false;        
    }
    
    bool isHasPath(char* matrix,int rows,int cols,char* str,int row,int col,bool* isVisited,int pathStep){
        if(str[pathStep]=='\0')return true;
        bool hasPath=false;
        if(row>=0 && row<rows && col>=0 && col<cols && matrix[row*cols+col]==str[pathStep] && !isVisited[row*cols+col]){
            ++pathStep;
            isVisited[row*cols+col]=true;
            hasPath=isHasPath(matrix,rows,cols,str,row+1,col,isVisited,pathStep)
                 || isHasPath(matrix,rows,cols,str,row-1,col,isVisited,pathStep)
                 || isHasPath(matrix,rows,cols,str,row,col+1,isVisited,pathStep)
                 || isHasPath(matrix,rows,cols,str,row,col-1,isVisited,pathStep);
            if(!hasPath){
                --pathStep;
                isVisited[row*cols+col]=false;
            }
        }
        return hasPath;
    }


};