剑指offer第十题之第十六题（java详解）

最新推荐文章于 2020-07-21 00:18:53 发布

图书馆五楼管理员

最新推荐文章于 2020-07-21 00:18:53 发布

阅读量1.1k

点赞数

分类专栏：剑指offer-java 文章标签：剑指offer-java 剑指offer-java实现

本文链接：https://blog.csdn.net/jiaohanhan/article/details/72638354

版权

剑指offer-java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

第十题（一）：二进制中1的个数
第十题（二）：判断一个数是否是2的整数次方
第十题（三）：两个整数m和n，计算需要改变m的二进制表示中的多少位才能得到n.
第十一题：数值的整数次方
第十二题：打印1到n位数
第十三题：在O(1)时间内删除链表结点
第十四题：调整数组顺序使奇数位于偶数前面
第十五题（一）：链表中倒数第k个结点
第十五题（二）：链表的中间的结点
第十六题：反转链表

第十题（一）：二进制中1的个数

/**
 * 题目描述：二进制中1的个数
 *      请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。
 *      例如把9表示成二进制1001，有2位是1.因此如果输入9，就输出2。
 * 
 * 解题思路1：可以考虑(n & 1)结果如果是1，就累加结果，n >> 1迭代。但是这样
 *      输入的数据是负数的时候，就会陷入死循环，所以可以反过来做，flag=1，
 *      判断（n & flag)是不是等于flag，flag << 1 迭代，就可以避免死循环了
 * 
 * 解题思路2：把一个整数减一，再和原整数做与运算，会把该整数最右边的一个1变成0
 *      那么一个整数的二进制中有多少个1，就可以进行多少次这样的运算
 * 
 * @author 焦含寒
 *
 */
public class NO10_0 {
    public static void main(String[] args) {
        System.out.println(count1(7));
        System.out.println(count2(7));
    }

    public static int count1(int n) {
        int flag = 1;
        int result = 0;
        while (flag > 0) {
            if ((n & flag) == flag)
                result++;

            flag <<= 1;
        }
        return result;
    }

    public static int count2(int n) {
        int result = 0;
        while (n != 0) {
            result++;
            n = (n - 1) & n;
        }
        return result;
    }
}

## 第十题（二）：判断一个数是否是2的整数次方 ##

/**
 * 题目描述：
 *      判断一个数是否是2的整数次方，是就输出yes,否则就输出no
 * 
 * 解题思路：如果一个数是2的整数次方，那么这个数的二进制一定只包含一个1
 *      ，也就是说，这个整数减去1和自己做与运算，就会变成0
 * 
 * @author 焦含寒
 *
 */
public class NO10_1 {

    public static void main(String[] args) {
        judge(8);
        judge(5);
    }

    public static void judge(int n) {
        if (((n - 1) & n) == 0)
            System.out.println("yes");
        else
            System.out.println("no");
    }

}

## 第十题（三）：两个整数改变m的二进制中的多少位才能得到n. ##

/**
 * 题目描述：
 *      输入两个整数m和n，计算需要改变m的二进制表示中的多少位
 *      才能得到n.
 * 
 * 解题思路：先做异或，然后统计异或结果中1的位数
 * 
 * @author 焦含寒
 *
 */
public class NO10_2 {

    public static void main(String[] args) {
        System.out.print(count(1, 3));
    }

    public static int count(int m, int n) {
        int result = 0;
        n = m ^ n;
        while (n > 0) {
            ++result;
            n = n & (n - 1);
        }
        return result;
    }

}

## 第十一题：数值的整数次方##

/**
 * 题目描述：数值的整数次方
 *      实现函数double power(double base, int exponent),求base的exponent次方。
 *      不得使用库函数，同时不需要考虑大数问题。
 * 
 * 解题思路：注意指数可以正，负，0，基数是否为0；在计算的时候注意比较double类型的
 *      时候不能用==号，计算的时候可以进行优化
 * 
 * @author 焦含寒
 *
 */
public class NO11 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(power(2.0, 10));
    }

    public static double power(double base, int exponent) {
        double result = 0.0;
        if (equal(base, 0.0) && exponent < 0) {
            throw new IllegalArgumentException("0的负数次幂没有意义");
        }

        if (exponent < 0) {
            result = 1.0 / powerWithExpoment(base, -exponent);
        } else {
            result = powerWithExpoment(base, exponent);
        }

        return result;
    }

    private static double powerWithExpoment(double base, int exponent) {
        if (exponent == 0)
            return 1.0;
        if (exponent == 1)
            return base;
        // //这是线性时间
        // double result = 1.0;
        // for(int i=0;i<exponent;i++)
        // result *= base;

        // 优化
        double result = powerWithExpoment(base, exponent >> 1);
        result *= result;
        if ((exponent & 0x1) == 1)
            result *= base;
        return result;
    }

    private static boolean equal(double num1, double num2) {
        if (Math.abs(num1 - num2) < 0.0000001)
            return true;
        else
            return false;
    }
}

## 第十二题：打印1到n位数##

/**
 * 题目描述：打印1到n位数
 *      输入数字n，按顺序打印从1到最大n位十进制数。
 *      比如输入3，则打印1、2...999
 * 
 * 解题思路：注意一定要考虑单纯的打印小于10^(n+1)容易造成的溢出
 * 
 * 
 * @author 焦含寒
 *
 */
public class NO12 {

    public static void main(String[] args) {
        printNum(2);
    }

    private static void printNum(int n) {
        if (n < 0)
            throw new IllegalArgumentException("非法数字");

        int[] array = new int[n];
        printArray(array, 0);
    }

    private static void printArray(int[] array, int n) {
        if (n != array.length) {
            for (int i = 0; i < 10; i++) {
                array[n] = i;
                printArray(array, n + 1);
            }
        } else {
            boolean flag = false;
            for (int j = 0; j < array.length; j++) {
                if (array[j] != 0) {
                    flag = true;
                }
                if (flag) {
                    System.out.print(array[j]);
                }
            }
            if (flag)
                System.out.println();
        }

    }

}

## 第十三题：在O(1)时间内删除链表结点##

/**
 * 题目描述：在O(1)时间内删除链表结点
 *      给定单向链表的头指针和一个结点指针，定义一个函数在O(1)时间
 *      删除该结点。
 * 
 * 解题思路：删除单链表结点的思路有两种，一种就是顺序遍历链表找到要删除的
 *      的结点的上一个结点，把其指针指向要删除节点的下一个结点；第二种思路
 *      把要删除结点的下一个结点的值赋给要删除的结点，并把赋好值的结点的指针
 *      指向下一个个结点。在本题中，采用第二种思路，这种思路好处在于删除的
 *      结点只需要常数时间，但是基于这个结点一定在链表中，这样也给了这个函数
 *      的调用者增加了O(n)的复杂度来确保要删除结点是不是在链表中
 * 
 * @author 焦含寒
 *
 */
public class NO13 {

    public static void main(String[] args) {
        Node node1 = new Node("A");
        Node node2 = new Node("B");
        Node node3 = new Node("C");
        Node node4 = new Node("D");
        Node node5 = new Node("E");
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);
        delete(node1,node4);
        Node node = node1;
        while(node != null){
            System.out.println(node.getData());
            node = node.getNext();
        }

    }

    public static void delete(Node head, Node delNode){
        //如果是尾结点，只能遍历删除
        if(delNode.getNext() == null){
            while(head.getNext() != delNode){
                head = head.getNext();
            }

            Node node = head.getNext();
            node = null;
        }else if(head == delNode){
            head = null;
        }else{
            delNode.setData(delNode.getNext().getData());
            delNode.setNext(delNode.getNext().getNext());
        }
    }

}

class Node{

    private String data;
    private Node next;

    public Node(String data) {
        super();
        this.data = data;
    }
    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }



}

## 第十四题：调整数组顺序使奇数位于偶数前面 ##


/**
 * 题目描述：调整数组顺序使奇数位于偶数前面
 *      输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有
 *      奇数位于数组的前半部分，所有偶数位于数组的后半部分
 * 
 * 解题思路：用两个下标，一个从前向后找第一个遇到的偶数，第二个从后向前找
 *      第一个遇到的奇数，交换，当两个下标相遇结束。
 * 
 * @author 焦含寒
 *
 */
public class NO14 {

    public static void main(String[] args) {
        int[] arr = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
        adjust(arr);
        for (int i : arr)
            System.out.print(i + " ");

    }

    public static void adjust(int[] arr) {
        if (arr == null || arr.length == 0)
            throw new NullPointerException("空数组");
        int i = 0;
        int j = arr.length - 1;
        int temp = 0;
        while (i < j) {
            if (i<j &&(arr[i] & 0x1) == 1)
                i++;

            if (i<j && (arr[j] & 0x1) == 0)
                j--;

            if(i<j){
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }

        }
    }

}

## 第十五题（一）：链表中倒数第k个结点##


/**
 * 题目描述：链表中倒数第k个结点
 *      输入一个链表，输出该链表中倒数第k个结点，规定链表从1开始计数，
 *      。例如一个链表有6个结点，那么从头开始计数依次是1、2、3、4、5、6
 *      这个链表的倒数第3个结点是值为4的结点。
 * 
 * 解题思路：直观解法，就是把链表遍历两次，第一次遍历出链表长度，第二次
 *      定位出k所在的位置。在遍历一次就定位到k所在位置，只需要定义两个指针
 *      一个先跑k步，另一个指针再出发，当第一个指针到了链表尾部，那么第二个
 *      指针就正好定位到k的位置，注意代码的鲁棒性，考虑空指针，链表结点少于k，
 *      以及输入k为0的情况
 * 
 * @author 焦含寒
 *
 */
public class NO15_1 {

    public static void main(String[] args) {
        My_Node node1 = new My_Node("1");
        My_Node node2 = new My_Node("2");
        My_Node node3 = new My_Node("3");
        My_Node node4 = new My_Node("4");
        My_Node node5 = new My_Node("5");
        My_Node node6 = new My_Node("6");
        My_Node node7 = new My_Node("7");
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);
        node5.setNext(node6);
        node6.setNext(node7);
        System.out.println(findKthMy_NodeFromTail(node1, 4));



    }

    public static String findKthMy_NodeFromTail(My_Node head, int k){
        if(head == null)
            return null;
        if(k==0){
            System.out.println("k要求从1开始");
            return null;
        }

        My_Node temp1 = head;
        for(int i = 0;i<k-1;i++){
            if(temp1.getNext() == null){
                System.out.println("k不应该大于链表长度的");
                return null;
            }
            temp1 = temp1.getNext();
            }

        My_Node temp2 = head;
        while(temp1.getNext() != null){
            temp1 = temp1.getNext();
            temp2 = temp2.getNext();

        }


        return temp2.getData();
    }

}

class My_Node{
    private String data;
    private My_Node next;


    public My_Node(String data) {
        super();
        this.data = data;
    }

    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public My_Node getNext() {
        return next;
    }
    public void setNext(My_Node next) {
        this.next = next;
    }

}

## 第十五题（二）：链表的中间的结点 ##

/**
 * 题目描述：链表的中间的结点
 *      求链表的中间结点。如果链表结点总数是奇数，返回中间结点；如果
 *      结点总数是偶数，返回中间两个结点的任何一个都可以
 * 
 * 解题思路：用两个指针，一个指针比另一个慢一步，当一个指针走到末尾的时候，
 *      另一个正好在中间
 * 
 * @author 焦含寒
 *
 */
public class NO15_2 {

    public static void main(String[] args) {
        MNode node1 = new MNode("1");
        MNode node2 = new MNode("2");
        MNode node3 = new MNode("3");
        MNode node4 = new MNode("4");
        MNode node5 = new MNode("5");
        MNode node6 = new MNode("6");
        MNode node7 = new MNode("7");
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);
        node5.setNext(node6);
        node6.setNext(node7);
        System.out.println(findMid(node1).getData());


    }

    private static MNode findMid(MNode head) {
        if(head == null)
            return null;
        MNode slow = head;
        MNode fast = head;
        while(fast.getNext() != null && fast.getNext().getNext() != null){
            slow = slow.getNext();
            fast = fast.getNext().getNext();
        }
        return slow;
    }

}
class MNode{
    private String data;
    private MNode next;


    public MNode(String data) {
        super();
        this.data = data;
    }

    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public MNode getNext() {
        return next;
    }
    public void setNext(MNode next) {
        this.next = next;
    }

}

## 第十六题：反转链表##

/**
 * 题目描述：反转链表
 *      定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的
 *      头结点。
 * 
 * 解题思路：先保证代码的鲁棒性，反转策略就是
 * @author 焦含寒
 *
 */
public class N016 {

    public static void main(String[] args) {
        MyNode node1 = new MyNode("1");
        MyNode node2 = new MyNode("2");
        MyNode node3 = new MyNode("3");
        MyNode node4 = new MyNode("4");
        MyNode node5 = new MyNode("5");
        MyNode node6 = new MyNode("6");
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);
        node5.setNext(node6);
        System.out.println(reverseList(node1).getData());
    }

    public static MyNode reverseList(MyNode head) {
        if (head == null)
            return null;
        if (head.getNext() == null)
            return head;

        MyNode preMyNode = null;
        MyNode curMyNode = head;
        MyNode reversedHead = null;

        while (curMyNode.getNext() != null) {
            MyNode nextMyNode = curMyNode.getNext();
            if (nextMyNode == null)
                reversedHead = nextMyNode;
            MyNode temp = curMyNode.getNext();
            temp = preMyNode;
            preMyNode = curMyNode;
            curMyNode = nextMyNode;
        }
        return curMyNode;
    }

}

class MyNode {
    private String data;
    private MyNode next;

    public MyNode(String data) {
        super();
        this.data = data;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    public MyNode getNext() {
        return next;
    }

    public void setNext(MyNode next) {
        this.next = next;
    }

}

图书馆五楼管理员

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指offer第十题之第十六题（java详解）

目录第十题（一）：二进制中1的个数第十题（二）：判断一个数是否是2的整数次方第十题（三）：两个整数m和n，计算需要改变m的二进制表示中的多少位才能得到n.第十一题：数值的整数次方第十二题：打印1到n位数第十三题：在O(1)时间内删除链表结点第十四题：调整数组顺序使奇数位于偶数前面第十五题（一）：链表中倒数第k个结点第十五题（二）：链表的中间的结点第十六题：反转链表
复制链接

扫一扫