二维数组中的查找
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()