目录
剑指offer03——二维数组中的查找
【思路】：
有以下规律：首先选取数组中右上角的数字。
如果该数字等于要查找的数字，查找过程结束；
如果该数字大于要查找的数字，剔除这个数字所在的列；
如果该数字小于要查找的数字，剔除这个数字所在的行；
也就是说如果要查找的数字不在数组的右上角，则每一次都在数组的查找范围中剔除一行或者一列，这样每一步可以缩小查找的范围，知道找到要查找的数字，或者查找范围为空。
【java 实现】
/**
* 《剑指offer03——二维数组中的查找》》
* 题目描述：
* 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列
* 都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个
* 二维数组和一个整数，判断数组中是否含有该整数。
* @param array
* @param target
* @return
*/
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;
}剑指offer04——替换空格
【java 实现】
/**
* 《剑指offer04——替换空格》
* 题目描述：
* 请实现一个函数，将一个字符串中的空格替换成“%20”。
* 例如，当字符串为We Are Happy.则经过替换之后的
* 字符串为We%20Are%20Happy。
* @param str
* @return
*/
public String replaceSpace(StringBuffer str) {
int strLen = str.length();
StringBuffer newStr = new StringBuffer();
for(int i=0;i<strLen;i++){
char ch = str.charAt(i);
if(ch != ' '){ //判断是否为空字符
newStr.append(ch);
}
else
newStr.append("%20");
}
return newStr.toString();
}
剑指offer05——从尾到头打印链表
【java 实现】
/**
* 《剑指offer05——从尾到头打印链表》
* 题目描述：
* 输入一个链表，从尾到头打印链表每个节点的值
* @param listNode
* @return
*/
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> printList = new ArrayList<Integer>();
while(listNode!=null){
Integer listVal= listNode.val;
printList.add(0, listVal);
listNode = listNode.next;
}
return printList;
}剑指offer06——重建二叉树
【java 实现】
/**
* 《剑指offer06——重建二叉树》
* 题目描述:
* 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
* 假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
* 例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列
* {4,7,2,1,5,3,8,6}，则重建二叉树并返回
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
* @param pre
* @param in
* @return
*/
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
//int preLength = pre.length; //先序遍历的节点长度
int inLength = in.length; //中序遍历的节点长度
if(inLength >0){ //即不为空的时候
int Flag=0;
for(int i=0;i<inLength;i++){
if(in[i]!=pre[0]){
Flag++;
}
else
break;
}
//初始化左子树的先序序列
int[] lpre = new int [Flag];
//初始化左子树的中序序列
int[] lin = new int [Flag];
//初始化右子树的先序序列
int[] rpre = new int [inLength-Flag-1];
//初始化右子树的中序序列
int[] rin = new int [inLength-Flag-1];
for(int i=0;i<Flag;i++){
lpre[i]=pre[i+1];
lin[i]=in[i];
}
for(int i=Flag+1,j=0;i<inLength;i++,j++){
rpre[j]=pre[i];
rin[j]=in[i];
}
TreeNode bTree = new TreeNode(pre[0]);
bTree.left=reConstructBinaryTree(lpre,lin);
bTree.right=reConstructBinaryTree(rpre,rin);
return bTree;
}
else
return null;
}剑指offer07——用两个栈实现队列
【java 实现】
/**
*《剑指offer07——用两个栈实现队列》
*题目描述：
*用两个栈来实现一个队列，完成队列的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 node) { //存入stack1中
stack1.push(node);
}
public int pop() {
if(stack2.isEmpty()){
while(!stack1.isEmpty()){
//将stack1中的数据全部放到stack2中
stack2.push(stack1.pop());
}
}
int result = stack2.pop(); //取出要POP的那个数
/*while(!stack2.isEmpty()){ //将其余的数再次存储到stack1中
stack1.push(stack2.pop());
}*/
System.out.print(result);
return result;
}
}剑指offer08——旋转数组的最小数字
【java 实现】
/**
* 《剑指offer08——旋转数组的最小数字》
* 题目描述:
* 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
* 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
* 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
* NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
* @param array
* @return
*/
public int minNumberInRotateArray(int [] array) {
int result=0;
if(array.length>0){
for(int i=0;i<array.length;i++){
//出现靠后的数组的值小于靠前的，则必然为要输出的数字
if(array[i]>array[i+1]){
result = array[i+1];
break;
}
}
}
else{
return 0;
}
return result;
}剑指offer09——斐波那契数列
【java 实现】
/**
* 斐波那契数列：输入参数N 输出第N项 F(0)=0，F(1)=1, F(n)=F(n-
* 1)+F(n-2)
* @param n
* @return
*/
/**
* 斐波那契数列：
* 第一种方法：递归
*/
public static int Fibonacci(int n){
if(n == 0){
return 0;
}
else if(n == 1){
return 1;
}
else{
return Fibonacci(n-1)+Fibonacci(n-2);
}
}
/**
* 斐波那契数列：
* 第二种方法：
*/
public static int Fibonacci2(int n) {
int fn1 = 1; //记录相加的第一项
int fn2 = 1; //记录相加的第二项
if(n <= 0 ) {
return 0;
}
if(n==1 || n==2) {
return 1;
}
while(n>2) {
fn1 += fn2;
fn2 = fn1-fn2;
n--;
}
return fn1;
}剑指offer10——二进制中1的个数
【java 实现】
解法一：
/**
* 第一种解法
* 思想：用整数N与1按位与运算，如果结果为1，说明该位为1，否则为零，然
* 后再将1左移1位。这种方法
* 要将flag=1左移32(int整数32位）次
* @param n
* @return
*/
public static int NumberOf1(int n) {
int count =0;
int flag = 1;
while(flag !=0){
if((n & flag)!=0){
count++;
}
flag = flag << 1;
}
System.out.println("数字"+n+"中1的个数为"+count);
return count;
}解法二：
/**
* 第二种解法(最优解)
* 思想:用 n=(n-1) & n 检测数中一共有几个1。用这种方法可以将整数N的
* 二进制数的第一个1变成零，因此有几个1便会循环几次
* @param n
* @return
*/
public static int NumberOf2(int n) {
int count =0;
while(n !=0){
count++;
n = (n-1) & n;
}
System.out.println("数字"+n+"中1的个数为"+count);
return count;
}剑指offer11——数值的整数次方
【java实现】
解法一：
/**
* 给定一个double类型的浮点数base和int类型的整数exponent。求base
* 的exponent次方
* @param args
*/
public static double Power(double base,int exponent){
double solution = 1.0;
if(exponent >= 0){
while(exponent !=0){
solution *= base;
exponent--;
}
return solution;
}
else{
exponent = -exponent;
if(equal(base,0.0)){ //double类型判断相等时不能用“==”
throw new RuntimeException("0不能出现负次幂！");
}
while(exponent !=0){
solution *= base;
exponent--;
}
return 1/solution;
}
}
public static boolean equal(double num1,double num2){
if((num1 - num2 > -0.0000001) && (num1 - num2 < 0.0000001)){
return true;
}
else
return false;
}解法二：
/**
* 二分快速幂解法
* 1.全面考察指数的正负、底数是否为零等情况。
* 2.写出指数的二进制表达，例如13表达为二进制1101。
* 3.举例:10^1101 = 10^0001*10^0100*10^1000。
* 4.通过&1和>>1来逐位读取1101，为1时将该位代表的乘数累乘到最终结果。
*/
public static double Power2(double base, int n){
double res = 1,curr = base;
int exponent;
if(n>0){
exponent = n;
}else if(n<0){
if(base==0)
throw new RuntimeException("分母不能为0");
exponent = -n;
}else{// n==0
return 1;// 0的0次方
}
while(exponent!=0){
if((exponent&1)==1) //该二进制位为1，则结果res乘以curr当前值
res*=curr;
exponent>>=1;// 右移一位
curr*=curr;// 右移1位则，底数base翻倍，即curr^2
}
return n>=0?res:(1/res);
}
剑指offer12——打印1到最大的n位数
【java 实现】
/**
* 《《剑指offer——12》》
* 打印1到最大的n位数
* 思路：考虑大数问题。这里有两种解决方案，一种使用字符串表示表达大
* 数，另一种是用数组表示大数
* @param args
*/
public static void print1ToMaxOfNDigits(int n){
//用字符数组表示大数
char[] number = new char[n];
//字符数组每一位置为‘0’
for(int i=0;i<number.length;i++)
number[i] = '0';
while(!addOne(number)){ //如果没有溢出
String result="";
for(int i =0;i<number.length;i++){
result += number[i];
}
System.out.println(result);
}
if(n<=0) //当n小于等于0时
return;
return;
}
public static boolean addOne(char[] number){
boolean isOverFlow = false; //设置判断是否溢出位
int flag = 1; //加法进位
char[] base = {'0','1','2','3','4','5','6','7','8','9'};
for(int i = number.length-1;i>=0;i--){
if(((number[i]- '0')+flag)>=10){
if(i == 0){ //最高位溢出
isOverFlow = true;
}
number[i] = '0';
}
else{
int num =0;
num =(number[i]- '0') + 1;
number[i] = base[num];
flag = 0;
break;
}
}
return isOverFlow;
}剑指offer14——调整数组顺序使奇数位于偶数前面
【java 实现】
解法一：
/**
* 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，
* 使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，
* 并保证奇数和奇数，偶数和偶数之间的相对位置不变。
* @param array
*/
public static void reOrderArray(int [] array){
//array[0]=4;
int length = array.length;
int[] newArray = new int[length];
int j=0;
for(int i=0;i<length;i++){
if((array[i] & 0x1) == 1){ //为奇数
newArray[j] = array[i];
j++;
}
}
for(int i=0;i<length;i++){
if((array[i] & 0x1) == 0){
newArray[j] = array[i];
j++;
}
}
for(int i=0;i<newArray.length;i++){
array[i]=newArray[i];
}
return;
}解法二：
/**
* 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，
* 使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，
* 并保证奇数和奇数，偶数和偶数之间的相对位置不变。
* @param array
*/
public void reOrderArray2(int [] array){
for(int i= 0;i<array.length-1;i++){
for(int j=0;j<array.length-1-i;j++){
if(array[j]%2==0 && array[j+1]%2==1){
int t = array[j];
array[j]=array[j+1];
array[j+1]=t;
}
}
}
}剑指offer15——链表中倒数第k个节点
【java 实现】
/**
* 《《剑指offer15——链表中倒数第k个节点》》
* 题目描述
* 输入一个链表，输出该链表中倒数第k个结点。
* @param args
*/
/*public static class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public static ListNode FindKthToTail(ListNode head,int k){
if(head == null || k<0)
return null;
ListNode firstHead = head;
ListNode lastHead = head;
while(k>0){ //当第一个指针遍历了K个节点后
if(firstHead == null) //当K值大于链表长度时
return null;
firstHead = firstHead.next;
k--;
}
while(firstHead != null){
firstHead = firstHead.next;
lastHead = lastHead.next;
}
return lastHead;
}【Python 实现】
-*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def FindKthToTail(self, head, k):
# write code here
if(head == None or k < 0):
return
firstHead = head
lastHead = head
while k > 0:
if firstHead == None:
return
firstHead = firstHead.next
k -=1
while firstHead != None:
firstHead = firstHead.next
lastHead = lastHead.next
return lastHead
剑指offer24——二叉搜索树的后序遍历序列
【java 实现】
/**
* 《《剑指offer24——二叉搜索树的后序遍历序列》》
* Description:
* 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。
* 如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互
* 不相同。
* 思路：二叉搜索树即为二叉排序树，其特点是：左子树的值小于等于根
* 节点的值并且根节点值小于等于右子树值。
* 因此，在后序遍历得到的序列中，最后一个数字是树的根节点的值。
* 数组中前面的数字可以分为两部分：
* 第一部分是根节点左子树节点的值，他们都比根节点小；
* 第二部分是根节点右子树节点的值，都比根节点大。
* 如此递归循环判断，便可以确定该序列是否是二叉排序树的后序遍历序列
* @param sequence 后序遍历序列
* @param start 数组起始下标
* @param end 数组终止下标
*/
public boolean VerifySquenceOfBST(int [] sequence) {
int start=0,end = sequence.length-1;
return VerifySquenceOfBST(sequence,start,end);
}
public boolean VerifySquenceOfBST(int [] sequence,int start,int end){
int k=start;// 记录当前遍历到的位置
if(start > end || sequence ==null)
return false;
if(start == end) //序列只剩一个元素
return true;
//将序列值小于根节点值的一段序列全部存入leftNode，直到碰到第一个大于根节点值的序列节点出现为止
for(int i=start;i<=end;i++,k++){
if(sequence[i] >= sequence[end])
break;
}
//判断左子树是否为后序遍历序列
boolean leftIsBST=true;
if(k>start)
leftIsBST = VerifySquenceOfBST(sequence,start,k-1);
for(int i=k;i<=end;i++){ //判断是否为右子树序列
if(sequence[i] < sequence[end])
return false;
}
//判断右子树是否为后序遍历序列
boolean rightIsBST = true;
if(k<end-1)
rightIsBST = VerifySquenceOfBST(sequence,k,end-1);
//最终判断如果左右子树都为后序序列，则该序列一定符合条件
return(leftIsBST && rightIsBST);
}剑指offer29——数组中出现次数超过一半的数字
解法一：
【思路】：
如果数组排序，则出现次数超过数组长度一半的数字一定会出现在数组的中间位置，因此利用快速排序一趟归位一个元素的思想，我们只需要找到数组中间的那个数，并且判断它的出现次数是否满足就可以了。
public class Solution {
/**
* 《《数组中出现次数超过一半的数字-——解法一》》
* @param array
*/
public static int MoreThanHalfNum_Solution(int [] array) {
//判断边界条件
if(array == null || array.length<=0)
return 0;
//根据快速排序一趟归位一个元素的思想，确定数组的中间元素
int midOfNum = getMiddleNumOfArray(array,0,array.length-1,array.length/2);
//获取中间元素的出现次数是否超过一半
boolean isMoreThanHalf = checkMoreThanHalf(midOfNum,array);
if(isMoreThanHalf)
return midOfNum;
else
return 0;
}
/**
* 获取数组排序后的中位数
* @param array 数组
* @param start 数组开始下标
* @param end 数组结束下标
* @param middle 中间坐标
*/
public static int getMiddleNumOfArray(int[] array,int start,int end,int middle){
int i=start,j=end;
if(start<end){
int temp = array[start];
while(i!=j){
while(i<j && array[j]>=temp)
j--;
array[i]=array[j];
while(i<j && array[i]<=temp)
i++;
array[j]=array[i];
}
array[i]=temp;
}
//判断i是否为数组中位数
if(i==middle)
return array[i];
else if(i<middle){
return getMiddleNumOfArray(array, i+1, end, middle);
}else{
return getMiddleNumOfArray(array, start, i-1, middle);
}
}
/**
* 判断该数字是否在数组中出现的次数超过一半
* @return
*/
public static boolean checkMoreThanHalf(int middleOfNum,int[] array){
int count=0;
for(int i=0;i<array.length;i++){
if(array[i]==middleOfNum)
count++;
}
if(count > array.length/2)
return true;
else
return false;
}
} 解法二：
【思路】：
在遍历数组的时候保存两个值：一个是数组中的一个数字，一个是次数。当我们遍历到下一个数字的时候，如果下一个数字和我们之前保存的数字相同，则次数加1；如果不相同,则次数减1；如果次数为0，则需要将下一个数字保存，并把次数设为1.则最终保存的数字即为所求
public class Solution {
/**
* 《《数组中出现次数超过一半的数字-——解法二》》
* @param array
*/
public static int MoreThanHalfNum_Solution(int [] array){
//判断边界条件
if(array == null || array.length<=0)
return 0;
// 结果保存在result,次数设为0
int result=array[0],count=1;
for(int i=0;i<array.length-1;i++){
if(array[i+1] == array[i]){
count++;
}else if(count>0){
count--;
}else {
result=array[i+1];
}
}
//判断是否符合要求
boolean isMoreThanHalf = checkMoreThanHalf(result,array);
if(isMoreThanHalf)
return result;
else
return 0;
}
/**
* 判断该数字是否在数组中出现的次数超过一半
* @return
*/
public static boolean checkMoreThanHalf(int middleOfNum,int[] array){
int count=0;
for(int i=0;i<array.length;i++){
if(array[i]==middleOfNum)
count++;
}
if(count > array.length/2)
return true;
else
return false;
}
}
180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
