剑指Offer面试题（第三十六天）面试题63、64、65、66、67、68（1）、68（2）、68（3）

最新推荐文章于 2023-08-13 12:29:24 发布
最新推荐文章于 2023-08-13 12:29:24 发布
阅读量335 收藏
点赞数
分类专栏： 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43137176/article/details/89889140
版权

* 面试题63：股票的最大利润


     * 题目：假设把某股票的价格按照时间先后顺序存储在数组中，
     * 请问买卖该股票一次可能获得的最大利润是多少？
     * 例如：一只股票在某些时间节点的价格为{9，11，8，5，7，12，16，14}.
     * 如果能在价格为5的时候买入并在价格为16时卖出，则能收获的最大利润11
     * 
     * 
     * 思路：设定一个最小值和最大利润（差值），遍历数组，发现有比最小值小的则更新最小值
     * 若差值有比记录的最大利润大的 则更新最大利润
     * 时间复杂度O(n)

package Test;

public class No63MaxDiff {

	/*
	 * 面试题63：股票的最大利润
	 * 题目：假设把某股票的价格按照时间先后顺序存储在数组中，
	 * 请问买卖该股票一次可能获得的最大利润是多少？
	 * 例如：一只股票在某些时间节点的价格为{9，11，8，5，7，12，16，14}.
	 * 如果能在价格为5的时候买入并在价格为16时卖出，则能收获的最大利润11
	 * 
	 * 
	 * 思路：设定一个最小值和最大利润（差值），遍历数组，发现有比最小值小的则更新最小值
	 * 若差值有比记录的最大利润大的 则更新最大利润
	 * 时间复杂度O(n)
	 * */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		No63MaxDiff m = new No63MaxDiff();
		int[] values = {9,11,8,5,7,12,16,14};
		System.out.println("股票的最大利润："+m.MaxDiff(values));
	}

	private int MaxDiff(int[] values) {
		// TODO Auto-generated method stub
		if(values == null || values.length == 0)
			return -1;
		
		int min = values[0];
		int maxDiff = values[1] - min;
		
		for(int i = 2; i < values.length;i++) {
			if(values[i-1] < min)
				min = values[i-1];
			int currentDiff = values[i] - min;
			if(currentDiff > maxDiff)
				maxDiff = currentDiff;
		}
		
		return maxDiff;
	}

}

 * 面试题64：求1+2+3+...+n


     * 题目：求1+2+3+...+你，要求不能使用乘除法、for、while、if、
     * else、switch、case等关键字及条件判断语句（A？B:C）
     * 
     * 思路：与n有关，题目有限制，首先想到使用数组解决，将数累加放到构造函数中。
     * 但是数组不用for无法完成直接初始化，所以此方法不可行
     * 因而使用&&进行截断
     * &&：在第一个条件不成立时，不在进行第二个条件的判断
 

package Test;

public class No64Sum {

	/*
	 * 面试题64：求1+2+3+...+n
	 * 题目：求1+2+3+...+你，要求不能使用乘除法、for、while、if、
	 * else、switch、case等关键字及条件判断语句（A？B:C）
	 * 
	 * 思路：与n有关，题目有限制，首先想到使用数组解决，将数累加放到构造函数中。
	 * 但是数组不用for无法完成直接初始化，所以此方法不可行
	 * 因而使用&&进行截断
	 * &&：在第一个条件不成立时，不在进行第二个条件的判断
	 * 
	 * */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		No64Sum s = new No64Sum();
		int n = 10;
		System.out.println("从1-10的累加和为："+s.Sum(n));
				
	}

	//灵活运用递归的方式实现
	private int Sum(int n) {
		// TODO Auto-generated method stub
		int sum = 0;
		//&&:在前一个条件下不成立时，后一个条件将不再进行判断
		//也就是判断： n>0  如该条件不成立 则后面的sum+=则不再进行累加 
		//这样就保证一直，累加到1为止
		boolean b = (n > 0)&&((sum += Sum(n-1) + n)>0);
		return sum;
	}

}

     * 面试题65：不用加减乘除做加法


     * 题目：写一个函数，求两个整数之和，
     * 要求在函数体内不得使用“+”、“-”，“*”,“/”四则运算符号
     * 
     * 思路：对两个字使用二进制的位运算
     * 1>  首先对每一位进行相加（不考虑进位），使用异或的方式对每一位进行相加  相同为0，不同为1
     * 2>  然后再对每一位求进位（先与运算，然后再进行向左移动一位）求得进位的置
     * 3>  最后再将前两步的操作进行相加------>也就是重复刚才1>,2>过程
     * 重复执行该操作 直到无进位为止

package Test;

public class No65Add {

	/*
	 * 面试题65：不用加减乘除做加法
	 * 题目：写一个函数，求两个整数之和，
	 * 要求在函数体内不得使用“+”、“-”，“*”,“/”四则运算符号
	 * 
	 * 思路：对两个字使用二进制的位运算
	 * 1>  首先对每一位进行相加（不考虑进位），使用异或的方式对每一位进行相加  相同为0，不同为1
	 * 2>  然后再对每一位求进位（先与运算，然后再进行向左移动一位）求得进位的置
	 * 3>  最后再将前两步的操作进行相加------>也就是重复刚才1>,2>过程
	 * 重复执行该操作 直到无进位为止
	 * 
	 * */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		No65Add p = new No65Add();
		int m = 5;
		int n = 17;
		System.out.println("两个整数之和为："+p.Add(m,n));
	}

	private int Add(int m, int n) {
		// TODO Auto-generated method stub
		if(n == 0)
			return m;
		
		while(n != 0) {
			//使用异或 对每一位求和
			int temp = m ^ n;
			//使用与操作+左移操作  对每一位求进位
			n = (m & n) << 1;
			m = temp;
		}
		
		return m;
	}

}

 * 面试题66：构建乘积数组


     * 题目：给定一个数组A[0,1,2,...,n-1],请构建一个数组B[0,1,2,...,n],
     * 其中B中的元素B[i] =A[0]*A[1]*...*A[i-1]*A[i+1]*...A[n-1],不能使用除法
     * 
     * 思路：
     *  B[0]   =   1  * A[1] * A[2] * ... * A[n-2] * A[n-1]
     *  B[1]   = A[0] *   1  * A[2] * ... * A[n-2] * A[n-1]
     *  B[2]   = A[0] * A[1] *   1  * ... * A[n-2] * A[n-1]
     *  ......
     *  B[n-2] = A[0] * A[1] * A[2] * ... *    1   * A[n-1]
     *  B[n-1] = A[0] * A[1] * A[2] * ... * A[n-2] *   1
     * 
     * 然后对其进行上三角以及下三角区域相乘之积  即为所求
     * 上三角 由上到下计算
     * 下三角  由下到上计算

package Test;

public class No66Multiply {

	/*
	 * 面试题66：构建乘积数组
	 * 题目：给定一个数组A[0,1,2,...,n-1],请构建一个数组B[0,1,2,...,n],
	 * 其中B中的元素B[i] =A[0]*A[1]*...*A[i-1]*A[i+1]*...A[n-1],不能使用除法
	 * 
	 * 思路：
	 *  B[0]   =   1  * A[1] * A[2] * ... * A[n-2] * A[n-1]
	 *  B[1]   = A[0] *   1  * A[2] * ... * A[n-2] * A[n-1]
	 *  B[2]   = A[0] * A[1] *   1  * ... * A[n-2] * A[n-1]
	 *  ......
	 *  B[n-2] = A[0] * A[1] * A[2] * ... *    1   * A[n-1]
	 *  B[n-1] = A[0] * A[1] * A[2] * ... * A[n-2] *   1
	 * 
	 * 然后对其进行上三角以及下三角区域相乘之积  即为所求
	 * 上三角 由上到下计算
	 * 下三角  由下到上计算
	 * 
	 * */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		No66Multiply m = new No66Multiply();
		int[] A = {1,2,3,4,3,2,1};
		int[] B = m.Multiply(A);
		for(int i = 0;i < A.length;i++) {
			System.out.println(B[i]+",");
		}
		
	}

	private int[] Multiply(int[] A) {
		// TODO Auto-generated method stub
		if(A == null)
			return null;
		if(A.length == 0)
			return new int[0];
		
		int[] result = new int[A.length];
		result[0] = 1;
		//下三角C[i] = A[0]*A[1]*...*A[i-1]   
		//由上到下顺序计算  C[i] = C[i-1]*A[i-1]
		//其中result[i]为C[i] 
		for(int i = 1;i < A.length;i++)
			result[i] = result[i-1]*A[i-1];
		
		//上三角D[i] = A[i+1]*A[i+2]*...*A[n-1] 
		//由下到上顺序计算 D[i] = D[i+1]*A[i+1]
		int temp = 1;
		//其中  从下到上
		//temp = A[A.length-1],
		//temp = A[A.length-1]*A[A.length-2]
		//,...,
		//temp = A[A.length-1]*A{A.length-2}*...*A[0]
		//result[i] = result[i] * temp  就是B{i]的结果		for(int i = A.length - 2; i >= 0;i--) {
		for(int i = A.length - 2;i >= 0;i++) {
			temp *= A[i + 1];
			result[i] *= temp;
		}
		
		return result;
	}

}

 * 面试题67：把字符串转换成整数


     * 题目：将一个字符串转换成一个整数，要求不能使用字符串转换为证书的库函数
     * 数字为0或者字符串不是一个合法的数值，则返回0
     * 
     * 思路：
     * 需要考虑非法输入和边界值条件
     * 合法输入：
     * 1> 数字       
     * 2>+/-数字
     * 
     * 非法输入：
     * 1>null      
     * 2>字符串为空
     * 3>字符串只有一个符号+/-
     * 4>字符串中由非数字字符
     * 5>字符串超过int所能表示的范围  溢出

package Test;

public class No67StrToInt {

	/*
	 * 面试题67：把字符串转换成整数
	 * 题目：将一个字符串转换成一个整数，要求不能使用字符串转换为证书的库函数
	 * 数字为0或者字符串不是一个合法的数值，则返回0
	 * 
	 * 思路：
	 * 需要考虑非法输入和边界值条件
	 * 合法输入：
	 * 1> 数字       
	 * 2>+/-数字
	 * 
	 * 非法输入：
	 * 1>null      
	 * 2>字符串为空
	 * 3>字符串只有一个符号+/-
	 * 4>字符串中由非数字字符
	 * 5>字符串超过int所能表示的范围  溢出
	 * 
	 * */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		No67StrToInt p = new No67StrToInt();
		String s = "+889";
		System.out.println("字符串转为整数："+p.StrToInt(s));
	}

	private int StrToInt(String s) {
		// TODO Auto-generated method stub
		if(s == null || s == "")
			return 0;
		int index = 0;   //下标
		long result = 0;
		boolean isPositive = true;   //记录正负号标志位
		
		//若有符号
		if(s.charAt(0) == '+' || s.charAt(0) == '-') {
			++index;
			//若只有正负号  则返回0
			if(index == s.length())
				return 0;
			if(s.charAt(0) == '-')
				isPositive = false;
		}
		//因为是整数所以不必考虑小数点      123 中s.charAt(0) = 1;s.charAt(2) = 3;
		for(int i = index;i < s.length();i++) {
			if(s.charAt(i) < '0' || s.charAt(0) > '9')
				return 0;
			result *= 10;
			result += (s.charAt(i) - '0')*(isPositive?1:-1);
			if(result > Integer.MAX_VALUE || result < Integer.MIN_VALUE)
				return 0;
		}
		return (int)result;
	}

}

* 面试题68：最低公共祖先


     * 给出树中的两个节点，求这两个节点的最低公共祖先


     * 题目一：树是二叉搜索树

 
     * 思路：时间复杂度O(logn)     空间复杂度O(1)
     * 从树的根节点开始遍历，若根节点的值大于其中一个节点，小于另外一个节点，则根节点就是最低公共节点。
     * 若根结点的值小于两个节点的值，则递归求其右子树
     * 若根节点的值大于两个节点的值，则递归求其左子树
     * 若根节点的值等于其中的某一个节点，那么说明这两个节点在一条路径上，所以最低公共祖先则是根节点的父节点
 

package Test;

import Test.No55First_TreeDepth.BinaryTreeNode;

public class No68First_GetLowestCommonAncestorBinaryTree {

	/*
	 * 面试题68：最低公共祖先
	 * 给出树中的两个节点，求这两个节点的最低公共祖先
	 * 题目一：树是二叉搜索树
	 * 
	 * 
	 * 思路：时间复杂度O(logn)     空间复杂度O(1)
	 * 从树的根节点开始遍历，若根节点的值大于其中一个节点，小于另外一个节点，则根节点就是最低公共节点。
	 * 若根结点的值小于两个节点的值，则递归求其右子树
	 * 若根节点的值大于两个节点的值，则递归求其左子树
	 * 若根节点的值等于其中的某一个节点，那么说明这两个节点在一条路径上，所以最低公共祖先则是根节点的父节点
	 * 
	 * */
	static class BinaryTreeNode{
		int val;
		BinaryTreeNode left;
		BinaryTreeNode right;
		
		BinaryTreeNode(int val){
			this.val = val;
		}
		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		No68First_GetLowestCommonAncestorBinaryTree p =  new No68First_GetLowestCommonAncestorBinaryTree();
		BinaryTreeNode root1 = new BinaryTreeNode(5);
		BinaryTreeNode one = new BinaryTreeNode(3);
		BinaryTreeNode two = new BinaryTreeNode(7);
		BinaryTreeNode three = new BinaryTreeNode(2);
		BinaryTreeNode four = new BinaryTreeNode(4);
		BinaryTreeNode five = new BinaryTreeNode(6);
		BinaryTreeNode six = new BinaryTreeNode(8);
		BinaryTreeNode seven = new BinaryTreeNode(1);
		
		root1.left = one;
		root1.right = two;
		one.left = three;
		one.right = four;
		two.left = five;
		two.right = six;
		three.left = seven;
		three.right = null;
		four.left = null;
		four.right = null;
		five.left = null;
		five.right = null;
		six.left = null;
		six.right = null;
		seven.right = null;
		seven.left = null;
		
		System.out.println("两个节点的最低公共祖先："+p.GetLowestCommonAncestor(root1,root1,seven,four).val);
		
		
	}
	
	private BinaryTreeNode GetLowestCommonAncestor(BinaryTreeNode rootParent,BinaryTreeNode root1, BinaryTreeNode node1, BinaryTreeNode node2) {
		// TODO Auto-generated method stub
		if(root1 == null || node1 == null || node2 == null)
			return null;
		//若根节点在两个节点之间  则返回根节点
		if((root1.val - node1.val)*(root1.val - node2.val) < 0)
			return root1;
		else if((root1.val - node1.val)*(root1.val - node2.val) > 0) {
			//判断是左右子树中的哪一个
			BinaryTreeNode newRoot = ((root1.val > node1.val)&&(root1.val > node2.val))?root1.left:root1.right;
			return GetLowestCommonAncestor(root1,newRoot,node1,node2);
		}
		else
			return rootParent;
		
	}
	
	
	

}

 * 题目二：树是普通树，但有指向父节点的指针


     * 思路：两个节点若是在两条路径上，类似于两个链表的第一个公共节点。
     * 由于每个节点的深度最多为logn，所以时间复杂度O(logn)，空间复杂度O(1)

package Test;

public class No68Second_FetLowestCommonAncestorTreeParent {

	/*
	 * 面试题68：最低公共祖先
	 * 给出树中的两个节点，求这两个节点的最低公共祖先
	 * 题目二：树是普通树，但有指向父节点的指针
	 * 
	 * 
	 * 思路：两个节点若是在两条路径上，类似于两个链表的第一个公共节点。
	 * 由于每个节点的深度最多为logn，所以时间复杂度O(logn)，空间复杂度O(1)
	 * 
	 * */
	
	static class TreeNode{
		int val;
		TreeNode one;
		TreeNode two;
		TreeNode three;
		TreeNode parent;
		
		TreeNode(int val){
			this.val = val;
		}
		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		No68Second_FetLowestCommonAncestorTreeParent p =  new No68Second_FetLowestCommonAncestorTreeParent();

		TreeNode root1 = new TreeNode(5);
		TreeNode one = new TreeNode(3);
		TreeNode two = new TreeNode(7);
		TreeNode three = new TreeNode(2);
		TreeNode four = new TreeNode(4);
		TreeNode five = new TreeNode(6);
		TreeNode six = new TreeNode(8);
		
		root1.one = one;
		root1.two = two;
		root1.three = three;
		one.one = null;
		one.two = null;
		one.three = null;
		two.one = five;
		two.two = six;
		two.three = null;
		three.one = null;
		three.two = null;
		three.three = null;
		four.one = six;
		four.two = null;
		four.three = null;
		five.one = null;
		five.two = null;
		five.three = null;
		six.one = null;
		six.two = null;
		six.three = null;
		
		one.parent = root1;
		two.parent = root1;
		three.parent = root1;
		four.parent = one;
		five.parent = one;
		six.parent = four;
		
		System.out.println("两个节点的最低公共祖先："+p.GetLowestCommonAncestor(root1,six,two).val);

	}
	private TreeNode GetLowestCommonAncestor(TreeNode root1, TreeNode node1, TreeNode node2) {
		// TODO Auto-generated method stub
		if(root1 == null || node1 == null || node2 == null)
			return null;
		
		int depth1 = findTheDepthOfTheNode(root1,node1,node2);
		if(depth1 == -1)   //两个节点在一条路径上   则返回后一个的父节点即node2.parent
			return node2.parent;
		
		int depth2 = findTheDepthOfTheNode(root1,node2,node1);
		if(depth2 == -1)//两个节点在一条路径上   则返回后一个的父节点即node1.parent
			return node1.parent;
		
		//p 指向较深的节点
		//q 指向较浅的节点
		TreeNode p = (depth1 > depth2)?node1:node2;
		TreeNode q = (depth1 > depth2)?node2:node1;
		//二者深度的差值  的绝对值
		int depth = Math.abs(depth1-depth2); 

		//先将长的那一个率先移动差值个节点
		while(depth > 0) {
			p = p.parent;
			depth -- ;
		}
		//然后两个一起移动   直到找到最小公共祖先
		while(p != q) {
			p = p.parent;
			q = q.parent;
		}
		return p;
	}
	
	//求node1，node2深度，若node1和node2在一条路径上，则返回-1；否则返回node1的深度
	private int findTheDepthOfTheNode(TreeNode root1, TreeNode node1, TreeNode node2) {
		// TODO Auto-generated method stub
		int depth = 0;
		//从叶子节点向上遍历
		while(node1.parent != null) {
			node1 = node1.parent;
			depth++;
			//node1 == node2表示node1和node2在一条路径上
			//且 node2是node1的父节点 
			if(node1 == node2)
				return -1;
		}
		
		return depth;
	}

}


     * 题目三：树是普通树，没有指向父节点的指针


     * 思路：用栈的方式来实现类似于指向父节点指针的功能，
     * 获取node节点的路径时间复杂度为O(n)，所以总的时间复杂度O(n),空间复杂度O(logn)
 

package Test;

import java.util.Stack;

public class No68Third_FetLowestCommonAncestorTree {

	/*
	 * 面试题68：最低公共祖先  *********难！！！！！
	 * 给出树中的两个节点，求这两个节点的最低公共祖先
	 * 题目三：树是普通树，没有指向父节点的指针
	 * 
	 * 思路：用栈的方式来实现类似于指向父节点指针的功能，
	 * 获取node节点的路径时间复杂度为O(n)，所以总的时间复杂度O(n),空间复杂度O(logn)
	 * 
	 * */
	
	static class TreeNode{
		int val;
		TreeNode one;
		TreeNode two;
		TreeNode three;
		
		TreeNode(int val){
			this.val = val;
		}
		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		No68Third_FetLowestCommonAncestorTree p =  new No68Third_FetLowestCommonAncestorTree();

		TreeNode root1 = new TreeNode(5);
		TreeNode one = new TreeNode(3);
		TreeNode two = new TreeNode(7);
		TreeNode three = new TreeNode(2);
		TreeNode four = new TreeNode(4);
		TreeNode five = new TreeNode(6);
		TreeNode six = new TreeNode(8);
		
		root1.one = one;
		root1.two = two;
		root1.three = three;
		one.one = five;
		one.two = six;
		one.three = null;
		two.one = null;
		two.two = null;
		two.three = null;
		three.one = null;
		three.two = null;
		three.three = null;
		four.one = six;
		four.two = null;
		four.three = null;
		five.one = null;
		five.two = null;
		five.three = null;
		six.one = null;
		six.two = null;
		six.three = null;
		
		System.out.println("两个节点的最低公共祖先："+p.GetLowestCommonAncestor(root1,six,two).val);

	}
	private TreeNode GetLowestCommonAncestor(TreeNode root1, TreeNode node1, TreeNode node2) {
		// TODO Auto-generated method stub
		
		if(root1 == null || node1 == null || node2 == null)
			return null;
		
		Stack<TreeNode> path1 = new Stack<TreeNode>();
		boolean flag1 = GetThePathOfTheNode(root1,node1,path1);
		//树上没有node1节点
		if(!flag1) 
			return null;
		
		Stack<TreeNode> path2 = new Stack<TreeNode>();
		boolean flag2 = GetThePathOfTheNode(root1,node2,path2);
		//树上没有node2节点
		if(!flag2) 
			return null;
		
		//让两个路径等长
		if(path1.size() > path2.size())
			while(path1.size() != path2.size())
				path1.pop();
		else
			while(path1.size() != path2.size())
				path2.pop();
		
		//若path1 == path2  表示  比较的是stack1的地址与stack2的地址是都相同
		// 若相等      返回true 否则false
		if(path2 == path1)//表示path1和path2指向同一个地址空间     表示两个节点在一条路径上？？
		{
			path1.pop();
			return path1.pop();
		}else {
			TreeNode p = path1.pop();
			TreeNode q = path2.pop();
			
			while(p != q) {
				p = path1.pop();
				q = path2.pop();
			}
			//从目标节点向上遍历，返回第一个相等的（公共祖先）
			return p;	
		}
			
	}
	
	//获取根节点到node节点的路径   从根节点开始自上而下的将路径压入栈中
	private boolean GetThePathOfTheNode(TreeNode root1, TreeNode node, Stack<TreeNode> path) {
		// TODO Auto-generated method stub
		//将根节点压入栈内
		path.push(root1);
		//直到在树中找到node节点后  才会结束递归  并逐层返回递归结果
		if(root1 == node)
			return true;
		boolean found = false;
		if(root1.one != null)
			found = GetThePathOfTheNode(root1.one,node,path);
		
		if(!found && root1.two != null)
			found = GetThePathOfTheNode(root1.two,node,path);
		
		if(!found && root1.three != null)
			found = GetThePathOfTheNode(root1.three,node,path);
		
		if(!found)
			path.pop();
		
		return found;
	}

}

 

DM X
关注
专栏目录
【剑指offer】JVM经典面试题
sinat_34576567的博客
11-12 898
JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。 Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Java语言虚拟机后，Java语言在不同平...
剑指offer_常见面试题
legend050709的专栏
07-15 424
参见：https://www.cnblogs.com/AndyJee/category/687572.html https://www.jianshu.com/c/8581232f6d07 头条、快手、阿里的常见面试题：https://blog.csdn.net/xo3ylAF9kGs/article/details/89324669 ...
剑指offer-面试题4-(举一反三)-刷题及总结(python)
手中无剑，心中有剑
08-07 323
替换空格解题思路代码实现(python)解题总结 题目：有两个排序的数组A1和A2。内存在A1的末尾有足够多的空余空间容纳A2。请实现一个函数，把A2中的所有数字插入到A1中并且所有的数字是排序的。 解题思路 这道题是面试题4-替换空格的相关题目，和那道例题一样，首先想到的可能是在A1中从头到尾复制数字，但这样就会出现多次复制一个数字的情况，更好的办法是从尾到头比较A1和A2中的数字，并把较大的数...
剑指Offer面试题（第二十三天）面试题38
weixin_43137176的博客
04-18 196
* 面试题38：字符串的排列 * 题目：输入一个字符串，打印该字符串中字符的所有排列。 * 例如：输入字符串abc，打印出字符a、b、c所能排列出来的所有字符串abc,acb,bac,bca,cab,cba * * 思路：将字符串的多个位置拆分成 ==> 第一个字符+其他字符 * 第一步：第一个字符可以是字符串中的任意一个 ...
剑指Offer面试题（第二十九天）面试题48、49（无辅助空间）、49（有辅助空间）
weixin_43137176的博客
04-25 266
* 面试题48：最长不含重复字符的子字符串+长度 * 题目：请从字符串中找出一个最长的不包含重复自负的子字符串，计算该子字符串的长度。 * 假设字符串中只包含'a'~'z'的字符。 * 例如，在字符串"arabcacfr"中，最长的不含重复字符的子字符串是"acfr",长度为4 * * 思路：运用东岱规划的思想进行解题，设定f(i)表示以第...
Leetcode刷题：剑指offer【面试题07】
01-20
【面试题07】重建二叉树 难度： 中等 限制： 0 <= 节点个数 <= 5000 输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 Leetcode题目对应...
剑指offer面试题1-10
01-20
题目中提到的面试题是关于如何为自定义的类`CMyString`添加赋值运算符（copy assignment operator）。在C++中，赋值运算符需要处理深拷贝和浅拷贝的问题，以防止内存泄漏和悬挂指针。下面我们将详细讨论这个问题以及...
剑指offer 面试题63. 股票的最大利润
12-22
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。  注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。 示例 2: 输入: [7,6,4,3,1] 输出: 0 解释: ...
剑指offer面试题15. 二进制中1的个数(位运算)
12-21
剑指Offer面试题15就提出了这样一个问题：如何计算一个整数在二进制表示中1的个数？这个问题看似简单，但其背后的位运算技巧却蕴含了丰富的编程智慧。 首先，我们来看一下给出的解决方案。这个问题的解答关键在于位...
基于剑指Offer的编程面试题源码设计与解析
最新发布
09-29
该项目是针对《剑指Offer》编程面试题的源码设计与解析，汇集了C++、C、Python等多种语言编写的共338个文件，包括207个C++源文件、66个Markdown文档、18个Visual Studio项目文件、10个JPEG图片文件、2个Python和C...
剑指Offer面试题（第五天）面试题7、8
weixin_43137176的博客
03-26 381
* 面试题7：重建二叉树 * 题目：输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。 * 假设输入的前序遍历和中序遍历的结果中都不包含重复的数字。 * 例如：输入前序遍历序列{1，2，4，7，3，5，6，8}和中序遍历序列{4，7，2，1，5，3，8，6}， * 则重建二叉树并输出它的头节点...
剑指Offer面试题43：n个色子的点数
做一名努力的通信程序员
09-26 798
以下算法和程序转自该博客：http://blog.csdn.net/derrantcm/article/details/46784575 题目：n个色子的点数             把n个色子仍在地上，所有色子朝上一面的点数之和为s，输入n，打印出s的所有可能值出现的概率 算法分析： 算法1.基于递归求色子点数，时间效率不高 现在我们考虑如何统计每一个点
剑指offer面试题63：股票的最大利润
weixin_45693198的博客
02-20 318
题目描述 假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？ 示例1 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。 示例2 输入: [7,6,4,3,1] 输出: 0 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 提示 0<=数组长度
股票的最大利润(剑指 Offer 63)
input_out的博客
02-14 482
股票的最大利润(剑指 Offer 63) 1 题目描述 假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？ 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出， 最大利润 = 6-1 = 5 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。 2 思路分析 使用暴力法第一份层循环指向买的一天，第二层循环一次遍历以后的每一天找到利润最大的一次交易可得时间复杂度
(贪心) 剑指 Offer 63. 股票的最大利润 ——【Leetcode每日一题】
weixin_43412762的博客
08-13 1035
剑指 Offer 63. 股票的最大利润 假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？
剑指offer | 面试题63：股票的最大利润
程序员大航子
03-14 413
转载本文章请标明作者和出处 本文出自《Darwin的程序空间》 本文题目和部分解题思路来源自《剑指offer》第二版 开始行动，你已经成功一半了，献给正在奋斗的我们 题目 假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？ 示例一 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股...
面试题63-股票的最大利润
weixin_42127177的博客
01-12 1300
题目 假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？ 解题思路 我们可以先定义函数diff（x）为当卖出价位数组中第i个数字时可能获得的最大利润。显然，在卖出价固定时，买入价越低获得的利润越大。也就是说如果在扫描到数组中的第i个数字时，只要我们能够记住之前的i-1个数字中的最小值，就能算出在当前价位卖出时可能得到的最大利润。 C++实现 class Solution { public: int maxProfit(vector<int>&a
股票的最大利润 (DP求解)
小白猿同学
08-23 609
股票的最大利润 (DP求解) 题目描述：假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？LeetCode链接 题目分析：根据示例，我们发现需要找出给定数组中两个数字之间的最大差值（即，最大利润）。此外，第二个数字（卖出价格）必须大于第一个数字（买入价格）。 暴力求解 假设共有n天，第i天买入，第j天卖出，并且卖出价格必须大于买入价格，所以依次以第1天买入，第2 3 4….n天卖出，第2天买入，第3 4 5 6 …n天卖出,找出其中的最大值即可。 /**
《剑指Offer（第二版）》面试题63. 股票的最大利润
今晚打老虎
03-01 412
假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？ 示例 1: 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。 示例 2: 输入: [7,6,4,3,1] 输...
掌握前端算法面试题：剑指offer精选
资源摘要信息:"前端面试题之算法剑指offer题集.zip" 在IT行业中，前端开发是一个非常重要的领域，它主要负责网站或应用程序的用户界面和用户体验。前端开发通常包括HTML、CSS和JavaScript等技术。随着互联网的快速...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值