剑指offer学习2（Java语言版）

最新推荐文章于 2022-11-23 11:11:08 发布
最新推荐文章于 2022-11-23 11:11:08 发布
阅读量190 收藏 1
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sixabs/article/details/90740554
版权

题目列表

面试题2：单例模式

设计一个类，我们只能生成该类的一个实例

这道题考察的是单例模式，这里给个对单例模式讲解的比较详细的网址 菜鸟教程|单例模式

面试题3：数组中重复的数字

在这里插入图片描述
分析：利用数组下标是连续的，且在该题中与数组存储的元素具有对应关系，如果没有重复，则排序后刚好和下标对应；如果有重复，则排序后存在不能和下标对应的情况

public class Demo03_1 {
	/**
	 * @param arr 输入的数组
	 * @return 返回 -1表示要么数字超范围，要么没有重复的数字
	 */
	public static int search(int[] arr) {
		if (arr == null) {
			return -1;
		}
		for (int i = 0; i < arr.length; i++) {
			while (arr[i] != i) {
				int index = arr[i];
				// 验证数字
				if (index < 0 || index > arr.length - 1) {
					System.out.print("数组元素超出 [0,n-1]范围 ");
					return -1;
				}
				// 查重
				if (arr[i] == arr[index]) {
					return arr[i];
				}
				// 交换
				int temp = arr[index];
				arr[index] = arr[i];
				arr[i] = temp;
			}
		}
		return -1;
	}

	public static void main(String[] args) {
		// 测试用例
		int[] arr0 = null; // 空指针 
		int[] arr1 = {}; // 测空数组
		int[] arr2 = { 2, 3, 1, 0, 2, 5, 3 }; // 有重复数字：数字在 0 ~ n-1
		int[] arr3 = { 2, 3, 7, 0, 3, 5, 3 }; // 数字超出范围：数字不在 0 ~ n-1
		int[] arr4 = { 2, 0, 1, 3, 5, 4 }; // 没有重复数字

		// 测试结果
		System.out.println("arr0: " + search(arr0));
		System.out.println("arr1: " + search(arr1));
		System.out.println("arr2: " + search(arr2));
		System.out.println("arr3: " + search(arr3));
		System.out.println("arr4: " + search(arr4));
	}
}

测试输出:

arr0: -1
arr1: -1
arr2: 2
数组元素超出 [0,n-1]范围 arr3: -1
arr4: -1

在这里插入图片描述
分析：这里只是在题目一的基础上加1，使下标对应比所存的数字小一，所以可以在题目一的解答上稍作修改。

public class Demo03_2 {
	/**
	 * @param arr 输入的数组
	 * @return 返回 -1表示要么数字超范围，要么没有重复的数字
	 */
	public static int search(int[] arr) {
		if (arr == null) {
			return -1;
		}
		for (int i = 0; i < arr.length; i++) {
			while (arr[i] != i + 1) {
				int index = arr[i] - 1;
				// 验证数字
				if (index < 0 || index > arr.length - 1) {
					System.out.print("数组元素超出 [1,n]范围 ");
					return -1;
				}
				// 查重
				if (arr[i] == arr[index]) {
					return arr[i];
				}
				// 交换
				int temp = arr[index];
				arr[index] = arr[i];
				arr[i] = temp;
			}
		}
		return -1;
	}

	public static void main(String[] args) {
		// 测试用例
		int[] arr0 = null; // 空指针 
		int[] arr1 = {}; // 测空数组
		int[] arr2 = { 2, 3, 5, 4, 3, 2, 6, 7 }; // 有重复数字：数字在 1 ~ n
		int[] arr3 = { 2, 9, 5, 4, 3, 2, 6, 7 }; // 数字超出范围：数字不在 1 ~ n
		int[] arr4 = { 2, -1, 5, 4, 3, 2, 6, 7 }; // 数字超出范围：数字不在 1 ~ n
		int[] arr5 = { 2, 1, 3, 8, 4, 6, 5, 7 }; // 没有重复数字

		// 测试
		System.out.println("arr0: " + search(arr0));
		System.out.println("arr1: " + search(arr1));
		System.out.println("arr2: " + search(arr2));
		System.out.println("arr3: " + search(arr3));
		System.out.println("arr4: " + search(arr4));
		System.out.println("arr5: " + search(arr5));
	}
}

测试输出：

arr0: -1
arr1: -1
arr2: 3
数组元素超出 [1,n]范围 arr3: -1
数组元素超出 [1,n]范围 arr4: -1
arr5: -1

面试题4：二维数组中的查找

在这里插入图片描述
分析：首先处理输入为空数组的情况，还应该考虑是否存在行向量和列向量的情况。观察可以发现题目描述的矩阵可发现：目标值target与某一值arr[i][j]比较的时候，如果target = arr[i][j]直接返回true；如果target < arr[i][j]，则应该在该值左或上方找，i++；如果target > arr[i][j]，则应该在该值的右或下方找。所以我们应该开始从最左下角找，这样就只需要向上和向右走了，直到找到这个值返回true或者搜索完这个矩阵没找到返回false。

public class Demo04 {
	public static void main(String[] args) {
		// 测试用例
		int[][] m0 = null; // 空指针
		int[][] m1 = {}; // 空数组
		int[][] m2 = { { 1 }, { 3 }, { 6 }, { 23 }, { 49 }, { 60 } }; // 列向量
		int[][] m3 = { { 1, 3, 6, 23, 49, 60 } }; // 行向量
		int[][] m4 = { // 正常
						{ 1, 2, 8, 9 }, 
						{ 2, 4, 9, 12 }, 
						{ 4, 7, 10, 13 }, 
						{ 6, 8, 11, 15 } 
					 };
		// 二维数组不符合递增情况，不考虑
		// 二维数组行向量不等长，不考虑

		int[] target = { 3, -2, 6, 4, 9 };

		// 测试
		System.out.println("m0, target = 3: " + search(m0, target[0])); // false
		System.out.println("m1, target = -2: " + search(m1, target[1]));// false
		System.out.println("m2, target = 6: " + search(m2, target[2])); // true
		System.out.println("m3, target = 4: " + search(m3, target[3])); // false
		System.out.println("m4, target = 9: " + search(m4, target[4])); // true
	}

	public static boolean search(int[][] m, int target) {
		// 判空
		if (m == null || m.length == 0) {
			return false;
		}
		int row = m.length;
		int col = m[0].length;
		int i = row - 1, j = 0;
		while (i >= 0 && j <= col -1) {
			if (m[i][j] > target) {
				i--;
			} else if (m[i][j] < target) {
				j++;
			} else {
				return true;
			}
		}
		return false;
	}

}

测试输出：

m0, target = 3: false
m1, target = -2: false
m2, target = 6: true
m3, target = 4: false
m4, target = 9: true

面试题5：替换空格

在这里插入图片描述

分析：这个题不太适合Java，因为可以用替换函数s.replace(" ", “%20”);直接返回，暂时跳过。

面试题6：从尾到头打印链表

在这里插入图片描述
分析：LeetCode上算法题，头结点都是带数据的，所以这里我们也默认头结点带数据。
首先，需要考虑到链表为null和长度为1的特殊情况，打印一般是要求返回一个存储结点值的List。

  • 方法1：遍历一遍存储在栈中，然后依次弹出来，有循环和递归两种；
  • 方法2：将值存储到一个ArrayList反向遍历；

用递归方法代码简洁，但是当列表很长，调用方法栈帧很多层，很吃内存，所以还是用循环的方式要好一点。

public class Demo06 {
	public static void main(String[] args) {
		// 测试用例
		// 一个测试用例 list = [9,8,7,6,5,4,3,2,1]
		ListNode root = new ListNode(9);
		ListNode node = root;
		for (int i = 8; i > 0; i--) {
			node.next = new ListNode(i);
			node = node.next;
		}

		// 测试
		printLinkedList(null); // null
		printLinkedList(root); // [9,8,7,6,5,4,3,2,1]
	}

	// 用了额外的空间，空间复杂度为O(n)
	private static void printLinkedList(ListNode root) {
		// 底层是数组, 所以随机访问get(i)复杂度是O(1)
		ArrayList<Integer> list = new ArrayList<Integer>(); 
		if (root == null) {
			return;
		}
		// 遍历
		while (root != null) {
			list.add(root.val);
			root = root.next;
		}
		// 反向打印
		for (int i = list.size() - 1; i >= 0; i--) {
			System.out.print(list.get(i) + " ");
		}
		list.clear();
	}
}

class ListNode {
	int val;
	ListNode next;

	ListNode(int x) {
		val = x;
	}
}

测试输出：

1 2 3 4 5 6 7 8 9

面试题7：重建二叉树

在这里插入图片描述
分析：二叉树是有序树，前序遍历的第一个值即为根节点，根据根节点的值我们可以在中序遍历中找到根节点的位置j，j前面部分位于根节点左边，后面的部分位于根节点右边，这样我们就又可以在先序遍历序列中找到根节点的左右子节点，依次递归下去。
同时我们还要注意给出的序列中不能有重复的值，不然是不能找到根节点的。

// 定义二叉树节点
class TreeNode {
	int val;
	TreeNode left;
	TreeNode right;

	TreeNode(int x) {
		val = x;
	}
}

public class Demo07 {
	public static void main(String[] args) {
		// 测试序列
		int[] preOrder = { 1, 2, 4, 7, 3, 5, 6, 8 };
		int[] inOrder = { 4, 7, 2, 1, 5, 3, 8, 6 };
		// 重建
		TreeNode root = reConstructBinaryTree(preOrder, inOrder);
		// 测试先序遍历
		traversePre(root);
		// 测试中序遍历
		System.out.println("\n---------------");
		traverseIn(root);
	}

	public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        TreeNode root = reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
        return root;
    }

	// 根据先序遍历和中序遍历创建二叉树
	private static TreeNode reConstructBinaryTree(int[] pre, int startPre,int endPre,int[] in, int startIn,int endIn){
		// 递归结束条件
        if(startPre>endPre||startIn>endIn)
            return null;
        // 新建一个节点
        TreeNode root = new TreeNode(pre[startPre]);
        
        for(int i = startIn; i <= endIn; i++)
            if(in[i] == pre[startPre]){// 在中序遍历中找到根节点位置
            	/**
            	 * 中序遍历中根节点在i位置，先序遍历中根节点在startPre位置，则：
            	 * 先序序列左子树范围：[startPre+1,startPre+i-startIn]
            	 * 中序序列左子树范围：[startIn,i-1]
            	 * 先序序列右子树范围：[i-startIn+startPre+1,endPre]
            	 * 中序序列右子树范围：[i+1,endIn]
            	 */
                root.left = reConstructBinaryTree(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
                root.right = reConstructBinaryTree(pre,i-startIn+startPre+1,endPre,in,i+1,endIn);
                break;
            }
        return root;
    }
	
	// 中序遍历
	public static void traverseIn(TreeNode root) {
		if (root != null) {
			traverseIn(root.left);
			System.out.print(root.val + " ");
			traverseIn(root.right); 
		}
	}

	// 先序遍历
	public static void traversePre(TreeNode root) {
		if (root != null) {
			System.out.print(root.val + " ");
			traversePre(root.left);
			traversePre(root.right); 
		}
	}

}

面试题8：二叉树的下一个结点

在这里插入图片描述

面试题9：用两个栈实现队列

在这里插入图片描述
分析：可以用stack1作为数据存储，添加的时候先已有的数据全压入stack2，然后在stack1添加新的元素，最后把stack2的元素压回来；如果是删除，直接从stack1栈顶pop一个元素即可，代价很小。这种方法缺点是入栈需要执行2n出栈操作和2n+1次入栈操作。

public class Quene<T> {
	private Stack<T> stack1 = new Stack<T>();
	private Stack<T> stack2 = new Stack<T>();

	public void appendTail(T t) {
		while (!stack1.isEmpty()) {
			stack2.push(stack1.pop());
		}
		stack1.push(t);
		while (!stack2.isEmpty()) {
			stack1.push(stack2.pop());
		}
	}

	public T deleteHead() {
		if (!stack1.isEmpty()) {
			return stack1.pop();
		}
		return null;
	}
}

public class Demo09 {
	public static void main(String[] args) {
		Quene<Integer> quene = new Quene<Integer>();
		// 入队测试
		for (int i = 0; i < 10; i++) {
			quene.appendTail(i);
		}
		// 出队测试
		Integer temp = null;
		while ((temp = quene.deleteHead()) != null) {
			System.out.print(temp + ", ");
		}
		// 空队出队
		System.out.println();
		System.out.println(quene.deleteHead());
	}
}

测试输出：

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 
null

思考题：用两个队列实现一个栈？
分析：其实用一个队列就可以实现一个栈，入栈的时候直接入队列，出栈的时候现将队列前面n-1个依次出队列入队列，然后将第n个出队列取出，第n个取出不在入队。

面试题10：斐波那契数列

在这里插入图片描述
分析：该题既可以用循环实现，也可以用递归实现。递归占用的内存相对较大，所以我们还是考虑用循环实现。

public class Demo10 {
	// 0 1 1 2 3 5 8 13
	public static void main(String[] args) throws Exception {
		// 测试
		for (int n = 0; n < 10; n++) {
			System.out.println("fibonacci(" + n + ") = " + fibonacci(n));
		}
		System.out.println("fibonacci(-1) = " + fibonacci(-1)); // 该行会抛出异常
	}

	private static int fibonacci(int n) throws Exception {
		int[] f = { 0, 1 };
		int fn = f[0] + f[1];
		if (n >= 2) {
			while (n-- > 1) {
				fn = f[0] + f[1];
				f[0] = f[1];
				f[1] = fn;
			}
		} else if (n >= 0) {
			return f[n];
		} else {
			throw new Exception("n < 1,输入不和法！！");
		}

		return fn;
	}
}

测试输出：

fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(2) = 1
fibonacci(3) = 2
fibonacci(4) = 3
fibonacci(5) = 5
fibonacci(6) = 8
fibonacci(7) = 13
fibonacci(8) = 21
fibonacci(9) = 34
Exception in thread "main" java.lang.Exception: n < 1,输入不和法！！
	at offer.ex10.Demo10.fibonacci(Demo10.java:34)
	at offer.ex10.Demo10.main(Demo10.java:16)

在这里插入图片描述
分析：
当n=1时，有一种跳法；
当n=2时，有两种跳法；
当n>2时，记所有跳法为f(n)，先跳1次，则可以跳1级或2级，所以有f(n) = f(n-1) + f(n-2);
该问题可以转化成题目一中的斐波拉契数列，代码略。

sixabs
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer第二版(Java最优解)---替换空格
数字成都
04-15 256
题目 　　请实现一个函数，把字符串中的每个空格替换成"%20"。例如输入“We are happy.”，则输出“We%20are%20happy.”。 回到顶部 思路 　　首先要询问面试官是新建一个字符串还是在原有的字符串上修改，本题要求在原有字符串上进行修改。 若从前往后依次替换，在每次遇到空格字符时，都需要移动后面O(n)个字符，对于含有O(n)个空格字符的字符串而言，总的时间效率为O(n2)...
剑指offer-(java版-2).pdf
03-21
剑指offer-(java版-2), 低分共享出来， 文字还比较清晰
剑指Offer（第二版）Java例题详解
qq_41866626的博客
09-22 2219
PS：《剑指offer》是很多同学找工作都会参考的一本面试指南，同时也是一本算法指南。现在很多互联网的算法面试题基本上可以在这里找到影子，为了以后方便参考与回顾，现将书中例题用Java实现（第二版），欢迎各位同学一起交流进步。 GitHub： 待整理添加。 剑指offer（第二版）Java例题详解例题顺序 例题顺序 下面是所有例题在《剑指offer》书中的页码、题目、以及题解链接。（目前已经刷过全部例题，现在需要时间整理，然后慢慢更新内容） 页码 题目顺序 题目 链接 25 1 赋值运算符函
JAVA实现 剑指offer第二版 2
Aye
04-26 305
面试题16：数值的整数次方需要考虑底数为0的情况，指数为正或负的情况；在计算次方时，应注意到4次方为2次方的2次方，可以进行递归调用减少复杂度；也要主要到double类型的比较不能直接使用==；private static boolean g_InvalidInput = false; public static void main(String[] args){ Syst...
剑指offer第二版完整java版
12-15
本人吐血亲自整理，完整版！在牛客网上完全可以运行通过，对于牛客上没有的，也有完整的整理。
《剑指Offer》题目及java代码实现
12-10
总之，《剑指Offer》通过Java语言实现了众多面试题，涵盖了编程基础、数据结构、算法、设计模式等多个方面，是提升Java程序员面试技能的宝贵资源。通过深入学习和实践，你可以提升自己的编程能力，为面试做好充分...
牛客网剑指offer——Java题解.pdf
09-07
剑指offer Java题解 本资源总结了牛客网剑指offer Java题解的关键知识点，涵盖了Java基本概念、数据结构和算法等方面的知识。 JZ1 二维数组中的查找 * 题目描述：在一个二维数组中查找指定的整数。 * 解题思路：...
《剑指Offer》学习80题java版本.zip
03-10
每个问题都可能涉及多种技术和思维方式，通过《剑指Offer》的学习，不仅可以巩固基础知识，还能提高问题解决能力。书中不仅提供了解决方案，还有对问题本质的深入剖析，有助于应聘者在面试中灵活应对各种挑战。因此...
剑指offer-Java代码_java_剑指offer_
09-30
《剑指Offer》是一本备受推崇的编程面试指南，尤其对于Java开发者来说，它提供了大量精心设计的面试题目，旨在帮助求职者提升编程技能和解决问题的能力。这本书的Java代码实现和文字说明是深入理解问题解决方案的...
【剑指 offer 第二版 】Java 代码解析（2021 03 25更新）
Josvin
12-29 1097
这里写自定义目录标题剑指 offer 03：数组中重复的数字题目描述解题思路+代码实现方法一： 排序+for循环方法二：HashSet方法三：原地交换 剑指 offer 03：数组中重复的数字 题目描述 找出数组中重复的数字。（传送门） 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。 示例 1： 输入： [2, 3, 1, 0, 2, 5, 3] 输出：2 或 3
剑指offer第二版整理的java代码
04-17
个人收集整理的剑指offer第二版java代码，每道题都命名了，有多种解法
《剑指offer第二版》JAVA代码
业精于勤荒于嬉 行成于思毁于随
10-24 1158
/** * 字符串匹配问题 */ public class Offer19 { public boolean solve(String s, String pattern) { if (s == null || pattern == null) return false; char[] sArr = s.toCharArray(); c...
剑指Offer第二版大部分题解（Java实现）
qq_41112238的博客
05-11 635
剑指Offer第二版题解 面试题03. 数组中重复的数字 找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。 示例 1： 输入： [2, 3, 1, 0, 2, 5, 3] 输出：2 或 3 思路和代码： class Solution { public int findRepeatNumber(int[] nums) {
剑指Offer（1-9Java语言描述）
ForeverSen的博客
08-14 273
很快秋招就来了，今天开始刷剑指，应该不会太慢吧，之前刷了一百道leetcode，按照tag刷的，想着这个月前把剑指刷一遍，记录下： 3.重复的数字 题目描述： 在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的...
剑指Offer-Java实现
寒沨的博客
04-07 608
2.2 编程语言 面试题2： 实现Singleton模式 /** * @ClassName: Singleton * @Description: 静态内部内 * @author hf寒沨 * @date 2019年4月7日 下午4:55:39 * */ public class Singleton { private Singleton() { } public static...
剑指offerⅡ（Java 持续更新...）
weixin_45876739的博客
07-14 401
剑指offer
《剑指offer》Java实现——每天9题——第1天
zhoucheng05_13的博客
03-02 1651
面试题1 赋值运算符函数 该题目涉及到c++语言的指针特性，java语言暂没想出解决方案。 面试题2 实现Singleton模式 设计一个类，我们只能生成该类的一个实例。 实现代码 public class LazyLoadedSingleton{ private LazyLoadedSingleton{} //private构造方法，防止外部实例化...
剑指offer_2_二进制加法(java)
最新发布
一起coding，一起嗨。
11-23 1487
计算二进制加，1+0=1 0+0=0 1+1=10，题目没有限制字符串长度，不能使用字符串转换为整数计算，会溢出；
Java版《剑指offer》面试题：单例模式与二维数组查找
"剑指offer（java版）.pdf，涵盖了Java编程语言中的面试题，包括设计模式和数组操作等主题。" 在Java编程中，单例模式是一种常用的创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。该模式在很多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值