第一题/**在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。
* 请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
* Created by gentl on 2017/9/18.
*/
public class T1_cankao {
/*两种思路
一种是：
把每一行看成有序递增的数组，
利用二分查找，
通过遍历每一行得到答案，
时间复杂度是nlogn*/
public class Solution {
public boolean Find(int [][] array,int target) {
for(int i=0;i<array.length;i++){
int low=0;
int high=array[i].length-1;
while(low<=high){
int mid=(low+high)/2;
if(target>array[i][mid])
low=mid+1;
else if(target<array[i][mid])
high=mid-1;
else
return true;
}
}
return false;
}
}
/* 另外一种思路是：
利用二维数组由上到下，由左到右递增的规律，
那么选取右上角或者左下角的元素a[row][col]与target进行比较，
当target小于元素a[row][col]时，那么target必定在元素a所在行的左边,
即col--；
当target大于元素a[row][col]时，那么target必定在元素a所在列的下边,
即row++；*/
public class Solution2 {
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 class Solution3 {
public boolean Find(int [][] array,int target) {
int len = array.length-1;
int i = 0;
while((len >= 0)&& (i < array[0].length)){
if(array[len][i] > target){
len--;
}else if(array[len][i] < target){
i++;
}else{
return true;
}
}
return false;
}
}
}第二题/**
* Created by gentl on 2017/9/18.
* 请实现一个函数，将一个字符串中的空格替换成“%20”。
* 例如，当字符串为We Are Happy.
* 则经过替换之后的字符串为We%20Are%20Happy。
*/
public class T2 {
public String replaceSpace(StringBuffer str) {
for (int i=0;i<str.length();i++){
if(str.charAt(i)==' '){
str.deleteCharAt(i);
str.insert(i,"%20");
}
}
return str.toString();
}
}
第三题import java.util.ArrayList;
import java.util.Stack;
/**
* Created by gentl on 2017/9/18.
* 输入一个链表，从尾到头打印链表每个节点的值。
*/
class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
public class T3 {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> al=new ArrayList<>();
Stack<Integer> st=new Stack<>();
while (!listNode.equals(null)){
//System.out.print(listNode.val+" ");
st.push(listNode.val);
//al.add(listNode.val);
listNode=listNode.next;
}
while(!st.isEmpty()){
al.add(st.peek());
st.pop();
}
return al;
}
}
第四题/**
* Created by gentl on 2017/9/18.
*/
/*
*输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
* 假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
* 例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，
* 则重建二叉树并返回。
*/
//Definition for binary tree
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public class T4 {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
TreeNode root=reConstruct(pre,0,pre.length-1,in,0,in.length-1);
return root;
}
public TreeNode reConstruct(int[] pre,int startPre,int endPre,int[]in,int startIn,int endIn){
if(startPre>endPre||startIn>endIn){
return null;
}
TreeNode root=new TreeNode(pre[startPre]);
for (int i=startIn;i<=endIn;i++){
if(in[i]==pre[startPre]){
root.left=reConstruct(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
root.right=reConstruct(pre,startPre+i-startIn+1,endPre,in,i+1,endIn);
}
}
return root;
}
}
第五题
import java.util.Stack;
/**
* Created by gentl on 2017/9/18.
* 用两个栈来实现一个队列，完成队列的Push和Pop操作。
* 队列中的元素为int类型。
*/
public class T5 {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
stack1.push(node);
}
public int pop() {
if(stack2.empty()){
while(!stack1.empty()){
stack2.push(stack1.pop());
}
}
if (!stack2.empty()){
return stack2.pop();
}else return -1;
}
}
第六题
/**
* Created by gentl on 2017/9/18.
* 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
* 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
* 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
* NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
*/
public static int minNumberInRotateArray(int[] array) {
if (array.length == 0)
return 0;
int left = 0;
int right = array.length - 1;
int middle = -1;
while (array[left]>=array[right]) {
if(right-left==1){
middle = right;
break;
}
middle = left + (right - left) / 2;
if (array[middle] >= array[left]) {
left = middle;
}
if (array[middle] <= array[right]) {
right = middle;
}
}
return array[middle];
}