7.11题目总结

最新推荐文章于 2025-07-21 10:46:13 发布

lzw2019sun

最新推荐文章于 2025-07-21 10:46:13 发布

阅读量212

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构与算法

本文链接：https://blog.youkuaiyun.com/liuzewei2015/article/details/95596806

数据结构与算法专栏收录该内容

9 篇文章

订阅专栏

博客围绕链表、数组和数学问题展开。涉及两个单调递增链表的合成、链表反转、查找链表倒数第k个结点，还包括调整数组中奇偶顺序、求浮点数的整数次方、小矩形覆盖大矩形的方法数，以及计算整数二进制中1的个数等算法问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

//    输入两个单调递增的链表，输出两个链表合成后的链表，
//    当然我们需要合成后的链表满足单调不减规则。
    public Node Merge(Node list1, Node list2) {
        Node head = list1.data < list2.data ? list1 : list2;
        Node cur1 = head == list1 ? list1 : list2;//初始头结点所在的链表
        Node cur2 = head == list1 ? list2 : list1;
        Node pre = null;
        Node nex = null;
        while (cur1 != null && cur2 != null) {
            if ((cur1.data <= cur2.data)) {
                pre = cur1;
                cur1 = cur1.next;
            } else {//注意容易出现循环链表
                nex = cur2.next;
                pre.next = cur2;
                cur2.next = cur1;//cur2节点添加到链表中
                cur2 = nex;
                pre = pre.next;
            }
        }
        pre.next = cur1 == null ? cur2 : cur1;
        return head;
    }

输入一个链表，反转链表后，输出新链表的表头。

    public Node ReverseList(Node head) {
        if (head == null) {
            return null;
        }
        Node preNode = null;
        Node nextNode = null;
        while (head != null) {
            nextNode = head.next;
            head.next = preNode;
            preNode = head;
            head = nextNode;
        }
        System.out.println(preNode.data);
        return preNode;
    }

用递归的方式翻转链表：

    //    用递归的方式翻转链表
//    以1-2-3-4为例：
//    程序到达Node newHead = reverse(head.next);时进入递归
//    我们假设此时递归到了3结点，此时head=3结点，temp=3结点.next(实际上是4结点)
//    执行Node newHead = reverse(head.next);传入的head.next是4结点，返回的newHead是4结点。
//    接下来就是弹栈过程了
//    程序继续执行 temp.next = head就相当于4->3
//    head.next = null 即把3结点指向4结点的指针断掉。
//    返回新链表的头结点newHead
    public Node iterationRevise(Node head) {
        if (head == null || head.next == null) {
            return head;
        }
        Node temp = head.next;//temp指向4节点
        Node newHead = iterationRevise(head.next);
        temp.next = head;//4节点指向3节点
        head.next = null;//将3节点指向null，断开3节点指向4节点的连接；
        return newHead;
    }

    public Node iterationRevise2(Node head) {
        if (head == null || head.next == null) {
            return head;
        }
        //递归走到链表的末端；先翻转后面的链表；
        Node newHead = iterationRevise(head.next);
        //将当前节点设置为后面节点的next节点
        head.next.next = head;//翻转了链表的指向
        head.next = null;//防止链表错乱
        return newHead;
    }

输入一个链表，输出该链表中倒数第k个结点

    public Node FindKthToTail(Node head, int k) {
        int f = 0;
        Node kNode = head;
        while (kNode != null) {
            f++;
            kNode = kNode.next;
        }
        if (k > f) {
            return null;
        }
        for (int i = 0; i < f - k; i++) {
            head = head.next;
        }
        System.out.println(head.data);
        return head;
    }

输入一个链表，输出该链表中倒数第k个结点。(改进，遍历一遍)：

    //    输入一个链表，输出该链表中倒数第k个结点。(改进，遍历一遍)
    public Node FindKthToTail2(Node head, int k) {
        if (head == null || k <= 0) {
            return null;
        }
        Node kNode = head;

        for (int i = 0; i < k; i++) {
            if (head == null) {
                return null;
            }
            head = head.next;
        }//head为第k个了

        while (head != null) {
            kNode = kNode.next;
            head = head.next;
        }

        System.out.println(kNode.data);
        return kNode;
    }

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

    public void reOrderArray(int[] array) {
        int[] result = new int[array.length];
        int sizeOdd = 0;
        int po = 0;
        int even = 0;
        for (int i = 0; i < array.length; i++) {
            if ((array[i] & 0x1) == 1) {//如果为奇数
                sizeOdd++;
            }
        }
        for (int i = 0; i < array.length; i++) {
            if ((array[i] & 0x1) == 0) {//如果为偶数
                result[sizeOdd + even] = array[i];
                even++;
            } else {
                result[po] = array[i];
                po++;
            }
        }
        for (int i = 0; i < array.length; i++) {
            array[i] = result[i];
        }
    }

如果：不保证相对位置不变,原地变换数组：

    public void reArray(int[] array) {
        int left = 0;
        int right = array.length - 1;
        int temp;
        while (left < right) {
            if ((array[left] & 0x1) == 0) {//左边的为偶数
                if ((array[right] & 0x1) == 1) {//右边的也为奇数
                    temp = array[left];
                    array[left] = array[right];
                    array[right] = temp;
                    right--;
                    left++;
                } else {
                    right--;
                }
            } else {
                left++;
            }
        }
    }

不保证相对位置不变,原地变换数组(更简洁的代码)：

    public void reArray2(int[] array) {
        int left = 0;
        int right = array.length - 1;
        int temp;
        while (left < right) {
            while ((left < right) && (array[left] & 0x1) == 1) {//左边的为奇数
                left++;
            }
            while ((left < right) && (array[right] & 0x1) == 0) {//右边的为偶数
                right--;
            }
            temp = array[left];
            array[left] = array[right];
            array[right] = temp;
            right--;
            left++;
        }
    }

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

    public double Power(double base, int exponent) {
        if (base == 0) {
            if (exponent >= 0) return 0;
            if (exponent < 0) throw new RuntimeException("分母不能为0");
        }
        if (exponent == 0) return 1;
        double res = base;
        if (exponent < 0) {
            exponent = -exponent;
            for (; exponent != 0; exponent >>= 1) {
                if ((exponent & 1) == 1) res = base * res;
                else base = base * base;
            }
            res = 1 / res;
        } else {
            for (; exponent != 0; exponent >>= 1) {
                if ((exponent & 1) == 1) res = base * res;
                else base = base * base;
            }
        }
        return res;
    }

将指数为正整数时的情况拿出来，使用递归实现，递归次数logn

    public double Power2WithExponent(double base, int exponent) {
        //指数为正整数时的结果，递归节省计算的次数
        if (exponent == 0) return 1;
        if (exponent == 1) return base;

        double res = Power2WithExponent(base,exponent>>1);
        res = res*res;
        if((exponent & 0x1) == 1){//用与，为0为偶数，为1为奇数
            res = res*base;
        }
        return res;
    }
    public double Power2(double base, int exponent) {
        if (base == 0) {
            if (exponent >= 0) return 0;
            if (exponent < 0) throw new RuntimeException("分母不能为0");
        }
        if (exponent == 0) return 1;
        double result = 0;
        if (exponent < 0) {
            exponent = -exponent;
            result = Power2WithExponent(base,exponent);
            result = 1/ result;
        }else {
            result = Power2WithExponent(base,exponent);
        }
        return result;
    }

我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

    //我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。
    //请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
    //同斐波那契数列的应用
    public int RectCover(int target) {
        if(target == 1){
            return 1;
        }
        if(target == 2){
            return 2;
        }
        int a = 1;
        int b = 2;
        int total = 0;
        for(int i = 3; i <= target; i++){
            total = a+b;
            a = b;
            b = total;
        }
        return total;
    }

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

    public int NumberOf1(int n) {
        int pre = 0;
        int flag = 1;
        while (flag != 0){//这个方法中循环的次数等于整数二进制的位数，32位的整数
            if((n & flag) == 1){
                pre++;
            }
            flag <<= 1;
        }
        return pre;
    }

更好的解法：

    public int NumberOf2(int n) {//好的解法
        int pre = 0;
        while (n != 0){
            pre++;
            n = n & (n-1);
        }
        return pre;
    }