从本篇开始连续五篇总结《剑指offer》这本书里的50道编程题目,这些题目是在面试中常见被要求手写的,所以一定要很熟悉。另外,这些题目我均用Java来编写,题目中的思想也可以总结出来用在很难的编程题上,要求自己每道至少独立手写三遍 ~
class Singleton{
//先是上来就new属性
private static final Singleton instance = new Singleton();
//无参私有构造方法
private Singleton(){}
//静态方法
public static Singleton getInstance(){
return instance;
}
//普通方法
public void print(){
System.out.println("Hello World!");
}
}
class Singleton{
//声明属性
private static final Singleton instance = null;
private Singleton(){};
public static Singleton getInstance(){
if (instance==null){
instance = new Singleton();
}
return instance;
}
public void print(){
System.out.println("Hello World!");
}
}
public class Test{
public static boolean findNum(int[][] arr,int number){
if (arr==null)
return false;
int column = arr[0].length-1;
int row = 0;
while (row<arr.length && column>=0){
if (arr[row][column]==number)
return true;
if (arr[row][column]>number){
column--;
}else {
row++;
}
}
return false;
}
public static void main(String[] args) {
int[][] arr = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
System.out.println( findNum(arr,55));
}
}
public class Test{
public static String replaceBlank(String str){
if (str==null)
return null;
StringBuffer sb = new StringBuffer();
for (int i=0;i<str.length();i++){
if (str.charAt(i)==' '){
sb.append("%20");
}else {
sb.append(str.charAt(i));
}
}
return new String(sb);
}
public static void main(String[] args) {
System.out.println(replaceBlank("Hello World !"));
}
}
public class Test{
public static void main(String[] args) {
ListNode node1 = new ListNode();
ListNode node2 = new ListNode();
ListNode node3 = new ListNode();
node1.data=1;
node2.data=2;
node3.data=3;
node1.next=node2;
node2.next=node3;
printListNodeReverse(node1);
}
// //非递归实现,用栈
// public static void printListNodeReverse(ListNode headNode){
// Stack stack = new Stack();
// while (headNode!=null){
// stack.push(headNode);
// headNode=headNode.next;
// }
// while (!stack.isEmpty()){
// System.out.println(stack.pop().data);
// }
// }
//递归实现
public static void printListNodeReverse(ListNode headNode) {
if (headNode!=null){
if (headNode.next!=null){
printListNodeReverse(headNode.next);
}
}
System.out.println(headNode.data);
}
}
class BinaryTreeNode{
public static int value;
public BinaryTreeNode leftNode;
public BinaryTreeNode rightNode;
}
public class Test{
public static BinaryTreeNode constructCore(int[] preorder,int[] midorder){
if (preorder==null || midorder==null)
return null;
if (preorder.length!=midorder.length)
new Exception("前序和中序长度不同,属于非法输入...");
BinaryTreeNode root = new BinaryTreeNode();
for (int i=0;i<midorder.length;i++){
if (midorder[i]==preorder[0]){
root.value = midorder[i];
System.out.println(root.value);
//这个拷贝函数,拷的是前后序号之间的。左闭右开。
root.leftNode = constructCore(Arrays.copyOfRange(preorder,1,i+1),
Arrays.copyOfRange(midorder,0,i));
root.rightNode = constructCore(Arrays.copyOfRange(preorder,i+1,preorder.length),
Arrays.copyOfRange(midorder,i+1,midorder.length));
}
}
return root;
}
public static void main(String[] args) {
int[] pre = {1,2,4,7,3,5,6,8};
int[] mid = {4,7,2,1,5,3,8,6};
System.out.println(constructCore(pre,mid));
}
}
public class Test{
private Stack<Integer> stack1 = new Stack<>();
private Stack<Integer> stack2 = new Stack<>();
public void appendTail(Integer a){
stack1.push(a);
System.out.println(stack1);
}
public Integer deleteHead() throws Exception {
if (stack2.isEmpty()){
while (!stack1.isEmpty()){
stack2.push(stack1.pop());
}
}
if (stack2.isEmpty()){
throw new Exception("队列为空,不能删除");
}
System.out.println(stack2);
return stack2.pop();
}
public static void main(String[] args) throws Exception {
Test test = new Test();
test.appendTail(1);
test.appendTail(2);
test.appendTail(3);
test.deleteHead();
}
}
public class Test{
public static void main(String[] args) {
//int[] array = {1,0,1,1,1};
//int[] array = {3,4,5,1,2};
int[] array = {1,2,0,1,1};
System.out.println(Arrays.toString(array));
System.out.println(findMinNum(array));
}
public static Integer findMinNum(int[] arr){
if (arr==null)
return null;
int leftIndex=0;
int rightIndex=arr.length-1;
int mid=0;
//判断是否为旋转过的数组
while (arr[leftIndex]>=arr[rightIndex]) { //数组最左边的数>=最右边的数,旋转过的进入循环
if (rightIndex - leftIndex <= 1) { //整个数组中只有一个数或者两个数
mid = rightIndex; //中间指针赋给任意一个即可
break;
}
mid = (leftIndex + rightIndex) / 2; //否则,取中间指针为靠前的那个
// 如果数组左右两数相等并且左边的数等于中间数
if (arr[leftIndex] == arr[rightIndex] && arr[leftIndex] == arr[mid]) {
//上述条件下满足:次左和次右的数不相等
if (arr[leftIndex + 1] != arr[rightIndex - 1]) {
//若左边小就取次左赋给中间,右边小就取次右赋给中间
mid = arr[leftIndex + 1] < arr[rightIndex - 1] ? (leftIndex + 1) : (rightIndex - 1);
break;
} else {
//若次左和次右相等,索引就一起向中间挪步
leftIndex++;
rightIndex--;
}
} else {
//左右两数不等
//若中间数大于左数
if (arr[mid] >= arr[leftIndex])
leftIndex = mid;
else if(arr[mid]<arr[rightIndex]){
rightIndex = mid;
}
}
}
return arr[mid];
}
}
public class Test{
public static void quickSort(int[] arr,int startIndex,int endIndex){
if (startIndex>=endIndex)
return;
int mid = partition(arr,startIndex,endIndex);
quickSort(arr,startIndex,mid-1);
quickSort(arr,mid+1,endIndex);
}
private static int partition(int[] arr,int startIndex,int endIndex){
//取传入数组中的第一个元素为基础数据
int data = arr[startIndex];
int left = startIndex;
int right = endIndex;
//循环结束条件为左右指针相等时
while (left!=right){
//从后向前找小于基础数的数字,如果不是,就继续向前找
while (left<right && arr[right]>=data)
right--;
//从前往后找大于基础数的数字,如果不是,就继续向后找
while (left<right && arr[left]<=data)
left++;
//此时已经找到相应的两个数字,进行交换
if (left<right){
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
}
}
//此时left和right在相同位置,则把当前指针处的数据与基础数据交换
int temp = arr[left];
arr[left] = data;
arr[startIndex] = temp;
return left;
}
public static void main(String[] args) {
//int[] arr = new int[]{4,7,6,5,3,2,8,1};
int[] arr = new int[]{7,6,3,6,0,2,1,4,3};
quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
}
public class Test{
public static long fibnacci(int n){
long result = 0;
long preOne = 0;
long preTwo = 1;
if (n==0)
return preOne;
if (n==1)
return preTwo;
for(int i=0;i<n;i++){
result=preOne+preTwo;
preOne = preTwo;
preTwo = result;
}
return result;
}
public static void main(String[] args) {
System.out.println(fibnacci(5));
}
}
public class Test{
public static int numOf_1(int n){
int count = 0;
while (n!=0){
count++;
n=n&(n-1);
}
return count;
}
public static void main(String[] args) {
System.out.println(numOf_1(15));
}
}