剑指offer--java（01-10）

二维数组中的查找

题目描述：

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

8	9	12
9	11	14
23	35	46

---

思路：

利用题中所给的条件：二维数组由左到右递增，由上到下递增的规律，那么，数组的左上角元素是最小的，数组的右下角元素是最大的。还有右上角的元素它的左边都比它小，下边元素都比它大。而左下角元素，该元素上边的都比自身小，右边的都比自身大。利用此性质，我们可以选取右上角元素或者左下角元素作为参照物。这里我选取的是右上角元素，拿着右上角元素array[row][col]与target进行比较，若target小于array[row][col]时，就不需要再考虑array[row][col]所在列的所有元素了，即col–（删除该列）。若target大于array[row][col]时，一样的道理就不需要再考虑array[row][col]所在行的所有元素了，即row++（删除改行）。
以上是该题思路。

代码如下：

@skl--java
package training;

public class Solution01 {
    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;
    }
    public static void main(String[] args)
    {   
        int arrayInt[][] ={{8,9,12},{29,11,14},{23,35,46}};
        Solution01 t = new Solution01();
        if(t.Find(arrayInt, 23))
            System.out.println("true");
        else
            System.out.println("false");

    }

}

替换空格

题目描述：

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

---

思路：

首先，我们要知道字符串中有多少个空格，既从头到尾遍历字符串，统计空格数。由此计算替换之后的所需要的总长度。然后从后往前依次检查字符串，如果发现是空格则替换为%20。如果从前往后开始检查，发现有空格时需要移动后面的字符腾出位置，之后要不断向后检查一旦发现有空格还要继续后移字符（要多次移动，所以效率低下）。如果事先计算需要多少空间，从后往前检查，则每个字符只移动一次，这样效率更高。

示例：

     原来：We Are Happy 现在：We%20Are%20Happy

代码如下：

@skl--java
package training;
//以下代码所标数值仅为本例参考

public class Solution02 {
    public String replacespace(StringBuffer str)
    {
        int spacenum = 0;
        for(int i = 0;i < str.length(); i++)  //str.length()=12
        {
            if(str.charAt(i) == ' ')
                spacenum ++;               //spacenum = 2
        }
        int indexold = str.length() - 1;  //替换前的下标
        int newlength = str.length() + spacenum *2; //newlength=16
        int indexnew = newlength -1; 
        str.setLength(newlength);
        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));
                //修改指定索引处的字符，将indexnew处修改为
                str.charAt(indexold)也可理解为赋值，再进行--
            }
        }
        return str.toString();
    }
    public static void main(String [] args)
    {
        StringBuffer a = new StringBuffer("we are happy"); 
        Solution02 t =new Solution02();
        //t.replacespace(new StringBuffer("we are happy"));
        //String s = new String(); 
        //s = t.replacespace(a);
        System.out.println(t.replacespace(a));
    }
}

知识补充：

String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）

简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象（常量）, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，其指针指向了新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后，JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer对象本身进行操作。而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer， 特别是字符串对象经常改变的情况下。

从尾到头打印链表

题目描述：

输入一个链表，从尾到头打印链表每个节点的值。

---

思路：

将链表中的值从头到尾依次压入进栈，利用栈后进先出的性质从栈顶依次出栈实现了反转，同时再将出栈的元素加入新的链表，最后输出新的链表即可。

@skl--java
package training;

import java.util.List;
import java.util.ArrayList;                                        //ArrayList类是一种特殊的数组类型（动态数组）
import java.util.Stack;      

public class Solution03 {
    public static   ArrayList<Integer> printListFromTailToHead(ListNode listNode)
    {
        if(listNode == null)
            return null;
        Stack<Integer> stk = new Stack<Integer>(); 
        //定义一个栈类型 对象 stk
        while(listNode != null)
        {
            stk.push(listNode.val);  //当前节点不为空时，将其值压入进栈
            listNode = listNode.next; //节点后移一个位置继续检查
        }
        ArrayList<Integer> arr = new ArrayList<Integer>();
        while(! stk.isEmpty())
        {
            arr.add(stk.pop());                                                //ArrayList自带的添加元素方法：add(object value)，
            //判断栈顶的当前元素不为空时，出栈同时加入数组arr
        }
        return arr;
    }
    public class ListNode
    {
        int val;
        ListNode next =null;
        ListNode(int val)
        {
            this.val = val;
        }
    }
    public static void main(String[] args) 
    {  
                int[] arr = {1, 23, 12, 8, 222};  
                int i = 0;    
                Solution03  s = new Solution03();   
                ListNode listNode = s.new ListNode(arr[i++]);
                listNode.next = null;  
                ListNode p = listNode;  
              while(i < arr.length)
               { // 创建单链表  
                    ListNode tmp = s.new ListNode(arr[i++]);  
                    tmp.next = null;  
                    p.next = tmp;  
                    p = tmp;  
               }  
              List<Integer> l = printListFromTailToHead(listNode);
              for(Integer t : l)
                 {  
                     System.out.println(t);  
                 }  
         }