迭代和递归基本思想

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class IterationAndRecursion {

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    System.out.println(sum1(arr, arr.length));
    reverse(arr, 1, 4);
    System.out.println(sum2(arr, 0, arr.length - 1));
    max2(arr,0,arr.length);
    max2better(arr,0,arr.length);
}


//数组中前2大元素改进
private static void max2better(int[] arr, int low, int high) {
    int max1,max2;
    if (arr[max1 = low] < arr[max2 = low + 1]) {
        arr[max1] = arr[max1] ^ arr[max2];
        arr[max2] = arr[max1] ^ arr[max2];
        arr[max1] = arr[max1] ^ arr[max2];
    }
    for (int i = low + 2; i < high; i++) {
        if (arr[i] > arr[max2]) {
            if (arr[max2 = i] > arr[max1]) {
                arr[max1] = arr[max1] ^ arr[max2];
                arr[max2] = arr[max1] ^ arr[max2];
                arr[max1] = arr[max1] ^ arr[max2];
            }
        }
    }
    System.out.println(arr[max1] + "," + arr[max2]);
}

//数组中前2大元素
private static void max2(int[] arr, int low, int high) {
    int max1 = low,max2 = low;
    for (int i = low + 1; i < high; i++) {
        if (arr[max1] < arr[i]) {
            max1 = i;
        }
    }
    for (int i = low; i < max1; i++) {
        if (arr[max2] < arr[i] ) {
            max2 = i;
        }
    }
    for (int i = max1 + 1; i < high; i++) {
        if (arr[max2] < arr[i]) {
            max2 = i;
        }
    }
    System.out.println(arr[max1] + "," + arr[max2]);
}

// 数组求和线性递归
private static int sum1(int[] a, int n) {
    return n < 1 ? 0 : sum1(a, n - 1) + a[n - 1];
}

// 数组求和二分递归
private static int sum2(int[] arr, int low, int high) {
    if (low == high)
        return arr[low];
    int mid = (low + high) >> 1;
    return sum2(arr, low, mid) + sum2(arr, mid + 1, high);
}

// 数组反转递归
private static void reverse(int[] arr, int i, int j) {
    if (i < j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
        reverse(arr, i + 1, j - 1);
    }
}

}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,我可以为您解答关于迭代器、装饰器和冒泡排序的问题。 首先,迭代器是一种可以遍历一个容器中元素的对象,例如列表或字典。要实现一个迭代器,可以定义一个包含 `__iter__()` 和 `__next__()` 方法的类。`__iter__()` 方法返回迭代器对象本身,而 `__next__()` 方法返回下一个元素。 接下来是装饰器。装饰器是一种函数或类,用于包装其他函数或类并修改它们的行为。装饰器函数需要在函数定义之前加上 `@decorator_name` 的语法糖。其作用是不改变源代码的情况下对函数进行增强。 最后是冒泡排序的递归实现。冒泡排序是一种简单的排序算法,基本思想是重复地交换相邻的未按顺序排列的元素。递归实现就是把排序过程分解为更小的子问题,直到子问题可以直接解决为止。 下面是迭代器和装饰器递归实现冒泡排序的 Python 代码: ```python # 定义迭代器 class MyIterator: def __init__(self, my_list): self.list = my_list self.idx = 0 def __iter__(self): return self def __next__(self): if self.idx == len(self.list): raise StopIteration else: self.idx += 1 return self.list[self.idx-1] # 定义装饰器 def my_decorator(func): def wrapper(*args, **kwargs): print("Before function is executed.") result = func(*args, **kwargs) print("After function is executed.") return result return wrapper # 递归实现冒泡排序 @my_decorator def recursive_bubble_sort(l): for i, num in enumerate(l[:-1]): if num > l[i+1]: l[i], l[i+1] = l[i+1], l[i] if len(l) > 1: recursive_bubble_sort(l[:-1]) return l ``` 希望这些信息能够帮助到您,如果您需要进一步的解释,请随时询问。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值