剑指offer（二）
1.二进制中1的个数
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
思路：我的思路就是使用先使用Integer的toBinaryString方法将该数转换成二进制形式的字符串，然后统计1的个数。
public class Solution {
public int NumberOf1(int n) {
int count = 0;
String result = Integer.toBinaryString(n);
for(int i = 0; i < result.length(); i++) {
if(result.charAt(i) == '1') {
count++;
}
}
return count;
}
}另一种更好的解法：位运算符&，|，~等是针对二进制的。所以我们可以使用&求解本题。一个数如果不为0，则它表示的二进制必定带有1，当它减1的时候，其最低位的1必定会变成0，其后的0必定全部变成1，如1100，减1，第三位变成了0，后面的两个0 都变成1，就变成了1011，而1100 & 1011 = 1000，也就是说每次这个数和比它小1的数进行&运算，都会消去一个1，基于此，可以得到下面的解法。
public class Solution {
public int NumberOf1(int n) {
int count = 0;
while(n != 0) {
n = n & (n - 1);
count++;
}
return count;
}
}2.调整数组顺序使奇数位于偶数的前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
思路：直接使用有个linkedList作为额外空间，然后把数组的奇数插入前半部分，偶数插入后半部分。
import java.util.LinkedList;
public class Solution {
public void reOrderArray(int [] array) {
LinkedList<Integer> t = new LinkedList<>();
int index = 0;
for(int i = 0; i < array.length; i++) {
// 如果是奇数，则从list的第一个位置开始插，每次插入之后就记录下该元素的下一个位置，
// 当第二个奇数来的时候，插入第一个奇数的后面
if(array[i] % 2 != 0) {
t.add(index, array[i]);
index = t.indexOf(array[i]) + 1;
} else {
// 偶数直接从list的最后面开始插入
t.add(t.size(), array[i]);
}
}
for(int i = 0; i < t.size(); i++) {
array[i] = t.get(i);
}
}
}不使用额外的空间求解，使用类似于冒泡的思想，每次循环把一个偶数移动到数组的最后
public class Solution {
public void reOrderArray(int [] array) {
// 类似于冒泡的思想，每次把一个偶数移动到最末尾
for(int i = 0; i < array.length - 1; i++) {
for(int j = 0; j < array.length - i - 1; j++) {
if(array[j] % 2 == 0 && array[j + 1] % 2 != 0) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
}3.链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个结点。
思路1：首先遍历一遍链表，得到链表的长度len，则len - k就是倒数第k个节点
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
int len = 0;
ListNode t = head;
// 先求出链表的长度
while(t != null) {
len++;
t = t.next;
}
if(k > len) {
return null;
}
// 倒数第k个节点就是链表的长度减k位置处的节点
for(int i = 0; i <= len - k; i++) {
if(i == len - k) {
return head;
} else {
head = head.next;
}
}
return null;
}
}思路2：使用两个指针，第一个指针先移动k个位置，之后两个指针一起移动，当第一个指针移动到链表尾部的时候，第二个指针所指向的元素就是倒数第k个元素
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
ListNode node1 = head;
ListNode node2 = head;
// 第一个指针先移动k个位置
while(k > 0) {
if(node1 != null) {
node1 = node1.next;
k--;
} else {
return null;
}
}
// 两个指针一起移动，当第一个指针到底链表尾部的时候，第二个指针所指向的元素就是倒数第k个元素
while(node1 != null) {
node1 = node1.next;
node2 = node2.next;
}
return node2;
}
}4.反转链表
输入一个链表，反转链表后，输出新链表的表头。
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode ReverseList(ListNode head) {
// 如果是空链表，则返回null
if(head == null) {
return null;
}
// 用来存放反转好的节点
ListNode pre = null;
// 用于存放当前节点后面的节点
ListNode next = null;
while(head != null) {
// 保存当前节点后面的节点，不然反转后,后面的节点会丢失
next = head.next;
// 改变当前节点链表的指向
head.next = pre;
// 把反转部分赋值给pre
pre = head;
// 把当前节点后面的节点赋值后head。进行下一轮的遍历
head = next;
}
return pre;
}
}5.合并两个排序的列表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1 == null) {
return list2;
}
if(list2 == null) {
return list1;
}
ListNode result = null;
ListNode r = null;
while(list1 != null && list2 != null) {
// 如果第二个链表的当前值更小
if(list1.val >= list2.val) {
// 如果是第一次进行赋值，则把更小的赋值给r，并建立r和result的联系
if(r == null) {
r = list2;
result = r;
} else {
r.next = list2;
r = r.next;
}
list2 = list2.next;
} else {
if(r == null) {
r = list1;
result = r;
} else {
r.next = list1;
r = r.next;
}
list1 = list1.next;
}
}
// 如果list1链表还有余下的节点，则直接进行赋值
if(list1 == null) {
r.next = list2;
}
// 如果list2链表还有余下的节点，则直接进行赋值
if(list2 == null) {
r.next = list1;
}
return result;
}
}6.树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
思路：看到树就有点懵逼，还有递归，看来要勤加练习树这一块。
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public static boolean HasSubtree(TreeNode root1,TreeNode root2) {
boolean result = false;
// 两棵树不为空则进行遍历，否则直接返回false
if(root2 != null && root1 != null) {
// 如果当前节点的值相等，则以当前节点为起点，继续遍历
if(root1.val == root2.val) {
result = doesRoot1HasRoot2(root1, root2);
}
// 如果找不到，则以root1的左子树为起点，继续寻找root2
if(!result) {
result = HasSubtree(root1.left, root2);
}
// 如果还没有找到，则以root1的右子树为起点，继续寻找root2
if(!result) {
result = HasSubtree(root1.right, root2);
}
}
return result;
}
public static boolean doesRoot1HasRoot2(TreeNode root1, TreeNode root2) {
// 如果root2先为空，则说明root2是root1的子树，返回true
if(root2 == null) {
return true;
}
// 如果root1先为空，则说明root2不是root1的子树，返回false
if(root1 == null) {
return false;
}
// 如果当前节点的值不相等，返回false
if(root1.val != root2.val) {
return false;
}
return doesRoot1HasRoot2(root1.left, root2.left) && doesRoot1HasRoot2(root1.right, root2.right);
}
}7.二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述
二叉树的镜像定义：源二叉树
8
/ \
6 10
/ \ / \
5 7 9 11
镜像二叉树
8
/ \
10 6
/ \ / \
11 9 7 5
思路：直接用递归即可
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public void Mirror(TreeNode root) {
if(root == null) {
return;
}
TreeNode temp = root.left;
root.left = root.right;
root.right = temp;
Mirror(root.left);
Mirror(root.right);
}
}8.顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
思路：首先打印矩阵的第一行元素，然后把剩下的矩阵逆时针旋转90度，继续打印矩阵的第一行元素，直到矩阵为空。
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printMatrix(int [][] matrix) {
ArrayList<Integer> result = new ArrayList<>();
if(matrix == null) {
return result;
}
// 行的数量
int m = matrix.length;
int n = 0;
if(m > 0) {
// 列的数量
n = matrix[0].length;
}
for(int i = 0; i < n; i++) {
// 把当前矩阵的第一行加入list
result.add(matrix[0][i]);
}
// 如果行的长度已经等于1，则说明矩阵已经遍历完毕，直接输出
if(m == 1) {
return result;
} else {
// 把当前矩阵的第一行去掉
int[][] temp = new int[m - 1][n];
for(int i = 1; i < m; i++) {
for(int j = 0; j < n; j++) {
temp[i - 1][j] = matrix[i][j];
}
}
// 逆时针旋转90当前矩阵
result.addAll(printMatrix(rotateMatrix(temp, m - 1, n)));
}
return result;
}
// 将矩阵逆时针旋转90度
public int[][] rotateMatrix(int[][] matrix, int m, int n) {
int[][] rmatrix = new int[n][m];
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
rmatrix[i][j] = matrix[j][n - i - 1];
}
}
return rmatrix;
}
}9.包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
import java.util.Stack;
import java.util.Iterator;
public class Solution {
Stack<Integer> stack = new Stack<>();
public void push(int node) {
stack.push(node);
}
public void pop() {
stack.pop();
}
public int top() {
return stack.peek();
}
public int min() {
Iterator<Integer> iterator = stack.iterator();
int min = stack.peek();
while(iterator.hasNext()) {
int t = iterator.next();
if(min > t) {
min = t;
}
}
return min;
}
}10.栈的压入、弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
思路：首先遍历压入序列，遇到和弹出序列不一样的元素，则放入一个list中，遍历完压入序列后，若弹出序列还没遍历完，则反向遍历list，继续和弹出序列比较，如果有任何一个不相等，则返回false。
import java.util.ArrayList;
public class Solution {
public boolean IsPopOrder(int [] pushA,int [] popA) {
if(pushA.length != popA.length) {
return false;
}
ArrayList<Integer> result = new ArrayList<>();
int count = 0;
for(int i = 0; i < pushA.length; i++) {
if(pushA[i] == popA[count]) {
count++;
} else {
result.add(pushA[i]);
}
}
if(count != popA.length) {
for(int i = result.size() - 1; i >= 0; i--) {
if(result.get(i) != popA[count]) {
return false;
} else {
count++;
}
}
}
return true;
}
}
