11-20题
11. 二进制中1的个数 – 算法和数据操作
题目描述
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
public class Solution {
public int NumberOf1(int n) {
int count = 0;
while (n != 0) {
count++;
n = n & (n - 1);
}
return count;
}
}12. 数值的整数次方 – 代码的完整性
题目描述
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
保证base和exponent不同时为0
public class Solution {
public double Power(double base, int exponent) {
if (base == 0) {
return 0;
}
if (exponent == 0) {
return 1;
}
if (exponent == 1) {
return base;
}
int absExponent = exponent;
if (exponent < 0) {
absExponent = -exponent;
}
double result = powerAbsexponent(base, absExponent);
if (exponent < 0) {
result = 1.0 / result;
}
return result;
}
public double powerAbsexponent(double base, int exponent) {
if (exponent == 0) {
return 1;
}
if (exponent == 1) {
return base;
}
double result = powerAbsexponent(base, exponent / 2);
result = result * result;
if (exponent % 2 == 1) {
result = result * base;
}
return result;
}
}13. 调整数组顺序使奇数位于偶数前面 – 代码的完整性
题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
public class Solution {
public void reOrderArray(int[] array) {
// 不保持相对位置可以用两个指针调整
// 保持相对位置，这里用的插入排序的思想
int index = 0;
int temp;
int arrayLength = array.length;
for (int i = 0; i < arrayLength; i++) {
if (array[i] % 2 == 1) {
temp = array[i];
int indextemp = i;
while (indextemp > index) {
array[indextemp] = array[--indextemp];
}
array[index++] = temp;
}
}
return;
}
}14. 链表中倒数第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) {
// 输出节点n-k+1=n-(k-1)
if (head == null || k == 0) {
return null;
}
ListNode phead1 = head;
ListNode phead2 = head;
for (int i = 0; i < k - 1; i++) {
if (phead1.next != null) {
phead1 = phead1.next;
} else {
return null;
}
}
while (phead1.next != null) {
phead1 = phead1.next;
phead2 = phead2.next;
}
return phead2;
}
}15. 反转链表 – 代码的鲁棒性
题目描述
输入一个链表，反转链表后，输出新链表的表头。
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode ReverseList(ListNode head) {
if (head == null) {
return null;
}
if (head.next == null) {
return head;
}
ListNode newHead = null;
ListNode nodepre = null;
ListNode node = head;
while (node != null) {
ListNode nodenext = node.next;
if (nodenext == null) {
newHead = node;
}
node.next = nodepre;
nodepre = node;
node = nodenext;
}
return newHead;
}
}16. 合并两个排序的链表 – 代码的鲁棒性
题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
/*
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 mergeList = null;
if (list1.val <= list2.val) {
mergeList = list1;
mergeList.next = Merge(list1.next, list2);
} else {
mergeList = list2;
mergeList.next = Merge(list1, list2.next);
}
return mergeList;
}
}17. 树的子结构 – 代码的鲁棒性
题目描述
输入两棵二叉树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 boolean HasSubtree(TreeNode root1, TreeNode root2) {
boolean result = false;
if (root1 != null && root2 != null) {
if (root1.val == root2.val) {
result = isSubtree(root1, root2);
}
if (!result) {
result = HasSubtree(root1.left, root2);
}
if (!result) {
result = HasSubtree(root1.right, root2);
}
}
return result;
}
public boolean isSubtree(TreeNode root1, TreeNode root2) {
if (root2 == null) {
return true;
}
if (root1 == null) {
return false;
}
if (root1.val != root2.val) {
return false;
}
return isSubtree(root1.left, root2.left)
&& isSubtree(root1.right, root2.right);
}
}18. 二叉树的镜像 – 抽象问题形象化
题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树
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;
}
if (root.left == null && root.right == null) {
return;
}
TreeNode temp = root.left;
root.left = root.right;
root.right = temp;
if (root.left != null) {
Mirror(root.left);
}
if (root.right != null) {
Mirror(root.right);
}
return;
}
}19. 顺时针打印矩阵 – 抽象问题形象化
题目描述
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printMatrix(int[][] matrix) {
ArrayList<Integer> list = new ArrayList<Integer>();
int rows = matrix.length;
int cols = matrix[0].length;
boolean[][] vis = new boolean[rows][cols];
list.add(matrix[0][0]);
int count = rows * cols;
int ans = 1;
int i = 0, j = 0;
vis[i][j] = true;
while (ans < count) {
while (j + 1 < cols && !vis[i][j + 1]) {
j++;
list.add(matrix[i][j]);
vis[i][j] = true;
ans++;
}
while (i + 1 < rows && !vis[i + 1][j]) {
i++;
list.add(matrix[i][j]);
vis[i][j] = true;
ans++;
}
while (j - 1 >= 0 && !vis[i][j - 1]) {
j--;
list.add(matrix[i][j]);
vis[i][j] = true;
ans++;
}
while (i - 1 >= 0 && !vis[i - 1][j]) {
i--;
list.add(matrix[i][j]);
vis[i][j] = true;
ans++;
}
}
return list;
}
}20. 包含min函数的栈 – 抽象问题具体化
题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。 注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。
import java.util.Stack;
public class Solution
Stack<Integer> m_data = new Stack<Integer>();
Stack<Integer> m_min = new Stack<Integer>();
public void push(int node) {
m_data.push(node);
if (m_min.empty()) {
m_min.push(node);
} else if (node < m_min.peek()) {
m_min.push(node);
} else {
m_min.push(m_min.peek());
}
}
public void pop() {
m_data.pop();
m_min.pop();
}
public int top() {
return m_data.peek();
}
public int min() {
return m_min.peek();
}
}