【针对性复习】放假也不能闲着（2）~

最新推荐文章于 2024-04-22 21:14:23 发布
最新推荐文章于 2024-04-22 21:14:23 发布
阅读量967 收藏
点赞数 3
分类专栏： 针对性复习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Austin_Yan/article/details/102336799
版权

文章目录

#include<iostream>
#include<stack>

using namespace std;

//9.27

//栈实现队列:

class Solutione
{
public:
    void push(int node) 
    {
        s1.push(node);
    }

    int pop() 
    {
        while(s1.empty()==false)
        {
            s2.push(s1.top());
            s1.pop();
        }
        
        int i=s2.top();
        
        s2.pop();
        
        while(s2.empty()==false)
        {
            s1.push(s2.top());
            s2.pop();
        }
        return i;
    }

private:
    stack<int> s1;
    stack<int> s2;
};

//旋转数组的最小数字

#include<vector>

class Solutiond 
{
public:
    int minNumberInRotateArray(vector<int> rotateArray) 
    {
        if(rotateArray.size()==0)
        {
            return 0;
        }
        
        int min=rotateArray[0];
        
        for(int i=1;i<rotateArray.size();++i)
        {
            if(min>rotateArray[i])
            {
                min=rotateArray[i];
            }
        }
        return min;
    }
};

//斐波那契数列

#include<vector>

class Solutionc
{
public:
    int Fibonacci(int n) 
    {
        vector<int> fib;
        fib.resize(39,0);
        
        fib[1]=1;
        fib[2]=1;
        
        for(int i=3;i<=39;++i)
        {
            fib[i]=fib[i-1]+fib[i-2];
        }
        
        return fib[n];
    }
};

//跳台阶

class Solutionb 
{
public:
    int jumpFloor(int number) 
    {
        if(number==0)
        {
            return 0;
        }
        else if(number<3)
        {
            return number;
        }
        else
        {
            int f=0;
            int f1=1;
            int f2=2;
            
            for(int i=3;i<=number;++i)
            {
                f=f1+f2;
                f1=f2;
                f2=f;
            }
            return f;
        }
    }
};

//变态跳台阶

#include<vector>

class Solutiona
{
public:
    int jumpFloorII(int number) 
    {
        //动态规划问题
        
        //状态:青蛙调到台阶上的方法数
        
        //初始化
        vector<int> F(number+1);
        
        F[0]=1;
        F[1]=1;
        F[2]=2;
        
        //状态转移方程:F(n)=F(n-1)+F(n-2)+F(n-3)...+F(1)
        //F(n-1)=F(n-2)+F(n-3)...+F(1)
        //F(n)=2F(n-1)
        for(int i=3;i<=number;++i)
        {
            F[i] = 2 * F[i - 1];
        }
        //返回结果:F(n)
        return F[number];
    }
};

//矩形覆盖(变式斐波那契)

class Solution0 {
public:
    int rectCover(int number) 
    {
        if(number<=0)
        {
            return 0;
        }
        else if(number<=2)
        {
            return number;
        }
        else
        {
            return rectCover(number-1)+rectCover(number-2);
        }
    }
};

//二进制位1的数量,负数采用补码表示

class Solution1 {
public:
	int  NumberOf1(int n)
	{
		int count = 0;
		
		unsigned int nn = n;

		while (nn>0)
		{
			if ((nn & 1) == 1)
			{
				count++;
			}
			nn >>= 1;
		}
		return count;
	}
};

//幂运算

#include<algorithm>
#include<math.h>

class Solution2 {
public:
	double Power(double base, int exponent)
	{
		return pow(base, exponent);
	}
};

//调整数组奇数和偶数的位置

#include<vector>

class Solution3 
{
public:
	void reOrderArray(vector<int> &array)
	{
		vector<int> v;

		for (auto e : array)
		{
			if (e % 2 != 0)
			{
				v.push_back(e);
			}
		}

		for (auto e : array)
		{
			if (e % 2 == 0)
			{
				v.push_back(e);
			}
		}

		array = v;
	}
};

//14-17

struct ListNode 
{
	int val;
	struct ListNode *next;
	ListNode(int x) :
		val(x), next(NULL)
	{
	}
};

//链表倒数第K个节点

class Solution4 
{
public:
	ListNode* FindKthToTail(ListNode* pListHead, unsigned int k)
	{
		ListNode* fast = pListHead;
		ListNode* slow = pListHead;

		while (k > 0 && fast != nullptr)
		{
			fast = fast->next;
			k--;
		}

		if (fast == nullptr && k > 0)
		{
			return nullptr;
		}

		while (fast != nullptr)
		{
			fast = fast->next;
			slow = slow->next;
		}

		return slow;
	}
};

//反转链表

class Solution5 
{
public:
	ListNode* ReverseList(ListNode* pHead)
	{
		if (pHead == nullptr)
		{
			return nullptr;
		}

		ListNode* result = nullptr;

		ListNode* pCur = pHead;
		while (pCur != nullptr)
		{
			ListNode* Next = pCur->next;
			pCur->next = result;
			result = pCur;
			pCur = Next;
		}

		return result;
	}
};

//合并有序链表

class Solution6 
{
public:
	ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
	{
		if (pHead1 == nullptr)
		{
			return pHead2;
		}

		if (pHead2 == nullptr)
		{
			return pHead1;
		}

		ListNode* result = nullptr;
		ListNode* last = nullptr;

		ListNode* pCur1 = pHead1;
		ListNode* pCur2 = pHead2;

		while (pCur1 != nullptr && pCur2 != nullptr)
		{
			if (pCur1->val <= pCur2->val)
			{
				if (result==nullptr)
				{
					result = last = pCur1;
				}
				else
				{
					last->next = pCur1;
					last = pCur1;
				}
				pCur1 = pCur1->next;
			}
			else
			{
				if (result == nullptr)
				{
					result = last = pCur2;
				}
				else
				{
					last->next = pCur2;
					last = pCur2;
				}
				pCur2 = pCur2->next;
			}
		}

		if (pCur1 != nullptr)
		{
			last->next = pCur1;
		}

		if (pCur2 != nullptr)
		{
			last->next = pCur2;
		}

		last->next = nullptr;
		return result;
	}
};

//最小栈

//9.28
#include<stack>

class Solution7 
{
public:
    void push(int value) 
    {
        if(s1.empty()==true)
		{
			s1.push(value);
			s1.push(value);
		}
		else
		{
			int top=s1.top();
			s1.pop();

			if(value<s1.top())
			{
				s1.push(top);

				s1.push(value);
				s1.push(value);
			}
			else
			{
				int min=s1.top();
				s1.push(top);

				s1.push(min);
				s1.push(value);
			}
			
		}
		
    }
    void pop() 
    {
        s1.pop();
		s1.pop();
    }

    int top() 
    {
        return s1.top();
    }

    int min() 
    {
        int top=s1.top();
		s1.pop();

		int min=s1.top();
		s1.push(top);

		return min;
    }

private:
	stack<int> s1;
	stack<int> s2;
};

//树的子结构(错误代码)

struct TreeNode 
{
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL)
	{

	}
};

#include<vector>

void preOrder(TreeNode* root,vector<int>& v)
{
	if(root!=nullptr)
	{
		v.push_back(root->val);
		preOrder(root->left,v);
		preOrder(root->right,v);
	}
}

class Solution8
{
public:
	bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
	{
		vector<int> v1;
		vector<int> v2;

		preOrder(pRoot1,v1);
		preOrder(pRoot2,v2);

		int i=0;
		while(v1[i]!=v2[0])
		{
			i++;
		}

		for(int j=i;j<v2.size();++j)
		{
			if(v1[j]!=v2[j])
			{
				return false;
			}
		}
		return true;
	}
};

//树的子结构(正确代码)

class Solution9
{
public:
	bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
	{
		if (pRoot1 == nullptr || pRoot2 == nullptr)
		{
			return false;
		}

		bool result = false;

		if (pRoot1->val == pRoot2->val)
		{
			result=isSubtree(pRoot1, pRoot2);
		}
		
		if (result == false)
		{
			result = HasSubtree(pRoot1->left, pRoot2);
		}
		if (result == false)
		{
			result = HasSubtree(pRoot1->right, pRoot2);
		}
        
        return result;
	}

	bool isSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
	{
		if (pRoot2 == nullptr)
		{
			return true;
		}
        
		if (pRoot1 == nullptr)
		{
			return false;
		}
        
		bool result = true;

		if (pRoot1->val != pRoot2->val)
		{
			return false;
		}

		if (result == true)
		{
			result=isSubtree(pRoot1->left, pRoot2->left);
		}
		if (result == true)
		{
			result=isSubtree(pRoot1->right, pRoot2->right);
		}
        
        return result;
	}
};

//二叉树的镜像

//9.29
#include<queue>

void levelOrder(TreeNode* root,vector<TreeNode*>& v)
{
    if(root==nullptr)
	{
		return;
	}

	queue<TreeNode*> q;
	q.push(root);

	while(q.empty()==false)
	{
		v.push_back(q.front());

		if(q.front()->left!=nullptr)
		{
			q.push(q.front()->left);
		}

		if(q.front()->right!=nullptr)
		{
			q.push(q.front()->right);
		}

		q.pop();
	}
}

class Solution10
{
public:
    void _Mirror(TreeNode *pRoot) 
    {
		vector<TreeNode*> v;
        levelOrder(pRoot,v);

		for(int i=0;i<v.size();++i)
		{
			Mirror(v[i]);
		}
    }

	void Mirror(TreeNode *pRoot)
	{
		if(pRoot!=nullptr)
		{
			swap(pRoot->left,pRoot->right);
			Mirror(pRoot->left);
			Mirror(pRoot->right);
		}
	}
};

//顺时针打印矩阵

(VS可以但是代码不通过,时间复杂度可能不满足)

class Solution11
{
public:
	vector<int> printMatrix(vector<vector<int> > matrix)
	{
		vector<int> result;

		int row = matrix.size();
		int col = matrix[0].size();

		if (row == 1)
		{
			for (int j = 0; j < col; ++j)
			{
				result.push_back(matrix[0][j]);
			}
			return result;
		}

		if (col == 1)
		{
			for (int i = 0; i < row; ++i)
			{
				result.push_back(matrix[i][0]);
			}
			return result;
		}

		int i = 0;
		int j = 0;
		int time = 0;

		while (result.size() != (row * col))
		{
			for (; j < col - time; ++j)
			{
				result.push_back(matrix[i][j]);
			}

			j--;

			while (i < row -1 - time)
			{
				i++;
				result.push_back(matrix[i][j]);
			}

			time++;

			while (j > time-1)
			{
				j--;
				result.push_back(matrix[i][j]);
			}
			
			while (i > time)
			{
				i--;
				result.push_back(matrix[i][j]);
			}
			j++;
		}

		return result;
	}
};

//栈的压入、弹出序列

class Solution12 
{
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) 
    {
        vector<int> v;
        int j=0;
        
		for(int i=0;i<pushV.size();++i)
		{
			v.push_back(pushV[i]);

			while(j<popV.size() && v.back()==popV[j])
			{
				v.pop_back();
				j++;
			}
		}
		return v.empty();
    }
};

//从上到下打印二叉树(层序遍历)

class Solution13 
{
public:
	vector<int> PrintFromTopToBottom(TreeNode* root)
	{
		queue<TreeNode*> q;
		vector<int> v;

		if(root==nullptr)
		{
			return v;
		}

		q.push(root);

		while (q.empty() == false)
		{
			v.push_back(q.front()->val);

			if (q.front()->left != nullptr)
			{
				q.push(q.front()->left);
			}

			if (q.front()->right != nullptr)
			{
				q.push(q.front()->right);
			}

			q.pop();
		}
		return v;
	}
};

//二叉搜索树后续遍历序列(重点)

class Solution14 
{
public:
    bool VerifySquenceOfBST(vector<int> sequence) 
    {
		if(sequence.empty()==true)
		{
			return false;
		}

		return isPostOrder(sequence,0,sequence.size()-1);
    }

	bool isPostOrder(vector<int>& sequence,int left,int right)
	{
		if(left>=right)
		{
			return true;
		}
        
		int i=right;
		while(i > left && sequence[i - 1] > sequence[right]) 
        {
            --i;
        }

		for(int j=i-1;j>=left;--j)
		{
			if(sequence[j]>sequence[right])
			{
				return false;
			}
		}

		return isPostOrder(sequence,left,i-1)+isPostOrder(sequence,i,right-1);
	}
};

//字符串排列(重点)

//如果当时刷到了这个题,吉比特的笔试我应该能过

/*
Dfs(当前这一步的处理逻辑)
{
1. 判断边界，是否已经一条道走到黑了：向上回退
2. 尝试当下的每一种可能
3. 确定一种可能之后，继续下一步 Dfs(下一步)
}
*/

void perm(int k, string str, vector<string>& res)
{
	if (k == str.size() - 1)
	{
		res.push_back(str);
	}

	for(int i=k;i<str.size();++i)
	{
		if(i!=k && str[i]==str[k])
		{
			continue;
		}

		swap(str[k],str[i]);
		perm(k+1,str,res);
		swap(str[k],str[i]);
	}
}


vector<string> Permutation(string str)
{
	vector<string> res;
	perm(0,str,res);

	sort(res.begin(),res.end());
	return res;
}

//字符串超过一半的数

//10.1

class Solution15 
{
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) 
    {
        if(numbers.size()==0)
        {
            return 0;
        }
        
        sort(numbers.begin(),numbers.end());
        
        int count=0;
        
        for(int i=0;i<numbers.size();++i)
        {
            if(numbers[i]==numbers[numbers.size()>>1])
            {
                count++;
            }
        }
        
        if(count>(numbers.size()>>1))
        {
            return numbers[numbers.size()>>1];
        }
        else
        {
            return 0;
        }
    }
};

//最小的K个数

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

//连续子数组中最大和

class Solution17 
{
public:
    int FindGreatestSumOfSubArray(vector<int> array) 
    {
        int max=array[0];
        int sum=0;
        
        for(int i=0;i<array.size();++i)
        {
            sum+=array[i];
            
            if(sum>max)
            {
                max=sum;
            }
            
            if(sum<0)
            {
                sum=0;
            }
        }
        
        return max;
    }
};

//1-n中1出现的次数

#include<string>

class Solution18 
{
public:
    int NumberOf1Between1AndN_Solution(int n)
    {
        int count=0;
        
        for(int i=1;i<=n;++i)
        {
            string a=to_string(i);
            
            for(int j=0;j<a.size();++j)
            {
                if(a[j]=='1')
                {
                    count++;
                }
            }
        }
        return count;
    }
};

//把数组排成最小的数

bool cmp(int a,int b)
{
	string A;
	string B;

	A+=to_string(a);
	A+=to_string(b);

	B+=to_string(b);
	B+=to_string(a);

	return A<B;
}

string PrintMinNumber(vector<int> numbers) 
{
    sort(numbers.begin(),numbers.end(),cmp);
        
    string result;
        
    for(int i=0;i<numbers.size();++i)
    {
        result+=to_string(numbers[i]);
    }
        
    return result;
}

//丑数(重点)

class Solution19 
{
public:
    int GetUglyNumber_Solution(int index)
    {
        if(index<7)
        {
            return index;
        }
        
        vector<int> res;
        
        int p2=0;
        int p3=0;
        int p5=0;
        
        int putnum=1;
        res.push_back(putnum);
        
        while(res.size()<index)
        {
            putnum=min(res[p2]*2,min(res[p3]*3,res[p5]*5));
            
            if(res[p2]*2 == putnum)
            {
                p2++;
            }
            
            if(res[p3]*3 == putnum)
            {
                p3++;
            }
            
            if(res[p5]*5 == putnum)
            {
                p5++;
            }
            
            res.push_back(putnum);
        }
        return putnum;
    }
};

//第一个只出现一次的字符

//10.2

class Solution20 
{
public:
    int FirstNotRepeatingChar(string str) 
    {
        for (int i = 0; i < str.size(); ++i)
        {
            int count = 1;

            for (int j = 0; j < str.size(); ++j)
            {
                if (i != j && str[i] == str[j])
                {
                    count++;
                }
            }

            if (count == 1)
            {
                return i;
            }
        }
        return -1;
    }
};

//数组中的逆序对(暴力求解会超时)

class Solution21 
{
public:
    int InversePairs(vector<int> data) 
    {
		int count=0;

        for(int i=0;i<data.size();++i)
		{
			for(int j=i;j<data.size();++j)
			{
				if(data[i]>data[j])
				{
					count++;
				}
			}
		}
		return count%1000000007;
    }
};

//两个链表的第一个公共节点

class Solution22 
{
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) 
    {
        if(pHead1==nullptr || pHead2==nullptr)
		{
			return nullptr;
		}

		int size1=0;
		int size2=0;

		ListNode* pCur1=pHead1;
		ListNode* pCur2=pHead2;

		while(pCur1!=nullptr)
		{
			size1++;
			pCur1=pCur1->next;
		}

		while(pCur2!=nullptr)
		{
			size2++;
			pCur2=pCur2->next;
		}

		pCur1=pHead1;
		pCur2=pHead2;

		if(size1<size2)
		{
			while(size2-size1>0)
			{
				pCur2=pCur2->next;
				size2--;
			}
		}
		else
		{
			while(size1-size2>0)
			{
				pCur1=pCur1->next;
				size1--;
			}
		}

		while(pCur1!=nullptr && pCur2!=nullptr)
		{
			if(pCur1==pCur2)
			{
				return pCur1;
			}
			pCur1=pCur1->next;
			pCur2=pCur2->next;
		}
		return nullptr;
    }
};

//数字在排序数组中出现的次数

class Solution23 
{
public:
    int GetNumberOfK(vector<int> data ,int k) 
    {
        int count=0;
        
        for(int i=0;i<data.size();++i)
        {
            if(k==data[i])
            {
                count++;
            }
        }
        return count;
    }
};

//二叉树的深度


class Solution24 
{
public:
    int TreeDepth(TreeNode* pRoot)
    {
        if(pRoot==nullptr)
        {
            return 0;
        }
		else if(pRoot->left==nullptr && pRoot->right==nullptr)
		{
			return 1;
		}
        else
		{
			int t1=0;
			int t2=0;

			t1=TreeDepth(pRoot->left);
			t2=TreeDepth(pRoot->right);

			return max(t1,t2)+1;
		}
    }
};

//判断是否是平衡二叉树(重点)

#include<math.h>

//后续遍历二叉树,判断左右子树高度差,高度差大于1,返回-1,如果不大于1,返回子树高度(left,right取较大值+1)继续遍历
class Solution25 
{
public:
    bool IsBalanced_Solution(TreeNode* pRoot) 
    {
        if(GetDepth(pRoot)== -1)
		{
			return false;
		}
		else
		{
			return true;
		}
    }

	int GetDepth(TreeNode* root)
	{
		if(root==nullptr)
		{
			return 0;
		}
	
		int left=GetDepth(root->left);
		int right=GetDepth(root->right);

		if(left== -1)
		{
			return -1;
		}	
		if(right== -1)
		{
			return -1;
		}

		return abs(left-right)>1?-1:1+max(left,right);
	}
};

//数组中只出现一次的数字(其余数字出现两次)

class Solution26 
{
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) 
    {
        int res=0;
        
        for(int i=0;i<data.size();++i)
        {
            res^=data[i];
        }
        
        int pos=0;
        
        for(int i=0;i<32;++i)
        {
            if(res&1<<i)
            {
                pos=i;
                break;
            }
        }
        
        for(int i=0;i<data.size();++i)
        {
            if(data[i]&1<<pos)
            {
                *num1^=data[i];
            }
            else
            {
                *num2^=data[i];
            }
        }
    }
};

//和为s的连续整数序列

//算法大佬的双指针思路,又清晰时间复杂度也不高
//自己想真是想不到这么棒的思路


class Solution27 
{
public:
    vector<vector<int>> FindContinuousSequence(int sum) 
	{
        int pcur1=1;
		int pcur2=2;

		int sumcur=0;

		vector<vector<int>> result;

		while(pcur2>pcur1)
		{
			sumcur=(pcur1+pcur2)*(pcur2-pcur1+1)/2;

			if(sumcur<sum)
			{
				pcur2++;
			}

			if(sumcur==sum)
			{
				vector<int> res;
				for(int i=pcur1;i<=pcur2;++i)
				{
					res.push_back(i);
				}
				result.push_back(res);
				pcur1++;
			}

			if(sumcur>sum)
			{
				pcur1++;
			}
		}
		return result;
    }
};

//和为s的两个数字

class Solution28 
{
public:
	vector<int> FindNumbersWithSum(vector<int> array, int sum)
	{
		int a = 0;
		vector<int> v;

		for (int i = 0; i < array.size(); ++i)
		{
			for (int j = 0; j < array.size(); ++j)
			{
				if (i != j)
				{
					a = array[i] + array[j];
				}

				if (a == sum)
				{
					if (v.empty() == true)
					{
						v.push_back(array[i]);
						v.push_back(array[j]);
					}

					if (array[i] * array[j] < v[0] * v[1])
					{
						v.clear();
						v.push_back(array[i]);
						v.push_back(array[j]);
					}
				}
			}
		}
		return v;
	}
};

//左旋转字符串

class Solution29 
{
public:
    string LeftRotateString(string str, int n)
    {
        string result;
        
        if(str.size()==0)
        {
            return result;
        }
        
        string a = str.substr(0, n);
        string b = str.substr(n,str.size());
        
        result += b;
        result += a;

        return result;
    }
};

//翻转单词序列

class Solution30 
{
public:
    string ReverseSentence(string str)
    {
        reverse(str.begin(), str.end());

        int begin = 0;
        int end = 0;

        while (end<str.size())
        {
            while (str[end] != ' ' && end<str.size())
            {
                end++;
            }

            int nextposition = end+1;

            while (begin < end-1)
            {
                swap(str[begin],str[end-1]);
                begin++;
                end--;
            }
            begin = nextposition;
            end = nextposition;
        }

        return str;
    }
};

//不用加减乘除做加法

//10.3

class Solution31
{
public:
    int Add(int num1, int num2)
    {
        while(num1!=0)
        {
            int tmp=num2;
            num2=num1^num2;
            num1=num1&tmp;
            num1<<=1;
        }
        return num2;
    }
};

//把字符串转换为整数

class Solution32 
{
public:
    int StrToInt(string str)
    {
        long long res = 0;
        int flag=1;

        if (str[0] == '+')
        {
            str[0]='0';
        }

        if (str[0] == '-')
        {
            str[0]='0';
            flag=-1;
        }

        for (int i = 0; i < str.size(); ++i)
        {
            if (str[i] < '0' || str[i] > '9')
            {
                return 0;
            }
            res = res * 10 + str[i] - '0';
            
            if ((flag==1 && res>INT_MAX) || (flag==-1 && res*flag <INT_MIN))
		    {
			    return 0;
		    }
        }

        return res*flag;
    }
};

//数组中重复的数字

//(O(N2)常规思路)

class Solution33
{
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) 
    {
        for(int i=0;i<length;++i)
        {
            for(int j=0;j<length;++j)
            {
                if(i!=j && numbers[i]==numbers[j])
                {
                    *duplication=numbers[i];
                    return true;
                }
            }
        }
        return false;
    }
};

//哈希映射思想(时空复杂度O(N))
    bool duplicate(int numbers[], int length, int* duplication)
    {
        vector<int> hash(length,0);

        for (int i = 0; i < length; ++i)
        {
            hash[numbers[i]]++;
        }

        for (int i = 0; i < length; ++i)
        {
            if (hash[i]>1)
            {
                *duplication = i;
                return true;
            }
        }
		return false;
    }

//字符流中第一个不重复的字符

class Solution34
{
public:
  //Insert one char from stringstream
    char hash[256]={0};
    string a;
    
    void Insert(char ch)
    {
        a+=ch;
        hash[ch]++;
    }
  //return the first appearence once char in current stringstream
    char FirstAppearingOnce()
    {
        for(int i=0;i<a.size();++i)
        {
            if(hash[a[i]]==1)
            {
                return a[i];
            }
        }
        return '#';
    }
};

//带环链表的入环点

class Solution35
{
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {
        if(hasCycle(pHead)==nullptr)
        {
            return nullptr;
        }
        
        ListNode* pH=pHead;
        ListNode* pM=hasCycle(pHead);
        
        while(pH!=pM)
        {
            pH=pH->next;
            pM=pM->next;
        }
        
        return pM;
    }

//判断链表是否有环

ListNode* hasCycle(ListNode* pHead)
{
	if (pHead == nullptr)
	{
		return nullptr;
	}

	ListNode* fast = pHead;
	ListNode* slow = pHead;

	while (fast != nullptr && fast->next != nullptr)
	{
		fast = fast->next->next;
		slow = slow->next;

		if (fast == slow)
		{
			return fast;
		}
	}
	return nullptr;
}

//删除链表中重复的节点

ListNode* deleteDuplication(ListNode* pHead)
{
	if (pHead == nullptr || pHead->next == nullptr)
	{
		return pHead;
	}

	ListNode* pPre = pHead;
	ListNode* pCur = pHead;
	ListNode* pNext = pHead->next;

	while (pNext != nullptr)
	{
		if (pCur->val == pNext->val)
		{
			while (pNext!=nullptr && pCur->val == pNext->val)
			{
				pNext = pNext->next;
			}

			if (pCur == pHead)
			{
				pHead = pCur = pPre = pNext;

				if (pNext != nullptr)
				{
					pNext = pNext->next;
				}
			}
			else
			{
				pCur = pNext;
				pPre->next = pNext;
				pNext = pCur->next;
			}
		}
		else
		{
			pPre = pCur;
			pCur = pNext;
			pNext = pNext->next;
		}
	}

	return pHead;
}

//把二叉树打印成多行

class Solution36 
{
public:
    vector<vector<int>> Print(TreeNode* pRoot)
    {
        vector<vector<int>> result;

        if (pRoot == nullptr)
        {
            return result;
        }

        queue<TreeNode*> q;
        q.push(pRoot);

        while (q.empty() == false)
        {
            vector<int> res;

            int size = q.size();

            for (int i = 1; i <= size; ++i)
            {
                TreeNode* p = q.front();

                res.push_back(q.front()->val);

                if (p->left != nullptr)
                {
                    q.push(p->left);
                }

                if (p->right != nullptr)
                {
                    q.push(p->right);
                }

                q.pop();
            }

            result.push_back(res);
        }
        return result;
    }
};

//数据流中的中位数

class Solution37 
{
public:
    
    vector<int> v;

    void Insert(int num)
    {
        v.push_back(num);
    }

    double GetMedian()
    {
        sort(v.begin(), v.end());

        if (v.size() % 2 == 0)
        {
            double a = v[v.size() >> 1];
            double b = v[(v.size() >> 1) - 1];
            return (a + b) / 2;
        }
        else
        {
            return v[v.size() >> 1];
        }
    }
};

//滑动窗口的最大值

class Solution 
{
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size)
    {
        vector<int> v;
        
        if(num.size()==0 || size==0 || size>num.size())
        {
            return v;
        }
        
        for (int i = 0; i <= num.size() - size; ++i)
        {
            int putnumber = 0;
            int j = 0;

            while (j < size)
            {
                putnumber = max(putnumber, num[i + j]);
                j++;
            }

            v.push_back(putnumber);
        }
        return v;
    }
};

//正则表达式匹配(重点)

//思路参考牛客网的大佬，但是学来的就是我的了

bool match(char* str, char* pattern)
{
	if (*str == '\0' && *pattern == '\0')
	{
		return true;
	}

	if (*str != '\0' && *pattern == '\0')
	{
		return false;
	}

	if (*(pattern + 1) != '*')
	{
		if (*str == *pattern || (*str != '\0' && *pattern == '.'))
		{
			return match(str + 1, pattern + 1);
		}
		else
		{
			return false;
		}
	}
	else
	{
		if (*str == *pattern || (*str != '\0' && *pattern == '.'))
		{
			return match(str, pattern + 2) || match(str + 1, pattern);
		}
		else
		{
			return match(str, pattern + 2);
		}
	}
}

struct TreeLinkNode 
{
    int val;
    struct TreeLinkNode *left;
    struct TreeLinkNode *right;
    struct TreeLinkNode *next;
    TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) 
	{
        
    }
};

//二叉树的下一个节点

//时间复杂度O（N），空间复杂度O（N），非最优解法

void inOrder(vector<TreeLinkNode*>& res, TreeLinkNode* root)
{
	if (root != nullptr)
	{
		inOrder(res, root->left);
		res.push_back(root);
		inOrder(res, root->right);
	}
}


TreeLinkNode* GetNext(TreeLinkNode* pNode)
{
	TreeLinkNode* pCur = pNode;

	while (pCur->next != nullptr)
	{
		pCur = pCur->next;
	}

	vector<TreeLinkNode*> res;
	inOrder(res, pCur);

	for (int i = 0; i < res.size(); ++i)
	{
		if (i != res.size() - 1 && res[i] == pNode)
		{
			return res[i + 1];
		}
	}
	return nullptr;
}

//之字形打印二叉树

vector<vector<int>> LevelOrder(TreeNode* root)
{
	queue<TreeNode*> q;

	vector<vector<int>> result;

	q.push(root);

	while (q.empty() == false)
	{
		vector<int> res;

		//size必须单独拿出来，因为插入之后会更改q.size()的值
		int size = q.size();

		for (int i = 0; i < size; ++i)
		{
			res.push_back(q.front()->val);

			TreeNode* p = q.front();

			if (p->left != nullptr)
			{
				q.push(p->left);
			}

			if (p->right != nullptr)
			{
				q.push(p->right);
			}

			q.pop();
		}

		result.push_back(res);
	}
	return result;
}

vector<vector<int> > Print(TreeNode* pRoot)
{
	vector<vector<int>> res = LevelOrder(pRoot);

	for (int i = 0; i < res.size(); ++i)
	{
		if (i % 2 != 0)
		{
			reverse(res[i].begin(), res[i].end());
		}
	}

	return res;
}

//

int main()
{
	/*
	string a = "123";

	vector<string> result = Permutation(a);

	for(int i=0;i<result.size();++i)
	{
		cout<<result[i].c_str()<<endl;
	}
	*/

	/*
	Solution27 s;

	vector<vector<int>> ss=s.FindContinuousSequence(15);

	for(auto e:ss)
	{
		for(int i=0;i<e.size();++i)
		{
			cout<<e[i]<<" ";
		}
		cout<<endl;
	}

	cout<<endl;
	*/

	// string a="luzihan";

	// Solution29 s;

	// cout<<s.LeftRotateString(a,3).c_str()<<endl;

	system("pause");
	return 0;
}
Austin_Yan
关注
专栏目录
闲着没事整理了一下DLL的N种注入方法.rar
11-20
2. **CreateRemoteThread**： 这是最基本的注入方式，通过创建远程线程并在目标进程中执行LoadLibrary或GetProcAddress函数来加载DLL。首先，我们需要获取目标进程的句柄，然后在它的地址空间内分配内存，写入DLL的...
闲着无聊弄个猜拳的，对swing的布局还不是很了解啊
03-21
2. 布局管理器：深入理解FlowLayout、BorderLayout等布局，以及如何根据需求选择合适的布局。 3. 事件监听：掌握ActionListener接口，处理用户点击按钮的事件。 4. 随机数生成：利用java.util.Random类生成随机数，...
hpu 1216: 复习！复习！
王小二的博客
12-26 361
1216: 复习！复习！ [贪心]题目描述马上到要放假了，也意味着马上要考试了。王炸突然发现他只顾着学acm忘了学习功课，为了避免考试挂科，他决定进行一次复习以让更多的功课及格。已知他现在有n门功课，每门功课都有一个开始复习和复习完毕的时间[st,endd)来表示。求他最多可以复习多少门功课。输入数据的第一行输入一个整数T,表示数据的组数。（0 &lt; T &lt; 300）以后的T组数据，第一...
【针对性复习】放假也不能闲着（1）~
Austin_Yan的博客
10-07 170
去玩 复习
我也来连载我的Java学习之路，希望对大家有所启发
houzhiweisz的专栏
02-24 2679
我也来连载我的Java学习之路，希望对大家有所启发<br />文章分类:Java编程<br />来自:CSDN 推荐者:JAVA99.COM 推荐时间:2006-11-10 <br />作者:dlxu (Coding超过了10W行) 20:59:15 浏览:3672 <br /><br />    这里说说我的经历吧。大学前以及大学前面三年的经历就不说了，因为大学前的高中就是好好学习，大学前三年就是混过来的。 <br /><br /><br />    我上的学校还算可以，虽然不是北大清华这样第一流名牌大学
浙大计算机跨专业考研心路历程记录
CODER的博客
05-12 6749
1.大二下，专业课很多，蹭了许多课，但感觉还是浅尝辄止，没有深入研究下去，这样的我，学到了皮毛，但深入的一点都不会 （汇编，离散，Linux程序设计，密码学） 我好像总觉得自己很忙 但一和别人比较 我其实一点都不忙 我空的很呐 每天只能做两三道洛谷的题，我的方法对嘛？...
如何入门参与数学建模？
热门推荐
JiandaoStudio
12-25 7万+
数学建模感想 纪念逝去的大学数学建模：两次校赛，两次国赛，两次美赛，一次电工杯。从大一下学期组队到现在，大三下学期，时间飞逝，我的大学建模生涯也告一段落。感谢建模路上帮助过我的学长和学姐们，滴水之恩当涌泉相报，写下这篇感想，希望可以给学弟学妹们一丝启发，也就完成我的想法了。拙劣的文笔，也不知道写些啥，按顺序随便写写吧。 我是怎么选择建模的： 大一上，第一次听到数学建模其实是大一上学期，not...
系统架构师7
易的博客
07-12 1684
2017年11月11日 软件系统架构师考试经验分享 置顶2017年11月13日 15:25:53凌飞安阅读数 7812 版权声明：原创作品，转载请注明出处！个人主页 http://www.lingfeian.com https://blog.csdn.net/lingfeian/article/details/78520808 系统架构考试分为3个环节 11月11...
我们如何学习：学会学习再学习
Debroon
05-05 3683
我们如何学习：学会学习再学习学习方法人和人学习能力的差距在哪里？快速学习学习动力激发好奇心不谈兴趣，聘请自己人生只如初见：百学不腻重新定义心理建设进步回路：成为正能量本身：在任何情况下都能支持自己，鼓励自己断然行动：唯有立刻行动，担负起自己的责任，能斩断一切乱七八糟的想法。肯定宣言：我是要成为海贼王的男人，海贼王我当定了   学习方法 文科：刻意模仿，反复练习。 直奔大师，可以从自己喜欢的地方开始，不必从零开始。 比如林语堂先生说：学习英语唯一的正轨，不出仿效与熟诵；仿效即整句的仿效，熟.
记从连续挂掉五六家小型互联网公司面试到收获阿里核心部门实习offer的一些经历和感想
qq_32799165的博客
06-23 2102
写在前面 试读人群:学校背景不是很强，或者没有参加过面试、没有实习经验，基础薄弱又想拿个好offer.的同学，技术大佬可直接略过。 特别说明:由于保密性和公平性等原因，部分公司名称和岗位以及面试题没有直接写出，在此只分享经历和感受。面试经历以流水账的方式来记录，适合那些没有参加过任何面试的同学阅读，这样你能大概了解面试大概是什么样子的，多少可能会有些帮助。 作者简介：本人本科就读于一所地方二本院...
数模小白如何入手数学建模？
weixin_45499067的博客
04-22 952
各大数学建模资料，思路获取见文末名片 数学建模感想 纪念逝去的大学数学建模：两次校赛，两次国赛，两次美赛，一次电工杯。从大一下学期组队到现在，大三下学期，时间飞逝，我的大学建模生涯也告一段落。感谢建模路上帮助过我的学长和学姐们，滴水之恩当涌泉相报，写下这篇感想，希望可以给学弟学妹们一丝启发，也就完成我的想法了。拙劣的文笔，也不知道写些啥，按顺序随便写写吧。 我是怎么选择建模的： 大一上，第一次听到数学建模其实是大一上学期，not大一下学期。某次浏览网页偶然发现的，源于从小对数学，哲学以及历史的崇敬吧
CPU闲着就是闲着了？也是有任务的！.docx
09-26
2. **系统计时器**：系统计时器是唤醒CPU的一种机制，通过设置定时器，当达到预设的时间间隔时，CPU会被唤醒执行必要的任务，之后再返回空闲状态。 3. **节能模式**：现代处理器设计的一个重要目标是快速进入低功率...
java实现的大乐透选号器（5+2），闲着没事玩的，使用exe4j打包的exe文件，切记别当真。
01-29
java实现的大乐透选号器（5+2），闲着没事玩的，使用exe4j打包的exe文件，切记别当真。
考研复习-英语二真题考试题集-带答案
09-14
英语二考研真题复习资料，带答案版
2024中美独角兽公司发展分析报告.pdf
09-14
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、
C++ 中的异步编程模型是什么
09-14
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式： 每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。 在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。 总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。
正则表达式Regex是一种文本模式.docx
最新发布
09-14
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。 基本组成 普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。 特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。 字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。 预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任
基于struts+sqlserver网络购物系统毕业课程源码设计+论文资料
09-14
编号：150 系统功能： 展示网站最新的商品信息。 展示网站特价的商品信息。 为用户提供修改个人资料和查看在网站操作情况的平台。 提供用户在网站上购物的平台。 展示网站发布的公告信息。 展示商品的销量排行。 展示网站的友情链接信息。 对商品详细信息以及分类信息进行管理。 对用户基本资料、交易制度、消费情况及留言信息进行管理。 对用户提交的订单进行管理。 对管理员信息、网站公告信息、商业资讯信息及友情链接信息进行管理。 系统运行稳定，具有强大的数据处理能力。 操作注意事项 （1）本系统的用户名为：admin，密码为：admin （2）admin管理员的信息不能删除。 （3）用户注册登录后，可进行商品购买、商品信息查看以及订单查询操作。 （4）后台登陆地址：http://localhost:8080/WebShopping/bg-land.jsp。
编写程序，实现货币的转换，从键盘上输入人民币的币值，转换成美元的币值并输出，结果保留2位小数。
03-29
汇率为1美元=6.48人民币。 代码如下： ```python rmb = float(input("请输入人民币金额：")) usd = rmb / 6.48 print("美元金额为：%.2f" % usd) ``` 运行结果： ``` 请输入人民币金额：100 ...```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值