java实现剑指offer

Posted 2022-12-14 好好学习312

第二章 面试需要的基础知识

数组 - 二维数组中查找

• 题目：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

方法一

public class Solution 
    public boolean Find(int [][] array, int target) 
        for (int i=0; i<array.length; i++) 
            for (int j=0; j<array[i].length; j++) 
                if (array[i][j] == target)
                    return true;
            
        
        return false;

    

 
1
2
3
4
5
6
7
8
9
10
11
12
 
1
2
3
4
5
6
7
8
9
10
11
12

方法二

• 时间复杂度 O(n)

public class Solution 
    public boolean Find(int [][] array, int target) 
        int row =0;
        int col = array[0].length-1;
        int numRow = array.length;
        while (row < numRow && col>=0) 
            if (array[row][col] > target)
                col--;
            else if (array[row][col] < target)
                row++;
            else 
                return true; // 相等，返回true
            
        
        return false;  //遍历完，没有找到相等值，返回false
    

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

替换空格

方法一

• 借用String.replace()

public class Solution 
    public String replaceSpace(StringBuffer str) 
        String str1 = new String(str);
        return str1.replace(" ", "%20");
    

 
1
2
3
4
5
6
 
1
2
3
4
5
6

方法二

• 使用字符数组实现

public class Solution 
    public String replaceSpace(StringBuffer str) 
        String str1 = new String(str);
        char[] charArr = str1.toCharArray();
        // 计算源字符串的长度和空格的数量
        int originalLength = charArr.length;
        int numberOfBlank = 0;
        for (char item : charArr)
            if (item == ' ')
                numberOfBlank++;
        // 计算新的字符串长度
        int newLength = originalLength + numberOfBlank*2;
        char[] newcharArr = new char[newLength];
        //
        int indexOfOriginal = originalLength-1;
        int indexOfNew = newLength-1;
        while(indexOfOriginal>=0) 
            if (charArr[indexOfOriginal] == ' ') 
                newcharArr[indexOfNew--] = '0';
                newcharArr[indexOfNew--] = '2';
                newcharArr[indexOfNew--] = '%';
                indexOfOriginal--;
             else 
                newcharArr[indexOfNew--] = charArr[indexOfOriginal--];
            
        
        return String.valueOf(newcharArr);
    

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

从头到尾打印链表

import java.util.ArrayList;

class ListNode 
     int val;
     ListNode next = null;

     ListNode(int val) 
         this.val = val;
     


public class Solution 
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) 
        ArrayList<Integer> al = new ArrayList<Integer>();
        if (listNode == null) 
            return al;
        

        ListNode p = listNode;
        while (p != null) 
            al.add(p.val);
            p = p.next;
        

        int lower = 0;
        int higher =al.size()-1;
        while (lower < higher) 
            int temp = al.get(lower);
            al.set(lower, al.get(higher));
            al.set(higher, temp);
            lower++;
            higher--;
        
        return al;
    


 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

重建二叉树

import java.util.Arrays;

class TreeNode 
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x)  val = x; 


public class Solution 
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) 
        if (pre==null || in==null) // 判空
            return null;
        //生成根节点
        int rootValue = pre[0];
        TreeNode root = new TreeNode(rootValue);
        root.left = root.right = null;
        // 一个节点的情况
        if (pre.length==1) 
            if (in.length==1 && pre[0]==in[0]) 
                return root;
            else
                System.out.println("Invalid  input.");
        
        // 在中序遍历中查找根节点的值
        int rootInorder =0;
        while (rootInorder<in.length && in[rootInorder]!=rootValue)
            rootInorder++;
        // 构建左子树
        int[] leftPre = Arrays.copyOfRange(pre, 1, rootInorder+1);
        int[] leftIn = Arrays.copyOfRange(in, 0, rootInorder);
        if (leftPre.length>0) 
            root.left = reConstructBinaryTree(leftPre, leftIn);
        
        // 构建右子树
        int[] rightPre = Arrays.copyOfRange(pre, rootInorder+1, pre.length);
        int[] rightIn = Arrays.copyOfRange(in, rootInorder+1, in.length);
        if (rightPre.length>0) 
            root.right = reConstructBinaryTree(rightPre, rightIn);
        
        return root;
    


 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

用两个栈实现队列

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() 
        if (stack2.isEmpty()) 
            while (!stack1.isEmpty()) 
                stack2.push(stack1.pop());
            
        
        if (stack2.isEmpty()) 
            Exception e = new Exception("123");
            try 
                throw e;
             catch (Exception e1) 
                // TODO Auto-generated catch block
                e1.printStackTrace();
            
        

        return stack2.pop();
    

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

旋转数组的最小值

import java.util.ArrayList;

public class Solution 
    public int minNumberInRotateArray(int [] array) 
        if (array.length == 0)
            return 0;
        int index1 = 0;
        int index2 = array.length-1;
        int indexMid = index1;
        while (array[index1] >= array[index2]) 
            if (index2-index1==1) 
                indexMid = index2;
                break;
            
            indexMid = (index1+index2)/2;
            if(array[indexMid] >= array[index1])
                index1 = indexMid;
            else if (array[indexMid] <= array[index2])
                index2 = indexMid;
        
        return array[indexMid];

    

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

斐波那契数列

public class Solution 
    public int Fibonacci(int n) 
        if (n<=0)
            return 0;
 
以上是关于java实现剑指offer的主要内容，如果未能解决你的问题，请参考以下文章
 
 LeetCode（剑指 Offer）- 61. 扑克牌中的顺子
 剑指OFFER 扑克牌顺子
 剑指offer(三十)之扑克牌顺子
 剑指offer-扑克牌顺子-知识迁移能力-python
 剑指offer扑克牌顺子
 #yyds干货盘点#剑指 Offer 61. 扑克牌中的顺子