7.11题目总结

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

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

目录

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

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

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

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

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

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

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


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

//    输入两个单调递增的链表,输出两个链表合成后的链表,
//    当然我们需要合成后的链表满足单调不减规则。
    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;
    }

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个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;
    }

 

基于C#开发的一个稳定可靠的上位机系统,旨在满足工业控制的需求。该系统集成了多个功能界面,如操作界面、监控界面、工艺流显示界面、工艺表界面、工艺编辑界面、曲线界面和异常报警界面。每个界面都经过精心设计,以提高用户体验和工作效率。例如,操作界面和监控界面对触摸屏友好,支持常规点击和数字输入框;工艺流显示界面能够实时展示工艺步骤并变换颜色;工艺表界面支持Excel和加密文件的导入导出;工艺编辑界面采用树形编辑方式;曲线界面可展示八组曲线并自定义纵坐标数值;异常报警界面能够在工艺流程出现问题时及时报警。此外,该系统还支持与倍福TC2、TC3和西门子PLC1200/300等下位机设备的通信,确保生产线的顺畅运行。系统参考欧洲工艺软件开发,已稳定运行多年,证明了其可靠性和稳定性。 适合人群:从事工业自动化领域的工程师和技术人员,尤其是对C#编程有一定基础的人群。 使用场景及目标:适用于需要构建高效、稳定的工业控制系统的企业和个人开发者。主要目标是提升生产效率、确保生产安全、优化工艺流程管理和实现数据的有效管理与传输。 其他说明:文中提供了部分示例代码片段,帮助读者更好地理解具体实现方法。系统的复杂度较高,但凭借C#的强大功能和开发团队的经验,确保了系统的稳定性和可靠性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值