剑指Offer(一)

一、前言

从本章开始,从来没有看过算法的我要开始刷题啦,加油.

二、题目

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

public static boolean findNumber(int target, int[][] arr){
    int row = 0;
    int col = arr[0].length -1;
    while (row < arr.length  && col >= 0){
        if (target < arr[row][col]){
            col-- ;
        }else if(target > arr[row][col]){
            row++;
        }else {
            return true;
        }
    }
    return false;
}

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

• 思路：首先判断是否有空格：无则直接返回字符串，
  然后判断是否有多个空格：有则循环替换
  主要涉及到两个重点方法 indexOf()和replacce(startIndex,endIndex,String)的使用
  indexOf()是返回当前字符串的索引
  replacce(startIndex,endIndex,String):替换指定位置的字符串

public static String replaceSpace(StringBuffer str){
    //由于StringBuffer没有判断空格的方法，所以先转为字符串
    String result = str.toString();
    if (result.contains(" ")){
        //如果有多个空格,循环替换
        while (str.indexOf(" ") != str.lastIndexOf(" ")){
            int index = str.indexOf(" ");
            str.replace(index,index+1,"%20");
        }
        //如果只有一个空格，则单一替换即可
        int index = str.indexOf(" ");
        str.replace(index,index+1,"%20");
        result = str.toString();
    }else {
        return result;
    }
    return result;
}

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

• 思路：由于链表是先进先出的，要想打印从尾到头的list，可以借助栈，它是先进后出的

static class ListNode{
    //属性值
    int val;
    //下一个元素
    ListNode next = null;
    //构造函数
    ListNode(int val){
        this.val = val;
    }
}
public static ArrayList<Integer> printListFromTailToHead(ListNode listNode){
    //1.创建一个栈堆
    Stack<Integer> stack = new Stack<Integer>();
    //如果链表不为空，则将链表元素加入到栈堆中
    while (listNode != null){
        stack.push(listNode.val);
        listNode = listNode.next;
    }

    //2.创建一个ArrayList
    ArrayList<Integer> list  = new ArrayList<Integer>();
    //如果栈堆不为空，则将元素一一加入到list中
    if (!stack.empty()) {
        list.add(stack.pop());
    }
    return list;
}

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

import java.util.Stack;  
   
public class Solution {  
   Stack<Integer> stack1 = new Stack<Integer>();  //当做主队列
   Stack<Integer> stack2 = new Stack<Integer>();  //当做辅助
     
//入栈函数  
   public void push(int num) {  
       stack1.push(num);    //直接用栈的push方法       
    }  
     
//出栈函数  
   public int pop() {  
   Integer result = null;   
       if(!stack2.empty()){  // 如果栈2不是空的，那么把最上面那个取出来  
           result = stack2.pop();   
       }else{   
               //如果栈2是空的，就把栈1里的数一个个取出来，放到栈2里  
           while(!stack1.empty()){     
                result = stack1.pop();   
                stack2.push(result);   
                             }   
                  //栈2里有数之后，再次把里面的数取出来  
                  if(!stack2.empty()){   
                         result = stack2.pop();   
                   }   
       }   
       return result;   
    }  
}