面试题11：数值的整数次方

思路1：考虑要全面，负数怎么办？是0怎么办？

public class NumberPowerN {public static double manageResult(double number,int n) throws Exception {//      底数为0且指数为负数时if (equal(number,0.0) && n < 0) throw new Exception("非法输入！");
//      指数为0时if (n == 0) return 1.0;
//      底数为负数时boolean isFuShu = false;if (number < 0) {isFuShu = true;number = -number;}double result = getNumberPowerN(number,n);if (isFuShu) result = - 1.0/result;return result;}public static double getNumberPowerN1(double number,int n){//思路1double result = 1.0;for (int i = 0; i < n; i++){result *= number;}return result;}
//  浮点数的比较public static boolean equal(double num1,double num2){if ((num1 - num2 > -0.0000001) && (num1 - num2 < 0.0000001)) return true;else return false;}public static void main(String[] args) {try {System.out.println(manageResult(-2,3));} catch (Exception e) {e.printStackTrace();}}
}

思路2：使用公式

    public static double getNumberPowerN2(double number,int n){//思路2if (n == 0) return 1;if (n == 1) return number;double result = getNumberPowerN2(number,n>>1);result *= result;if ((n & 0x1) != 0) result *= number;return result;}

面试题12：打印1到最大的n位数

输入3，输出1,2,3...999

思路：n不知道到底有多大，先求出最大值再循环输出的话很可能会溢出，所以应该使用字符串来表示大数

public class PrintNumbers {public static void print(int n){if (n <= 0) return;char[] number = new char[n];
//      初始化数组for (int i = 0; i < n; i++){number[i] = '0';}for (int i = 0 ; i < 10; i++){number[0] = (char) (i + '0');print1ToMaxOfIndexRecursively(number,n,0);}}private static void print1ToMaxOfIndexRecursively(char[] number, int n, int index) {if (index == n - 1){PrintNumber(number);return;}for (int i = 0 ; i < 10; i++){number[index + 1] = (char) (i + '0');print1ToMaxOfIndexRecursively(number,n,index + 1);}}private static void PrintNumber(char[] number) {for (int i = 0; i < number.length; i++){if ('0' != number[i]){for (int j = i; j < number.length; j++){System.out.print(number[j]);}break;}}System.out.println();}public static void main(String[] args) {print(3);}
}

面试题13：在O(1)时间删除单向链表的节点

给定单向链表的头节点和一个非头结点的节点，定义一个函数在O(1)时间删除该节点

思路：一开始可能想直接遍历节点，但是会花费O(n)的时间，我们可以直接找到要删除的那个节点的后一个节点并将其复制到要删除的节点上去。

class Node{int value;Node next;public Node() {}public Node(int value) {this.value = value;}@Overridepublic String toString() {return "Node{" +"value=" + value +", next=" + next +'}';}
}
public class DeleteNodeByO1 {public static Node deleteNodeByO1(Node head,Node target){if (head == null || target == null) return head;
//      要删除的和头结点一样if (head == target) return null;
//      要删除的是尾部的元素else if (target.next == null){Node current = head;while (current.next != null){if (current.next == target){current.next = null;return head;}current = current.next;}}
//      其他情况else{Node targetNext = target.next;target.value = targetNext.value;target.next = targetNext.next;}return head;}public static void main(String[] args) {Node node = new Node(1);Node node1 = new Node(2);node.next = node1;Node node2 = new Node(3);node1.next = node2;Node node3 = new Node(4);node2.next = node3;Node node4 = new Node( 5);node3.next = node4;System.out.println(deleteNodeByO1(node,node3));}
}

面试题14：调整数组顺序使奇数位于偶数前面

思路：使用两个下标，一个指向第一个元素，第二个指向最后一个元素，如果第一个是偶数且第二个是奇数，则交换位置，否则调整下标的位置

import java.util.Arrays;public class OddNumberBeforeEvenNumberAfter {public static int[] letOddNumberEvenNumber(int[] array){int len = array.length;if (len == 0 || len == 1) return array;for (int i = 0, j = len - 1; i < j;){if ((array[i] & 0x1) == 1) i++;if ((array[j] & 0x1) == 0) j--;if ((array[i] & 0x1) == 0 && (array[j] & 0x1) == 1){int temp = array[i];array[i] = array[j];array[j] = temp;}}return array;}public static void main(String[] args) {int[] array = {};System.out.println(Arrays.toString(letOddNumberEvenNumber(array)));}
}

面试题15：链表中倒数第k个节点

思路：使用两个下标来计数，第一个先走k步，然后第二个和第一个同时走，如果第一个走到了链表的末尾，那么第二个指向的就是链表中倒数第k个节点

class Node{int value;Node next;public Node() {}public Node(int value) {this.value = value;}@Overridepublic String toString() {return "Node{" +"value=" + value +", next=" + next +'}';}
}
public class CountBackwardsKNode {public static Node getountBackwardsKNode(Node head, int count){if (head == null || count == 0) return null;Node node_1 = head;Node node_2 = head;for (int i = 0; i < count; i++){if (node_1 == null) return null;node_1 = node_1.next;}while (node_1 != null){node_2 = node_2.next;node_1 = node_1.next;}return node_2;}public static void main(String[] args) {Node node = new Node(1);Node node1 = new Node(2);node.next = node1;Node node2 = new Node(3);node1.next = node2;Node node3 = new Node(4);node2.next = node3;Node node4 = new Node( 5);node3.next = node4;System.out.println(getountBackwardsKNode(node,2));}
}

面试题16：反转链表

public class InverseList {public static Node inverList(Node head){Node newHead = null;Node currentNode = head;Node preNode = null;while (currentNode != null){Node nextNode = currentNode.next;if (nextNode == null) newHead = currentNode;currentNode.next = preNode;preNode = currentNode;currentNode = nextNode;}return newHead;}public static void main(String[] args) {Node node = new Node(1);Node node1 = new Node(2);node.next = node1;Node node2 = new Node(3);node1.next = node2;Node node3 = new Node(4);node2.next = node3;Node node4 = new Node( 5);node3.next = node4;System.out.println(inverList(node));}
}

面试题17：合并两个排序的链表

思路：新建一个链表依次从头节点开始向后遍历

public class MergeTwoList {public static Node mergeTwoList(Node list1,Node list2){if (list1 == null) return list2;else if (list2 == null) return list1;Node newList = new Node();if (list1.value < list2.value){newList.value = list1.value;newList.next = mergeTwoList(list1.next,list2);}else {newList.value = list2.value;newList.next = mergeTwoList(list1,list2.next);}return newList;}public static void main(String[] args) {Node node = new Node(1);Node node1 = new Node(3);node.next = node1;Node node2 = new Node(5);node1.next = node2;Node node3 = new Node(7);node2.next = node3;Node node4 = new Node( 9);node3.next = node4;Node n_node = new Node(2);Node n_node1 = new Node(4);n_node.next = n_node1;Node n_node2 = new Node(6);n_node1.next = n_node2;Node n_node3 = new Node(8);n_node2.next = n_node3;Node n_node4 = new Node( 10);n_node3.next = n_node4;System.out.println(mergeTwoList(node,n_node));}
}

面试题18：树的子结构

输入两棵二叉树A,B，判断B是不是A的子结构

class Node{int value;Node left;Node right;public Node() {}public Node(int value) {this.value = value;}
}
public class BISAdeSubtree {public static boolean bIsADeSubtree(Node treeA,Node treeB){boolean flag = false;if (treeA != null && treeB != null){if (treeA.value == treeB.value){flag = doesTreeAHasTreeB(treeA,treeB);}if (!flag) flag = bIsADeSubtree(treeA.left,treeB);if (!flag) flag = bIsADeSubtree(treeA.right,treeB);}return flag;}private static boolean doesTreeAHasTreeB(Node treeA, Node treeB) {if (treeA == null) return true;if (treeB == null) return true;if (treeA.value != treeB.value) return false;return doesTreeAHasTreeB(treeA.left,treeB.left) && doesTreeAHasTreeB(treeA.right,treeB.right);}public static void main(String[] args) {Node node = new Node(8);Node node1 = new Node(8);Node node2 = new Node(7);Node node3 = new Node(9);Node node4 = new Node(2);Node node5 = new Node(4);Node node6 = new Node(7);node.left = node1;node.right = node2;node1.left = node3;node1.right = node4;node4.left = node5;node4.right = node6;Node node7 = new Node(8);Node node8 = new Node(9);Node node9 = new Node(2);node7.left = node8;node7.right = node9;System.out.println(bIsADeSubtree(node,node7));}
}

面试题19：二叉树的镜像

思路：递归交换左右节点

public class BinaryTreeMirrorImage {public static Node getBinaryTreeMirrorImage(Node binaryTree){if (binaryTree == null) return null;if (binaryTree.left == null && binaryTree.right == null) return null;Node temp = binaryTree.left;binaryTree.left = binaryTree.right;binaryTree.right = temp;if (binaryTree.left != null) getBinaryTreeMirrorImage(binaryTree.left);if (binaryTree.right != null) getBinaryTreeMirrorImage(binaryTree.right);return binaryTree;}public static void main(String[] args) {Node node = new Node(8);Node node1 = new Node(8);Node node2 = new Node(7);Node node3 = new Node(9);Node node4 = new Node(2);Node node5 = new Node(4);Node node6 = new Node(7);node.left = node1;node.right = node2;node1.left = node3;node1.right = node4;node4.left = node5;node4.right = node6;System.out.println(getBinaryTreeMirrorImage(node));}
}

面试题20：顺时针打印矩阵

输入一个矩阵，按照从外到里以顺时针的顺序依次打印出每一个数字

public class Print2DArrayClockwise {public static void print2DArrayClockwise(int[][] array,int colums,int rows){int len = array.length;if (len == 0 || colums <= 0 || rows <= 0) return;int start = 0;while (colums > start * 2 && rows > start * 2){printArray(array,colums,rows,start);++start;}}private static void printArray(int[][] array, int colums, int rows, int start) {int endX = colums - 1 - start;int endY = rows - 1 - start;
//          左到右打印for (int i = start; i <= endX; ++i){System.out.println(array[start][i]);}
//          上到下打印if (start <= endX){for (int i = start + 1; i <= endY; ++i){System.out.println(array[i][endX]);}}
//          右到左打印if (start < endX && start < endY){for (int i = endX - 1; i >= start; --i){System.out.println(array[endY][i]);}}
//          下到上打印if (start < endX && start< endY - 1){for (int i = endY - 1; i >= start + 1; --i){System.out.println(array[i][start]);}}}public static void main(String[] args) {int a[][] = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};print2DArrayClockwise(a,3,4);}
}

剑指offer面试题（11-20）——java实现相关推荐

剑指offer——面试题11：数值的整数次方
剑指offer--面试题11:数值的整数次方 Solution1:基本算法累乘,时间复杂度为O(n) 要考虑全部情况:指数 < 0, == 0 和 > 0. 注意在 if-else if ...
剑指Offer面试题22（Java版）：栈的压入、弹出序列
题目:输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否为该栈的弹出顺序. 假设压入栈的所有数字均不相等.例如序列1,2,3,4,5是某栈的压栈序列,序列,4,5,3,2,1是该压栈序 ...
剑指Offer - 面试题11. 旋转数组的最小数字（二分查找）
1. 题目把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转.输入一个递增排序的数组的一个旋转,输出旋转数组的最小元素.例如,数组 [3,4,5,1,2] 为 [1,2,3,4,5] ...
数值的整数次方（剑指offer面试题11）
实现函数 double Power(double base, int exponent),即乘方运算. 考虑问题 exponet < 0 , 可以转化为 1.0 / Power(base, -1 ...
剑指offer面试题[11]-数值的正整数次方
题目描述给定一个double类型的浮点数base和int类型的整数exponent.求base的exponent次方. (自己方法可以通过-比较low)后期补充牛客网解法,先mark一下. clas ...
剑指offer面试题11. 旋转数组的最小数字（二分查找）
题目描述把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转.输入一个递增排序的数组的一个旋转,输出旋转数组的最小元素.例如,数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的 ...
[剑指offer]面试题第[68-2]题[Leetcode][第236题][JAVA][二叉搜索树的最近公共祖先][递归]
[问题描述][中等] 235/68-1 搜索二叉树 236/68-2 二叉树 [解答思路] 递归时间复杂度:O(N) 空间复杂度:O(N) 情况 1. , 2. , 3. , 4. 的展开写法如下. ...
[剑指offer]面试题第[57]题[Leetcode][第167题][JAVA][和为s的两个数字][两数之和][HashSet][二分][双指针]
[剑指offer]面试题第[57]题[Leetcode][第167题][第1题] 有序无序之分题目输出不同之分以下解法按照[剑指offer]面试题第[57]题进行题解 [问题描述][简单] 输入一 ...
剑指offer——面试题20：顺时针打印矩阵
剑指offer--面试题20:顺时针打印矩阵 Solution1: 可参考leetCode 54题的解法书上的思路特别好,学习之~ class Solution { public:vector< ...
Java详解剑指offer面试题50--第一个只出现一次的字符
Java详解剑指offer面试题50–第一个只出现一次的字符找出字符串中找出第一个只出现一次的字符,比如输入"abacceff",则输出'b' 要想知道某个字符是不是只出现了一次 ...

剑指offer面试题（11-20）——java实现

面试题整理（自用）