剑指offer 第一天

二维数组中的查找

PYTHON

class Solution:
    # array 二维列表
    def Find(self, array, target):
        # 判断数组是否为空
        if array == []:
            return False

        rawnum = len(array)
        colnum = len(array[0])

        # 判断非法输入
        # 可以换成 isinstance(target, (int, float)) 进行判断
        if type(target) == float and type(array[0][0]) == int:
            target = int(target)
        elif type(target) == int and type(array[0][0]) == float:
            target = float(int)
        elif type(target) != type(array[0][0]):     # 浮点数的相等判断问题需要特别注意, 一般都是判断两个数的差值是否小于一个特别小的数。这里不展开分析。
            return False

        i = colnum - 1
        j = 0
        while i >= 0 and j < rawnum:
            if array[j][i] < target:
                j += 1
            elif array[j][i] > target:
                i -= 1
            else:
                return True
        return False

JAVA

public class Find {
    public static boolean find(int arr[][],int keyNumber){
        int column=arr[0].length-1;
        int row=0;
        while(column>=0&&row<arr.length){
            if(arr[row][column]==keyNumber){
                return true;
            }
            else if(arr[row][column]>keyNumber){
                column--;
            }
            else {
                row++;
            }
        }
        return false;

    }
    //测试find函数
    public static void main(String[] args) {
        /*
         * 1  2  8  9
         * 2  4  9  12
         * 4  7  10 13
         * 6  8  11 15
         */
        int array[][]=new int[4][4];
        array[0][0]=1;
        array[0][1]=2;
        array[0][2]=8;
        array[0][3]=9;
        array[1][0]=2;
        array[1][1]=4;
        array[1][2]=9;
        array[1][3]=12;
        array[2][0]=4;
        array[2][1]=7;
        array[2][2]=10;
        array[2][3]=13;
        array[3][0]=6;
        array[3][1]=8;
        array[3][2]=11;
        array[3][3]=15;
        System.out.println(find(array, 7));
        System.out.println(find(array, 5));
    }

}

替换空格

# -*- coding:utf-8 -*-
class Solution:
    # s 源字符串

    # 创建新的字符串进行替换
    def replaceSpace1(self, s):
        tempstr = ''
        if type(s) != str:
            return
        for c in s:
            if c == ' ':
                tempstr += '%20'
            else:
                tempstr += c
        return tempstr

    # 简单代码替换
    # 在Python中str类型是不可变的类型, 使用replace语句会生成一个新的str, 原始的s还是带空格的str变量
    def replaceSpace2(self, s):
        if type(s) != str:
            return
        return s.replace(' ', '%20')

    # 书中给的思路
    # 判断输入类型的时候，isinstance必须首先判断，因为如果输入为integer的话，没有len，就会直接报错
    def replaceSpace3(self, s):
        if not isinstance(s,str) or len(s) <= 0 or s == None:
            return ""
        spaceNum = 0
        for i in s:
            if i == " ":
                spaceNum += 1

        newStrLen = len(s) + spaceNum * 2
        newStr = newStrLen * [None]
        indexOfOriginal, indexOfNew = len(s) - 1, newStrLen - 1
        while indexOfNew >= 0 and indexOfNew >= indexOfOriginal:
            if s[indexOfOriginal] == ' ':
                newStr[indexOfNew-2:indexOfNew+1] = ['%', '2', '0']
                indexOfNew -= 3
                indexOfOriginal -= 1
            else:
                newStr[indexOfNew] = s[indexOfOriginal]
                indexOfNew -= 1
                indexOfOriginal -= 1
        return "".join(newStr)


s = 'we are happy'
test = Solution()
print(test.replaceSpace1(s))
print(test.replaceSpace2(s))
print(test.replaceSpace3(s))

public class ReplaceBank {
    //借助StringBuffer    
    /**
     * StringBuilder是一个类，可以用来处理字符串，最简单的用法：
        StringBuilder sb=new StringBuilder();
        sb.Append("123");
        sb.Append("456");
        string str=sb.ToString();
        最后得到的str字符串的值就是"123456"，这种用法要比直接字符串相加效率高
     * @param input
     * @return
     */
    public String replace(String input){
        StringBuilder builder = new StringBuilder();
        if (input == null || input.length() ==0){
            return null;
        }
        for(int i=0;i< input.length() ; i++){
            if(input.charAt(i)==' '){
                builder.append("%");
                builder.append("2");
                builder.append("0");
            }else{
                builder.append(input.charAt(i));
            }
        }
        return builder.toString();
    }
  public String replace2(StringBuffer str){
      if (str == null) {    
          return null;    
      }    
      int blankNum = 0;    
      int length = str.length();    
      int newLength = 0;    
      for (int i = 0; i < length; i++) {    
          if (str.charAt(i) == ' ') {    
              blankNum++;    
          }    
      }    
      newLength = length + 2 * blankNum; // 替换后的字符串长度    
      char[] newChars = new char[newLength];// 新的字符数组    
      int index = newLength - 1;    
      for (int i = length - 1; i >= 0; i--) {    
          if (str.charAt(i) == ' ') {    
              newChars[index--] = '0';    
              newChars[index--] = '2';    
              newChars[index--] = '%';    
          } else {    
              newChars[index--] = str.charAt(i);    
          }    
      }    
      return new String(newChars); 
  }
    public static void main(String[] args) {
        ReplaceBank test = new ReplaceBank();
        // 输入的字符串包含空格：最后面，最前面，中间，连续空格
        String str1 = "We are happy.";
        String str2 = " We are happy.";

        StringBuffer sb = new StringBuffer(str1);
        System.out.println(test.replace2(sb));
        System.out.println(test.replace(str2));

    }
}

从尾到头打印链表

class ListNode:
    def __init__(self,x=None):
        self.val= x
        self.next = None

class Solution:
    def printListFromTailToHead(self,ListNode):
        if ListNode.val == None :
            return
        l=[]
        head = ListNode
        while head:
            l.insert(0,head.val)
            head = head.next
        return l
    def print_links(self,ListNode):
        stack=[]
        head=ListNode
        while head:
            stack.append(head.val)
            head=head.next
        while stack:
            print stack.pop()
      #递归实现有点问题。

package jianzhioffer;

import java.util.Stack;

//首先定义链表结构
class LinkNode{
    LinkNode next;
    int node_value;
}

public class print_link_recursion {
    public void reverse(LinkNode headNode){
        //用栈的思想来实现链表的倒序输出
        Stack<LinkNode> stack=new Stack<LinkNode>();
        while(headNode!=null){
            stack.push(headNode);
            headNode=headNode.next;
        }
        while(!stack.isEmpty()){
            System.out.print(stack.pop().node_value+" ");
        }
        System.out.println();
    }
   public void reverse1(LinkNode headNode){
       //递归
       if(headNode != null){
           reverse1(headNode.next);
           System.out.print(headNode.node_value+" ");
       }
   }
    /**
     * @param args
     */
    public static void main(String[] args) {
        //输入的链表有多个结点
        print_link_recursion plr=new print_link_recursion();
        LinkNode node1=new LinkNode();
        LinkNode node2=new LinkNode();
        LinkNode node3=new LinkNode();
        node1.node_value=1;
        node2.node_value=2;
        node3.node_value=3;
        node1.next=node2;
        node2.next=node3;
        plr.reverse(node1);
    }

}

重建二叉树

class TreeNode:
    def __init__(self,x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    def reConstructBinaryTree(self, pre, tin):
        if not pre and not tin:
            return None
        root = TreeNode(pre[0])
        if set(pre) != set(tin):
            return None
        i = tin.index(pre[0])
        root.left = self.reConstructBinaryTree(pre[1:i+1], tin[:i])
        root.right = self.reConstructBinaryTree(pre[i+1:], tin[i+1:])
        return root

用两个栈实现队列

class Solution:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
    def push(self,node):
        self.stack1.append(node)
    def pop(self):
        if len(self.stack2) ==0 and len(self.stack1) ==0:
            return
        elif len(self.stack2)==0:
            while(len(self.stack1) != 0 ):
                self.stack2.append(self.stack1.pop())
        return self.stack2.pop()

用两个队列实现栈

class Solution:
    def __init__(self):
        self.queue1 = []
        self.queue2 = []
    def push(self,x):
        if self.queue1 == []:
            self.queue2.append(x)
        else:
            self.queue1.append(x)
    def pop(self):
        if not self.queue1 and not self.queue2:
            return
        if self.queue1 == []:
            for i in range(len(self.queue2)-1):
                self.queue1.append(self.queue2.pop(0))
                return self.queue2.pop()
        else:
            for i in range(len(self.queue1) - 1):
                self.queue2.append(self.queue1.pop(0))
                return self.queue1.pop()