Hướng dẫn recursion javascript w3schools – đệ quy javascript w3schools

Chức năng đệ quy

Go chấp nhận các chức năng đệ quy. Một hàm được đệ quy nếu nó tự gọi và đạt đến điều kiện dừng.

Nội dung chính

Show

• Chức năng đệ quy
• Khi hàm public class Main {
  public static void main(String[] args) {
  int result = sum(5, 10);
  System.out.println(result);
  }
  public static int sum(int start, int end) {
  if (end > start) {
  return end + sum(start, end – 1);
  } else {
  return end;
  }
  }
  }1 được gọi, nó sẽ thêm tham số public class Main {
  public static void main(String[] args) {
  int result = sum(5, 10);
  System.out.println(result);
  }
  public static int sum(int start, int end) {
  if (end > start) {
  return end + sum(start, end – 1);
  } else {
  return end;
  }
  }
  }2 vào tổng của tất cả các số nhỏ hơn public class Main {
  public static void main(String[] args) {
  int result = sum(5, 10);
  System.out.println(result);
  }
  public static int sum(int start, int end) {
  if (end > start) {
  return end + sum(start, end – 1);
  } else {
  return end;
  }
  }
  }2 và trả về kết quả. Khi K trở thành 0, hàm chỉ trả về 0. Khi chạy, chương trình tuân theo các bước sau:
• Điều kiện tạm dừng
• Ví dụ giải thích
• Điều kiện tạm dừng

Trong ví dụ sau, testcount() là một hàm tự gọi. Chúng tôi sử dụng biến x làm dữ liệu, tăng theo 1 (x + 1) mỗi khi chúng tôi tái diễn. Đệ quy kết thúc khi biến x bằng 11 (________ 6). & Nbsp;

Thí dụ

Gói nhập chính (“FMT”)
import (“fmt”)

func testCount (x int) int {& nbsp; if x == 11 {& nbsp; & nbsp; & nbsp; trả về 0 & nbsp; } & nbsp; fmt.println (x) & nbsp; trả về testCount (x + 1)}
  if x == 11 {
    return 0
  }
  fmt.Println(x)
  return testcount(x + 1)
}

func main () {& nbsp; testcount (1)}
  testcount(1)
}

Result:


1
2
3
4
5
6
7
8
9
10

Hãy tự mình thử »

Recursion là một khái niệm toán học và lập trình phổ biến. Điều này có lợi ích của ý nghĩa mà bạn có thể lặp qua dữ liệu để đạt được kết quả.

Nhà phát triển nên cẩn thận với các chức năng đệ quy vì nó có thể khá dễ dàng để viết một chức năng không bao giờ kết thúc, hoặc một chức năng sử dụng lượng bộ nhớ hoặc nguồn bộ xử lý dư thừa. Tuy nhiên, khi được viết chính xác đệ quy có thể là một cách tiếp cận rất hiệu quả và về mặt toán học để lập trình.

Trong ví dụ sau, factorial_recursion() là một hàm tự gọi. Chúng tôi sử dụng biến x làm dữ liệu, giảm (-1) mỗi khi chúng tôi tái diễn. Đệ quy kết thúc khi điều kiện không lớn hơn 0 (nghĩa là khi nó là 0).

Thí dụ

Gói nhập chính (“FMT”)
import (“fmt”)

func testCount (x int) int {& nbsp; if x == 11 {& nbsp; & nbsp; & nbsp; trả về 0 & nbsp; } & nbsp; fmt.println (x) & nbsp; trả về testCount (x + 1)}
  if x > 0 {
     y = x * factorial_recursion(x-1)
  } else {
     y = 1
  }
  return
}

func main () {& nbsp; testcount (1)}
  fmt.Println(factorial_recursion(4))
}

Hãy tự mình thử »

public class Main {
  public static void main(String[] args) {
    int result = sum(5, 10);
    System.out.println(result);
  }
  public static int sum(int start, int end) {
    if (end > start) {
      return end + sum(start, end - 1);
    } else {
      return end;
    }
  }
}

0

Hãy tự mình thử »

Recursion là một khái niệm toán học và lập trình phổ biến. Điều này có lợi ích của ý nghĩa mà bạn có thể lặp qua dữ liệu để đạt được kết quả.

Khi hàm public class Main {
public static void main(String[] args) {
int result = sum(5, 10);
System.out.println(result);
}
public static int sum(int start, int end) {
if (end > start) {
return end + sum(start, end – 1);
} else {
return end;
}
}
}1 được gọi, nó sẽ thêm tham số public class Main {
public static void main(String[] args) {
int result = sum(5, 10);
System.out.println(result);
}
public static int sum(int start, int end) {
if (end > start) {
return end + sum(start, end – 1);
} else {
return end;
}
}
}2 vào tổng của tất cả các số nhỏ hơn public class Main {
public static void main(String[] args) {
int result = sum(5, 10);
System.out.println(result);
}
public static int sum(int start, int end) {
if (end > start) {
return end + sum(start, end – 1);
} else {
return end;
}
}
}2 và trả về kết quả. Khi K trở thành 0, hàm chỉ trả về 0. Khi chạy, chương trình tuân theo các bước sau:

10 + tổng (9) 10 + (9 + tổng (8)) 10 + (9 + (8 + tổng (7))) … 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + tổng (0) 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0

Vì hàm không tự gọi khi

public class Main {
  public static void main(String[] args) {
    int result = sum(5, 10);
    System.out.println(result);
  }
  public static int sum(int start, int end) {
    if (end > start) {
      return end + sum(start, end - 1);
    } else {
      return end;
    }
  }
}

2 là 0, chương trình dừng ở đó và trả về kết quả.

Điều kiện tạm dừng

Giống như các vòng lặp có thể chạy vào vấn đề vòng lặp vô hạn, các hàm đệ quy có thể gặp phải vấn đề đệ quy vô hạn. Đệ quy vô hạn là khi chức năng không bao giờ ngừng tự gọi. Mỗi chức năng đệ quy nên có một điều kiện tạm dừng, đó là điều kiện mà chức năng ngừng tự gọi. Trong ví dụ trước, điều kiện tạm dừng là khi tham số

public class Main {
  public static void main(String[] args) {
    int result = sum(5, 10);
    System.out.println(result);
  }
  public static int sum(int start, int end) {
    if (end > start) {
      return end + sum(start, end - 1);
    } else {
      return end;
    }
  }
}

2 trở thành 0.

Thí dụ

Sử dụng đệ quy để thêm tất cả các số lên đến 10.

public class Main {
  public static void main(String[] args) {
    int result = sum(10);
    System.out.println(result);
  }
  public static int sum(int k) {
    if (k > 0) {
      return k + sum(k - 1);
    } else {
      return 0;
    }
  }
}

Hãy tự mình thử »

Ví dụ giải thích

Khi hàm

public class Main {
  public static void main(String[] args) {
    int result = sum(5, 10);
    System.out.println(result);
  }
  public static int sum(int start, int end) {
    if (end > start) {
      return end + sum(start, end - 1);
    } else {
      return end;
    }
  }
}

1 được gọi, nó sẽ thêm tham số

public class Main {
  public static void main(String[] args) {
    int result = sum(5, 10);
    System.out.println(result);
  }
  public static int sum(int start, int end) {
    if (end > start) {
      return end + sum(start, end - 1);
    } else {
      return end;
    }
  }
}

2 vào tổng của tất cả các số nhỏ hơn

public class Main {
  public static void main(String[] args) {
    int result = sum(5, 10);
    System.out.println(result);
  }
  public static int sum(int start, int end) {
    if (end > start) {
      return end + sum(start, end - 1);
    } else {
      return end;
    }
  }
}

2 và trả về kết quả. Khi K trở thành 0, hàm chỉ trả về 0. Khi chạy, chương trình tuân theo các bước sau:

10 + tổng (9) 10 + (9 + tổng (8)) 10 + (9 + (8 + tổng (7))) … 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + tổng (0) 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0
10 + ( 9 + sum(8) )
10 + ( 9 + ( 8 + sum(7) ) )
…
10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + sum(0)
10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0

Vì hàm không tự gọi khi

public class Main {
  public static void main(String[] args) {
    int result = sum(5, 10);
    System.out.println(result);
  }
  public static int sum(int start, int end) {
    if (end > start) {
      return end + sum(start, end - 1);
    } else {
      return end;
    }
  }
}

2 là 0, chương trình dừng ở đó và trả về kết quả.

Điều kiện tạm dừng

Giống như các vòng lặp có thể chạy vào vấn đề vòng lặp vô hạn, các hàm đệ quy có thể gặp phải vấn đề đệ quy vô hạn. Đệ quy vô hạn là khi chức năng không bao giờ ngừng tự gọi. Mỗi chức năng đệ quy nên có một điều kiện tạm dừng, đó là điều kiện mà chức năng ngừng tự gọi. Trong ví dụ trước, điều kiện tạm dừng là khi tham số

public class Main {
  public static void main(String[] args) {
    int result = sum(5, 10);
    System.out.println(result);
  }
  public static int sum(int start, int end) {
    if (end > start) {
      return end + sum(start, end - 1);
    } else {
      return end;
    }
  }
}

2 trở thành 0.

Thật hữu ích khi thấy một loạt các ví dụ khác nhau để hiểu rõ hơn về khái niệm này. Trong ví dụ này, hàm thêm một loạt các số giữa bắt đầu và kết thúc. Điều kiện tạm dừng cho hàm đệ quy này là khi kết thúc không lớn hơn bắt đầu:end is not greater than start:

Thí dụ

Sử dụng đệ quy để thêm tất cả các số từ 5 đến 10.

public class Main {
  public static void main(String[] args) {
    int result = sum(5, 10);
    System.out.println(result);
  }
  public static int sum(int start, int end) {
    if (end > start) {
      return end + sum(start, end - 1);
    } else {
      return end;
    }
  }
}

Hãy tự mình thử »

Nhà phát triển nên rất cẩn thận với đệ quy vì có thể khá dễ dàng để viết một chức năng không bao giờ chấm dứt hoặc sử dụng lượng bộ nhớ hoặc nguồn bộ xử lý dư thừa. Tuy nhiên, khi được viết chính xác đệ quy có thể là một cách tiếp cận rất hiệu quả và về mặt toán học để lập trình.