Java算法问题学习笔记（二）（二维数组查询，字符串空格、链表反向输出、两栈模拟队列、旋转数组问题）

一、顺序二维数组查询问题

Q:在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

A:分析如下：以一个符合要求的二维数组为例，int[][] array={{1,2,3},{4,5,6},{7,8,9}}

                      

根据二维数组的行列分别递增规则，选取右上角元素为标的，与目标数字进行比较，在行数和列数不超过数组范围的前提下，若数组元素大于目标数，则列数减一；若数组元素小于目标数，则行数加一。

代码如下：

public class FindNumberInSecondDimension {
    public static void main(String[] args) {
        int[][] arr={{1,2,3},{4,5,6},{7,8,9}};
        FindNumberInSecondDimension findNumberInSecondDimension = new FindNumberInSecondDimension();
        System.out.println(findNumberInSecondDimension.isInArray(5,arr));
        System.out.println(findNumberInSecondDimension.isInArray(10,arr));
    }
    public boolean isInArray(int target,int[][] array){
        int row=array.length-1;
        int column=array[0].length-1;
        int i=0,j=column;
        if(row==0||column==0)
            return false;
        if(target<array[0][0]||target>array[row][column])
            return false;
        while(i<=row&&j>=0){
            if(target<array[i][j]){
                j--;
            }else if(target>array[i][j]){
                i++;
            }else if(target==array[i][j]){
                return true;
            }
        }
        return false;
    }
}

程序输出如下：

true
false

二、字符串替换空格问题

Q:请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

A:分析：创建StringBuffer，遍历字符串，对比每一个字符是否为空格，若非空格，StringBuffer添加该字符，若是空格，添加替换后的值即可。

代码如下：

public class ReplaceSpace {
    public static void main(String[] args) {
        String str="We Are Happy";
        replaceSpace(str);
    }
    public static void replaceSpace(String str){
        StringBuffer strBuffer=new StringBuffer();
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)==' ')
                strBuffer.append("%20");
            else
                strBuffer.append(str.charAt(i));
        }
        System.out.println(strBuffer.toString());
    }
}

程序输出结果如下：

We%20Are%20Happy

三、反向链表输出问题

Q:输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

A:分析：可通过借助栈(Stack)的后进先出特性或创建另一个ArrayList用于反向遍历存储返回结果两种方式实现。以第一种方式为例，代码如下：

import java.util.ArrayList;
import java.util.Stack;

public class PrintListFromTailToHead {
    public static void main(String[] args) {
        ListNode listNode1=new ListNode(1);
        ListNode listNode2=new ListNode(2);
        ListNode listNode3=new ListNode(3);
        listNode1.next=listNode2;
        listNode2.next=listNode3;
        System.out.println(printListFromTailToHead(listNode1));
    }

    public static class ListNode{
        int val;
        ListNode next=null;

        ListNode(int val){
            this.val=val;
        }
    }

    public static ArrayList<Integer> printListFromTailToHead(ListNode listNode){
        ArrayList<Integer> arrayList=new ArrayList<>();
        Stack<Integer> stack=new Stack<>();//利用栈后进先出特性，创建一个栈保存遍历值
        while(listNode!=null){
            stack.push(listNode.val);
            listNode=listNode.next;
        }
        while(!stack.isEmpty()){
            arrayList.add(stack.pop());//遍历出栈元素并添加到arrayList中
        }
        return arrayList;
    }
}

程序输出结果如下：

[3, 2, 1]

 四、两栈实现队列问题

Q:用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

A:分析：栈的特征：后进先出，即先push的元素最后一次pop的时候出栈。

               队列特征：先进先出，即先push的元素第一次pop的时候出队列。

因此，将第一个栈用于正常存储，另一个栈用于pop时的中转，即pop方法执行时，先判断中转栈是否为空（该步骤不可缺少，因为若不为空而直接将第一个栈中的元素压入中转栈，会导致整体顺序混乱，如先压入1,2，输出1，再压入3,4，则下一次输出判断时中转栈中的元素为3,4,2），如果不为空则直接执行中转栈pop，若为空，则需要将第一个栈中的所有元素均压入到中转栈以保证反向出栈顺序，然后中转栈出栈。

代码如下：

import java.util.Stack;

public class StackMakeQueue {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();

    public void push(int node) {
        stack1.push(node);
    }

    public int pop() {
        Integer node = null;
        if(!stack2.isEmpty()){
            node=stack2.pop();
        }else if(!stack1.isEmpty()){
            while (!stack1.isEmpty()){
                node=stack1.pop();
                stack2.push(node);
            }
            node=stack2.pop();
        }
        return node;
    }
}

五、旋转数组最小值问题

Q:把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

A:分析：根据旋转数组定义及数组非递减特性可知，以旋转后数组第一个元素为标的，若数组元素非全部相等，则在旋转起始点必然存在这样一个临界点满足一下两点中的一点：1.临界点左侧元素大于等于标的且右侧元素小于标的（此条件满足特殊情况如{5,5,5,1,2,3}）；2.临界点左侧元素大于标的且右侧元素小于等于标的（此条件满足特殊情况如{5,6,7,5,5,5}）。取该临界点右侧元素输出即可。

注：全部相等情况下遍历后返回结果仍为起始标的。

代码如下：

public class MinNumberInRotateArray {
    public static void main(String[] args) {
        int[] array={2,3,4,5,1,2,2};
        System.out.println(minNumberInRotateArray(array));
    }
    public static int minNumberInRotateArray(int [] array) {
        if(array.length==0)
            return 0;
        int minNumber=array[0];
        for(int i=0;i<array.length-1;i++){
            if((array[i]>=minNumber&&array[i+1]<minNumber)||(array[i]>minNumber&&array[i+1]<=minNumber)){
                return array[i+1];
            }
        }
        return minNumber;
    }
}

程序输出结果如下：

1