剑指offer11-20

二进制中1的个数

public class Solution {
    public int NumberOf1(int n) {
        int sum=0;
        while(n!=0)
        {
            sum++;
            n=n&(n-1);
        }
        return sum;
        //假设二进制为1100n-1为1011两个进行相与是1000这样就去除了一个最右边的一个1当没有1的时候此程序执行了多少次就是多少   }
   }
}

数值的整数次方

public class Solution {
    public double Power(double base, int exponent) {
        //当n为偶数，a^n =（a*a）的n/2次方 当n为奇数，a^n = （a*a）的n/2次方*a所以可以用递归求解
        //时间复杂度：log（n）
        if (exponent==0) return 1;
        if (exponent==1) return base;
        boolean isnegative=false;
        if(exponent<0)
        {
            exponent=-exponent;
            isnegative=true;
        }
        double number=Power(base*base,exponent/2);
        if(exponent%2==1)
            number=number*base;
        return isnegative?(1/number):number;

            
            
            
        
  }
}

调整数组顺序使得奇数位于偶数前面

public class Solution {
    public void reOrderArray(int [] array) {
        int oddcnt=0;
        for(int val:array)
        {
            if(val%2==1)
                oddcnt++;//记录数组中的奇数个数
        }
        int copy[]=array.clone();
        int i=0;
        for(int number:copy)
        {
            if(number%2==1)
                array[i++]=number;
            else
                array[oddcnt++]=number;
        }
    }
}

链表倒数第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) {
        //创建两个指针，让一个指针跑到第k个节点上，第二个指针指到头结点上，两个指针同时跑，当第一个
        //指针跑到尾部是第二个也就跑到了倒数第k个节点
        if(head==null||k==0)
        {
            return null;
        }
        ListNode p1,p2;
        p1=p2=head;
        while(p1!=null&&k-->0)
        {
            p1=p1.next;
        }
        if(k>0)
            return null;//判断如果倒数的k个节点超过了链表的长度返回null
        while(p1!=null)
        {
            p1=p1.next;
            p2=p2.next;
        }
        return p2;
    }
}

反转链表

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        ListNode newlist=new ListNode(0);
        while(head!=null)
        {
            ListNode next=head.next;
            head.next=newlist.next;
            newlist.next=head;
            head=next;
        }
        return newlist.next;
    }
}

合并两个排序的链表

/*
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 head=new ListNode(1);
        ListNode cur=head;
        while(list1!=null&&list2!=null)
        {
            if(list1.val<=list2.val)
            {
                cur.next=list1;
                list1=list1.next;
            }
            else
            {
                cur.next=list2;
                list2=list2.next;
            }
            cur=cur.next;
        }
        if(list1!=null) 
            cur.next=list1;
        if(list2!=null) 
            cur.next=list2;
        return head.next;
        
        
    }
}

树的子结构

/**
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) {
        if(root1==null||root2==null)
            return false;
        //找出根节点相同的位置
        boolean bol=false;
        if(root1!=null&&root2!=null)
        {
        if(root1.val==root2.val)
            bol=isSubTree(root1,root2);//找到了根节点相同，调用方法判断
        if(!bol)
            bol=HasSubtree(root1.left,root2);//从左子树找根节点相同的节点
        if(!bol)
            bol=HasSubtree(root1.right,root2);//从右子树找根节点相同的节点
        }
        return bol;
    }
    //匹配两个二叉树的每一个节点
    public static boolean isSubTree(TreeNode root1,TreeNode root2)
    {
        if(root2==null)
            return true;//B节点全部匹配
        if(root1==null)
            return false;//B节点还没有匹配A节点就完了
        if(root1.val!=root2.val)
            return false;
        return isSubTree(root1.left,root2.left)&&isSubTree(root1.right,root2.right);//判断每一个节点是否相等
    }
}

二叉树的镜像

/**
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 ;
        swap(root);
        Mirror(root.left);
        Mirror(root.right);
        
    }
    private void swap(TreeNode root){
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
    }
}

顺时针打印矩阵

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> ret=new ArrayList<Integer>();
        int r1=0,r2=matrix.length-1;//行数
        int c1=0,c2=matrix[0].length-1;//列数
        while(r1<=r2&&c1<=c2)
        {
            for(int i=c1;i<=c2;i++)
                ret.add(matrix[r1][i]);
            for(int i=r1+1;i<=r2;i++)
                ret.add(matrix[i][c2]);
            if(r1!=r2)
            {
                for(int i=c2-1;i>=c1;i--)
                    ret.add(matrix[r2][i]);
            }
            if(c1!=c2)//防止重复放入元素
            {
                for(int i=r2-1;i>r1;i--)
                    ret.add(matrix[i][c1]);
            }
            r1++;
            r2--;
            c1++;
            c2--;
                
        }
        return ret;
        
       
    }
}




/*int r1 = 0, r2 = matrix.length - 1, c1 = 0, c2 = matrix[0].length - 1;
    while (r1 <= r2 && c1 <= c2) {
        for (int i = c1; i <= c2; i++)
            ret.add(matrix[r1][i]);
        for (int i = r1 + 1; i <= r2; i++)
            ret.add(matrix[i][c2]);
        if (r1 != r2)
            for (int i = c2 - 1; i >= c1; i--)
                ret.add(matrix[r2][i]);
        if (c1 != c2)
            for (int i = r2 - 1; i > r1; i--)
                ret.add(matrix[i][c1]);
        r1++; r2--; c1++; c2--;
    }
    return ret;
    */

包含main函数的栈

import java.util.Stack;

public class Solution {
    private Stack<Integer> stack=new Stack<Integer>();
    private Stack<Integer> minstack=new Stack<Integer>();
    public void push(int node) {
        stack.push(node);
        minstack.push(minstack.isEmpty()?node:Math.min(node,minstack.peek()));
    }
    
    public void pop() {
        stack.pop();
        minstack.pop();
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int min() {
        return minstack.peek();
        
    }
}