3、二维数组中的查找
题目描述 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 | 1| 2| 8|9| |-|-----| -----| | 2 | 4 | 9|12| | 4| 7| 10 |13| | 6 | 8 | 11 |15|
思路： 从右上角开始，若小，向下走，删除一行，若大，向左走，删除一列
/*
利用二维数组由上到下，由左到右递增的规律，
那么选取右上角或者左下角的元素a[row] [col]与target进行比较，
当target小于元素a[row] [col]时，那么target必定在元素a所在行的左边,
即col--；
当target大于元素a[row][col]时，那么target必定在元素a所在列的下边,
即row++；
*/
public class Solution {
public boolean Find(int [][] array,int target) {
int row=0;
int col=array[0].length-1;
while(row<=array.length-1&&col>=0){
if(target==array[row][col])
return true;
else if(target>array[row][col])
row++;
else
col--;
}
return false;
}
}
复制代码4、替换空格
题目描述 请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
思路：先遍历一遍字符，统计空格数，由此计算替换之后的总长度。然后从后往前加载字符串，如果发现空格，就替换20%
/*
问题1：替换字符串，是在原来的字符串上做替换，还是新开辟一个字符串做替换！
问题2：在当前字符串替换，怎么替换才更有效率（不考虑java里现有的replace方法）。
从前往后替换，后面的字符要不断往后移动，要多次移动，所以效率低下
从后往前，先计算需要多少空间，然后从后往前移动，则每个字符只为移动一次，这样效率更高一点。
*/
public class Solution {
public String replaceSpace(StringBuffer str) {
int spacenum = 0;//spacenum为计算空格数
for(int i=0;i<str.length();i++){
if(str.charAt(i)==' ')
spacenum++;
}
int indexold = str.length()-1; //indexold为为替换前的str下标
int newlength = str.length() + spacenum*2;//计算空格转换成%20之后的str长度
int indexnew = newlength-1;//indexold为为把空格替换为%20后的str下标
str.setLength(newlength);//使str的长度扩大到转换成%20之后的长度,防止下标越界
for(;indexold>=0 && indexold<newlength;--indexold){
if(str.charAt(indexold) == ' '){ //
str.setCharAt(indexnew--, '0');
str.setCharAt(indexnew--, '2');
str.setCharAt(indexnew--, '%');
}else{
str.setCharAt(indexnew--, str.charAt(indexold));
}
}
return str.toString();
}
}
复制代码5、从尾到头打印链表
题目描述： 输入一个链表，从尾到头打印链表每个节点的值。
思路1：栈
/**
* public class ListNode {
* int val;
* ListNode next = null;
* ListNode(int val) {
* this.val = val;
* }
* }
*/
import java.util.Stack;
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
if(listNode == null){
ArrayList list = new ArrayList();
return list;
}
Stack<Integer> stk = new Stack<Integer>();
while(listNode != null){
stk.push(listNode.val);
listNode = listNode.next;
}
ArrayList<Integer> arr = new ArrayList<Integer>();
while(!stk.isEmpty()){
arr.add(stk.pop());
}
return arr;
}
}
复制代码思路2：递归
public class Solution {
public void printListFromTailToHead(ListNode listNode) {
if(listNode != null){
if(listNode.next != null){
printListFromTailToHead(listNode.next);
}
System.out.print(""+listNode.var);
}
}
}
复制代码6、重建二叉树
题目描述：已知中序和前序，请重建二叉树
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
TreeNode root=reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
return root;
}
//前序遍历{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
private 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]){
root.left=reConstructBinaryTree(pre,startPre+1,startPre+i-startIn,in,startIn,i-1); //注意pre的位置，要用偏移量，不能用i，因为i是在变化
root.right=reConstructBinaryTree(pre,i-startIn+startPre+1,endPre,in,i+1,endIn);
}
return root;
}
}
复制代码引申：已知中序和后序求前序
package com.zhuang.tree;
public class Main {
public static class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public static TreeNode reConstructBinaryTree(int [] post,int [] in) {
TreeNode root=reConstructBinaryTree(post,0,post.length-1,in,0,in.length-1);
return root;
}
private static TreeNode reConstructBinaryTree(int [] post,int startPost,int endPost,int [] in,int startIn,int endIn) {
if(startPost>endPost||startIn>endIn)
return null;
TreeNode root=new TreeNode(post[endPost]);
for(int i=startIn;i<=endIn;i++)
if(in[i]==post[endPost]){
root.left=reConstructBinaryTree(post,startPost,startPost+i-startIn-1,in,startIn,i-1);
root.right=reConstructBinaryTree(post,startPost+i-startIn,endPost-1,in,i+1,endIn);
}
return root;
}
public static void preOrder(TreeNode root){
if(root == null){
return;
}
System.out.println(root.val);
preOrder(root.left);
preOrder(root.right);
}
public static void main(String[] args){
int[] post = {2,4,3,1,6,7,5};
int[] in = {1,2,3,4,5,6,7};
TreeNode root = reConstructBinaryTree(post, in);
preOrder(root);
}
}
复制代码7、用两个栈实现队列
题目描述 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：入栈给stack1，出栈时，若stack2不为空，则出栈，若为空，把stack1的内容全都放入stack2，然后再出栈
import java.util.Stack;
public class Solution {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
stack1.push(node);
}
public int pop() {
while(!stack2.isEmpty())
{
return stack2.pop();
}
while(!stack1.isEmpty())
{
stack2.push(stack1.pop());
}
return stack2.pop();
}
}
复制代码8、旋转数组的最小数字
题目描述 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
import java.util.ArrayList;
public class Solution {
/*
* 传进去旋转数组，注意旋转数组的特性： 1.包含两个有序序列 2.最小数一定位于第二个序列的开头 3.前序列的值都>=后序列的值
*/
// 用到了快速排序的快速定位范围的思想，
public int minNumberInRotateArray(int[] array) {
if (array == null || array.length == 0) {
return 0;
}
int low = 0;//指向第一个
int up = array.length - 1;//指向最后一个
int mid = low;
// 当low和up两个指针相邻时候，就找到了最小值，也就是
// 右边序列的第一个值
while (array[low] >= array[up]) {
if (up - low == 1) {
mid = up;
break;
}
// 如果low、up、mid下标所指的值恰巧相等
// 如：{0,1,1,1,1}的旋转数组{1,1,1,0,1}
if (array[low] == array[up] && array[mid] == array[low])
return MinInOrder(array);
mid = (low + up) / 2;
// 这种情况，array[mid]仍然在左边序列中
if (array[mid] >= array[low])
low = mid;// 注意，不能写成low=mid+1；
// 要是这种情况，array[mid]仍然在右边序列中
else if (array[mid] <= array[up])
up = mid;
}
return array[mid];
}
private int MinInOrder(int[] array) {
// TODO Auto-generated method stub
int min = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] < min) {
min = array[i];
}
}
return min;
}
}
复制代码9、斐波那契数列
题目描述 大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。
思路1：递归，简洁但效率不高
public int Fibonacci(int n) {
if(n<=0)
return 0;
if(n==1)
return 1;
return Fibonacci(n-1) + Fibonacci(n-2);
}
复制代码思路2：循环，O（N）
public class Solution {
public int Fibonacci(int n) {
int preNum=1;
int prePreNum=0;
int result=0;
if(n==0)
return 0;
if(n==1)
return 1;
for(int i=2;i<=n;i++){
result=preNum+prePreNum;
prePreNum=preNum;
preNum=result;
}
return result;
}
}
复制代码扩展1：跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路：斐波拉契数序列，初始条件n=1:只能一种方法，n=2:两种 对于第n个台阶来说，只能从n-1或者n-2的台阶跳上来，所以 F(n) = F(n-1) + F(n-2)
扩展2：变态跳台阶
题目描述 一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路： 因为n级台阶，第一步有n种跳法：跳1级、跳2级、到跳n级 跳1级，剩下n-1级，则剩下跳法是f(n-1) 跳2级，剩下n-2级，则剩下跳法是f(n-2) 所以f(n)=f(n-1)+f(n-2)+...+f(1) 因为f(n-1)=f(n-2)+f(n-3)+...+f(1) 所以f(n)=2*f(n-1) 所以f(n)=2的(n-1)次幂
public class Solution {
public int JumpFloorII(int target) {
if(target<=0)
return 0;
return 1<<(target-1);
}
}
复制代码10、二进制中1的个数
题目描述 输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
最差的解法：因为要考虑负数的问题，若是负数,因为要保证一直输负数，多以第一位一直为1，最后会变成0XFFFFFFFF,造成死循环
public class Solution {
public int NumberOf1(int n) {
int count= 0;
int flag = 1;
while (n!= 0){
if ((n & 1) != 0){
count++;
}
n = n>>1;
}
return count;
}
}
复制代码改进的解法：
public class Solution {
public int NumberOf1(int n) {
int count= 0;
int flag = 1;
while (flag != 0){
if ((n & flag) != 0){
count++;
}
flag = flag << 1;
}
return count;
}
}
复制代码最精妙的解法：
public class Solution {
public int NumberOf1(int n) {
int count = 0;
while(n!= 0){
count++;
n = n & (n - 1);//每一次将最后一个1变成0
}
return count;
}
}
复制代码声明：此文章为本人原创，如有转载，请注明出处
如果您觉得有用，欢迎关注我的公众号，我会不定期发布自己的学习笔记、AI资料、以及感悟，欢迎留言，与大家一起探索AI之路。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
