帮我写一段提取蛋白复合物结构中单链，使用biopython

好的，以下是使用Biopython提取蛋白复合物结构中单链的示例代码：

from Bio.PDB import *

# 读取PDB文件
parser = PDBParser()
structure = parser.get_structure("complex", "complex.pdb")

# 提取单链
model = structure[0]
chains = model.get_chains()

for chain in chains:
    # 将单链写入PDB文件
    io = PDBIO()
    io.set_structure(chain)
    io.save(chain.get_id() + ".pdb")

以上代码将读取名为"complex.pdb"的PDB文件，然后提取每个单链并将其写入单独的PDB文件中。你可以将文件名和路径替换为你自己的文件名和路径。在这个示例中，我们使用`PDBParser`类来读取PDB文件，然后使用`get_chains`方法获取每个单链并将其写入单独的PDB文件。

相关问题

请帮我写一段单链表模板程序

好的，以下是一个单链表的模板程序，可以根据需要进行修改：

#include <iostream>
using namespace std;

//定义单链表节点结构体
template <typename T>
struct ListNode {
    T val;
    ListNode* next;
    ListNode(T x) : val(x), next(nullptr) {}
};

//定义单链表类
template <typename T>
class LinkedList {
public:
    LinkedList() : head(nullptr), tail(nullptr), size(0) {}
    ~LinkedList() {
        ListNode<T>* cur = head;
        while (cur) {
            ListNode<T>* temp = cur;
            cur = cur->next;
            delete temp;
        }
        head = tail = nullptr;
        size = 0;
    }

    //在链表尾部添加节点
    void add(T x) {
        ListNode<T>* node = new ListNode<T>(x);
        if (!head) {
            head = tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
        size++;
    }

    //删除链表中所有值为x的节点
    void remove(T x) {
        ListNode<T>* cur = head;
        ListNode<T>* pre = nullptr;
        while (cur) {
            if (cur->val == x) {
                if (cur == head) {
                    head = head->next;
                } else if (cur == tail) {
                    tail = pre;
                    tail->next = nullptr;
                } else {
                    pre->next = cur->next;
                }
                ListNode<T>* temp = cur;
                cur = cur->next;
                delete temp;
                size--;
            } else {
                pre = cur;
                cur = cur->next;
            }
        }
    }

    //打印链表中所有节点的值
    void print() {
        ListNode<T>* cur = head;
        while (cur) {
            cout << cur->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }

    //返回链表的长度
    int getSize() {
        return size;
    }

private:
    ListNode<T>* head;
    ListNode<T>* tail;
    int size;
};

int main() {
    LinkedList<int> list;
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.print(); //输出：1 2 3 4
    list.remove(2);
    list.print(); //输出：1 3 4
    cout << "size: " << list.getSize() << endl; //输出：size: 3
    return 0;
}

该程序定义了一个单链表的模板类，包括添加节点、删除节点、打印链表和返回链表长度等基本操作。其中，ListNode为单链表节点结构体，LinkedList为单链表类，使用模板类实现了支持任意类型的节点值。

帮我写一段代码完成一个单链表的堆排序

好的，以下是一个单链表堆排序的示例代码：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def heap_sort(head):
    if not head:
        return None
    heap = []
    cur = head
    while cur:
        heap.append(cur.val)
        cur = cur.next
    n = len(heap)
    # 建立小根堆
    for i in range(n // 2 - 1, -1, -1):
        heapify(heap, n, i)
    # 堆排序
    for i in range(n - 1, 0, -1):
        heap[0], heap[i] = heap[i], heap[0]
        heapify(heap, i, 0)
    # 构建排序后的链表
    dummy = ListNode(0)
    cur = dummy
    for val in heap:
        cur.next = ListNode(val)
        cur = cur.next
    return dummy.next

def heapify(heap, n, i):
    smallest = i
    left = 2 * i + 1
    right = 2 * i + 2
    if left < n and heap[left] < heap[smallest]:
        smallest = left
    if right < n and heap[right] < heap[smallest]:
        smallest = right
    if smallest != i:
        heap[i], heap[smallest] = heap[smallest], heap[i]
        heapify(heap, n, smallest)

使用方法：

l = ListNode(4, ListNode(2, ListNode(1, ListNode(3))))
l_sorted = heap_sort(l)

这个算法的时间复杂度为 O(nlogn)，其中 n 是链表的长度。