11.二进制中1的个数
12.数值的整数次方
13.调整数组顺序使奇数位于偶数前面
14.链表中倒数第K个节点
15.反转链表
16.合并两个排序的链表
17.树的子结构
18.二叉树的镜像
19.顺时针打印矩阵
20.包含min函数的栈
11.二进制中1的个数
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
public static int NumberOf1(int n) {
String x=Integer.toBinaryString(n);
int m=0;
for(int i=0;i<x.length();i++)
if(x.charAt(i)=='1')
m++;
System.out.println(x);
return m;
}
如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
举个例子：一个二进制数1100，从右边数起第三位是处于最右边的一个1。减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。
public static int NumberOf2(int n) {
int count=0;
while(n!=0){
count++;
n=n&(n-1);
}
return count;
}
12.数值的整数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
13.调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
方法一
1.要想保证原有次序，则只能顺次移动或相邻交换。
2.i从左向右遍历，找到第一个偶数。
3.j从i+1开始向后找，直到找到第一个奇数。
4.将[i,...,j-1]的元素整体后移一位，最后将找到的奇数放入i位置，然后i++。
5.终止条件：j向向后遍历查找失敗。
public void reOrderArray(int [] a) {
if(a==null||a.length==0)
return;
int i=0,j;
while(i<a.length){
while(i<a.length&&!isEven(a[i]))
i++;
j=i+1;
while(j<a.length&&isEven(a[j]))
j++;
if(j<a.length){
int tmp=a[j];
for(int k=j-1;k>=i;k--){
a[k+1]=a[k];
}
a[i++]=tmp;
}else{//查找失败
break;
}
}
}
boolean isEven(int n){
if(n%2==0)
return true;
return false;
}
方法二：
整体思路：
首先统计奇数的个数
然后新建一个等长数组，设置两个指针，奇数指针从0开始，偶数指针从奇数个数的末尾开始 遍历，填数
public void reOrderArray2(int [] a) {
if(a.length==0||a.length==1)
return;
int oddCount=0,oddBegin=0;
int b[]=new int[a.length];
for(int i=0;i<a.length;i++)
if((a[i]&1)==1)
oddCount++;
for(int i=0;i<a.length;i++){
if((a[i]&1)==1)
b[oddBegin++]=a[i];
else
b[oddCount++]=a[i];
}
for(int i=0;i<a.length;i++)
a[i]=b[i];
}
14.链表中倒数第K个节点
输入一个链表，输出该链表中倒数第k个结点。
//公共部分
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
方法一：两个指针，先让第一个指针和第二个指针都指向头结点，然后再让第一个指正走(k-1)步，到达第k个节点。然后两个指针同时往后移动，当第一个结点到达末尾的时候，第二个结点所在位置就是倒数第k个节点了
public ListNode FindKthToTail(ListNode head,int k){
if(head==null||k<=0)
return null;
ListNode pre=head;
ListNode last=head;
for(int i=1;i<k;i++){
if(pre.next!=null)
pre=pre.next;
else
return null;
}
while(pre.next!=null){
pre=pre.next;
last=last.next;
}
return last;
}
方法二：全部进栈然后出栈第k个
public ListNode FindKthToTail2(ListNode head,int k) {
if(head==null||k<=0)
return null;
Stack<ListNode> stack=new Stack<>();
ListNode node=head;
while(node!=null){
stack.push(node);
node=node.next;
}
if(k>stack.size())
return null;
while(k!=1&&!stack.isEmpty()){
stack.pop();
k--;
}
return stack.pop();
}
15.反转链表
输入一个链表，反转链表后，输出链表的所有元素。
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
public ListNode ReverseList(ListNode head) {
if(head==null)
return null;
ListNode pre=null;
ListNode next=null;
while(head!=null){
next=head.next;
head.next=pre;
pre=head;
head=next;
}
return pre;
}
16.合并两个排序的链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
非递归方法
public ListNode Merge(ListNode list1,ListNode list2) {
ListNode head=new ListNode(-1);
head.next=null;
ListNode root=head;
while(list1!=null&&list2!=null){
if(list1.val<list2.val){
head.next=list1;
head=list1;
list1=list1.next;
}else{
head.next=list2;
head=list2;
list2=list2.next;
}
}
if(list1!=null)
head.next=list1;
if(list2!=null)
head.next=list2;
return root.next;
}
递归方法
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1==null)
return list2;
else if(list2==null)
return list1;
ListNode mergeHead=null;
if(list1.val<list2.val){
mergeHead=list1;
mergeHead.next=Merge(list1.next,list2);
}else{
mergeHead=list2;
mergeHead.next=Merge(list1,list2.next);
}
return mergeHead;
}
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 boolean HasSubtree(TreeNode root1,TreeNode root2) {
boolean result=false;
if(root1!=null&&root2!=null){
if(root1.val==root2.val){
result=DoesTree1HaveTree2(root1,root2);
}
if(!result)
result=HasSubtree(root1.left, root2);
if(!result)
result=HasSubtree(root1.right, root2);
}
return result;
}
public boolean DoesTree1HaveTree2(TreeNode root1,TreeNode root2){
if(root1==null&&root2!=null)
return false;
if(root2==null)
return true;
if(root1.val!=root2.val)
return false;
return DoesTree1HaveTree2(root1.left, root2.left)&&DoesTree1HaveTree2(root1.right, root2.right);
}
18.二叉树的镜像
public void Mirror(TreeNode root){
if(root==null)
return;
if(root.left==null&&root.right==null)
return;
TreeNode pTemp=root.left;
root.left=root.right;
root.right=pTemp;
if(root.left!=null)
Mirror(root.left);
if(root.right!=null)
Mirror(root.right);
}
19.顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 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.
public ArrayList<Integer> printMatrix(int [][] array) {
ArrayList<Integer> result=new ArrayList<Integer>();
if(array.length==0)
return result;
int n=array.length,m=array[0].length;
if(m==0)
return result;
int layers=(Math.min(n, m)-1)/2+1;
for(int i=0;i<layers;i++){
for(int k=i;k<m-i;k++)//左到右
result.add(array[i][k]);
for(int j=i+1;j<n-i;j++)//右上到右下
result.add(array[j][m-i-1]);
for(int k=m-i-2;(k>=i)&&(n-i-1!=i);k--)//右到左
result.add(array[n-i-1][k]);
for(int j=n-i-2;(j>i)&&(m-i-1!=i);j--)//左上到左下
result.add(array[j][i]);
}
return result;
}
20.包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。
private Stack<Integer> data=new Stack<Integer>();
private Stack<Integer> min=new Stack<Integer>();
Integer temp=null;
public void push(int node) {
if(temp!=null){
if(node<=temp){
temp=node;
min.push(node);
}
data.push(node);
}else{
temp=node;
data.push(node);
min.push(node);
}
}
public void pop() {
int num=data.pop();
int num2=min.pop();
if(num!=num2)
min.push(num2);
}
public int top() {
return data.peek();
}
public int min() {
return min.peek();
}
