Hướng dẫn recursively iterate through list python - đệ quy lặp qua danh sách python

Nói rằng tôi có danh sách x = [1, 2, 3, 4]

Có một phương pháp đệ quy nơi tôi có thể đi qua danh sách để tìm giá trị?

Cuối cùng tôi muốn có thể so sánh một giá trị được trả về trong danh sách, [hoặc danh sách lồng nhau] với một số tùy ý để xem nó phù hợp.

Tôi có thể nghĩ một cách để làm điều này bằng cách sử dụng một vòng lặp, nhưng tôi gặp khó khăn trong việc tưởng tượng một phương pháp đệ quy để làm điều tương tự. Tôi biết rằng tôi không thể đặt một bộ đếm để theo dõi vị trí của mình trong danh sách vì gọi chức năng đệ quy sẽ đặt lại bộ đếm mỗi lần.

Tôi đã nghĩ rằng tôi có thể đặt trường hợp cơ sở của mình về hàm như là một so sánh giữa số và danh sách Len 1.

Tôi chỉ muốn một số gợi ý thực sự.

Đã hỏi ngày 4 tháng 2 năm 2014 lúc 20:59Feb 4, 2014 at 20:59

2

Đây không phải là cách để làm mọi thứ trong Python, nhưng chắc chắn - bạn có thể đi qua danh sách các danh sách đệ quy:

def findList[lst, ele]:
    if not lst:         # base case: the list is empty
        return False
    elif lst[0] == ele: # check if current element is the one we're looking
        return True
    elif not isinstance[lst[0], list]: # if current element is not a list
        return findList[lst[1:], ele]
    else:                              # if current element is a list
        return findList[lst[0], ele] or findList[lst[1:], ele]

Đã trả lời ngày 4 tháng 2 năm 2014 lúc 21:02Feb 4, 2014 at 21:02

Óscar Lópezóscar LópezÓscar López

229K35 Huy hiệu vàng307 Huy hiệu bạc380 Huy hiệu Đồng35 gold badges307 silver badges380 bronze badges

1

Các hàm đệ quy là thành ngữ khi bạn có một danh sách được liên kết. Danh sách Python giống như mảng hơn. Nhưng vẫn có thể xử lý một danh sách Python với chức năng đệ quy - không có tiện ích thực sự, nhưng nó có thể thú vị như một bài tập.

Bạn bắt đầu với một danh sách đầy đủ và trường hợp cơ sở của bạn là khi danh sách trống. Đi qua danh sách bằng cách chuyển danh sách trong một đối số, sử dụng

Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

0 để tìm nạp đồng thời và xóa mục đầu tiên trong danh sách, đánh giá mục popped, sau đó chuyển danh sách [giờ ngắn hơn] vào cùng một hàm.

Chỉnh sửa: Trên thực tế, trên suy nghĩ thứ hai, bạn sẽ tốt hơn khi không sử dụng x.pop [] và thay vào đó là nhìn trộm ở giá trị thứ nhất và chuyển phần còn lại trong một lát cắt. Điều này sẽ không hiệu quả, bởi vì bạn đang sao chép danh sách mỗi khi bạn cắt lát, nhưng nó tốt hơn là tiêu thụ phá hủy danh sách bên trong chức năng đệ quy của bạn, trừ khi đó là tác dụng phụ mong muốn.

Đã trả lời ngày 4 tháng 2 năm 2014 lúc 21:03Feb 4, 2014 at 21:03

Andrew Gorcesterandrew GorcesterAndrew Gorcester

Huy hiệu vàng 19.2K755 Huy hiệu bạc71 Huy hiệu đồng7 gold badges55 silver badges71 bronze badges

Vâng, bạn sẽ có hai trường hợp cơ sở:

1] Bạn đã đạt đến cuối danh sách => Trả về Sai.

2] Phần tử hiện tại của bạn là phần tử bạn đang tìm kiếm => Trả về True [hoặc phần tử hoặc vị trí của nó, bất cứ điều gì bạn quan tâm].

Điều bạn phải làm tất cả thời gian là kiểm tra cả hai trường hợp cơ sở trên phần tử hiện tại và áp dụng chức năng đệ quy trên phần tử tiếp theo trong danh sách nếu không một trong các trường hợp cơ sở được áp dụng.

Đã trả lời ngày 4 tháng 2 năm 2014 lúc 21:05Feb 4, 2014 at 21:05

FedorsmirnovfedorsmirnovfedorSmirnov

6912 Huy hiệu vàng9 Huy hiệu bạc19 Huy hiệu đồng2 gold badges9 silver badges19 bronze badges

Ngăn xếp lỗi tràn trong hàm đệ quy

Một hàm đệ quy được gọi với đầu vào yêu cầu quá nhiều lần lặp sẽ khiến ngăn xếp cuộc gọi trở nên quá lớn, dẫn đến lỗi tràn ngăn xếp. Trong những trường hợp này, việc sử dụng một giải pháp lặp lại là thích hợp hơn. Một giải pháp đệ quy chỉ phù hợp cho một vấn đề không vượt quá một số lượng cuộc gọi đệ quy nhất định.

Ví dụ:

Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

1 bên dưới ném lỗi tràn ngăn xếp khi đầu vào 1000 được sử dụng.

def myfunction[n]:
  if n == 0:
    return n
  else:
    return myfunction[n-1]
myfunction[1000]  

Trình tự Fibonacci

Trình tự Fibonacci là một chuỗi các số toán học sao cho mỗi số là tổng của hai số trước, bắt đầu từ 0 và 1.

Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

Gọi xây dựng ngăn xếp trong khi vòng lặp

Một ngăn xếp cuộc gọi với bối cảnh thực thi có thể được xây dựng bằng cách sử dụng vòng lặp

Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

2,

Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

3 để biểu thị ngăn xếp cuộc gọi và

Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

4 để biểu thị bối cảnh thực thi. Điều này rất hữu ích để bắt chước vai trò của một ngăn xếp cuộc gọi bên trong hàm đệ quy.

Cây tìm kiếm nhị phân

Trong Python, một cây tìm kiếm nhị phân là một cấu trúc dữ liệu đệ quy giúp các danh sách được sắp xếp dễ dàng hơn để tìm kiếm. Cây tìm kiếm nhị phân:

• Tham khảo hai đứa trẻ nhất trên mỗi nút cây.
• Con trái cây trái của cây phải chứa một giá trị thấp hơn cha mẹ của nó.
• Đứa trẻ bên phải của cây phải chứa một giá trị lớn hơn cha mẹ của nó.

     5
    / \
   /   \
  3     8
 / \   / \
2   4 7   9

Danh sách đệ quy và lồng nhau

Một danh sách lồng nhau có thể được đi qua và làm phẳng bằng hàm đệ quy. Trường hợp cơ sở đánh giá một yếu tố trong danh sách. Nếu nó không phải là một danh sách khác, phần tử duy nhất được thêm vào một danh sách phẳng. Bước đệ quy gọi hàm đệ quy với phần tử danh sách lồng nhau là đầu vào.

def flatten[mylist]:
  flatlist = []
  for element in mylist:
    if type[element] == list:
      flatlist += flatten[element]
    else:
      flatlist += element
  return flatlist
print[flatten[['a', ['b', ['c', ['d']], 'e'], 'f']]]

Đệ quy Fibonacci

Tính toán giá trị của số Fibonacci có thể được thực hiện bằng cách sử dụng đệ quy. Với đầu vào của Index N, hàm đệ quy có hai trường hợp cơ sở - khi chỉ mục bằng 0 hoặc 1. Hàm đệ quy trả về tổng của chỉ số trừ 1 và chỉ số trừ 2.

Thời gian chạy lớn của hàm Fibonacci là O [2^n].

def fibonacci[n]:
  if n  0 : 
    call_stack.append[{"input":value}]
    print["Call Stack:",call_stack]
    value -= 1
  print["Base Case Reached"]
  while len[call_stack] != 0:
    print["Popping {} from call stack".format[call_stack.pop[]]]
    print["Call Stack:",call_stack]
countdown[4]
'''
Call Stack: [{'input': 4}]             
Call Stack: [{'input': 4}, {'input': 3}]         
Call Stack: [{'input': 4}, {'input': 3}, {'input': 2}]     
Call Stack: [{'input': 4}, {'input': 3}, {'input': 2}, {'input': 1}]                                
Base Case Reached                                  
Popping {'input': 1} from call stack                       
Call Stack: [{'input': 4}, {'input': 3}, {'input': 2}]  
Popping {'input': 2} from call stack                   
Call Stack: [{'input': 4}, {'input': 3}]       
Popping {'input': 3} from call stack            
Call Stack: [{'input': 4}]                                 
Popping {'input': 4} from call stack              
Call Stack: []
'''

Đệ quy trong Python

Trong Python, một hàm đệ quy chấp nhận một đối số và bao gồm một điều kiện để kiểm tra xem nó có khớp với trường hợp cơ sở hay không. Một hàm đệ quy có:

• Trường hợp cơ sở - Một điều kiện đánh giá đầu vào hiện tại để ngăn chặn đệ quy tiếp tục.
• Bước đệ quy - Một hoặc nhiều cuộc gọi đến hàm đệ quy để đưa đầu vào gần hơn với trường hợp cơ sở.

def countdown[value]:
  if value