一个缓存结构需要实现如下功能。 set(key, value)：将记录(key, value)插入该结构 get(key)：返回key对应的value值 但是缓存结构中最多放K条记录，如果新的第K+1...

实现一个缓存结构可以使用哈希表和双向链表的组合来实现。哈希表用于快速查询key是否存在以及对应的value值，而双向链表用于维护缓存数据的顺序。

具体实现方法如下：

1. 定义一个双向链表节点类，包含key、value、前驱节点和后继节点四个属性。

2. 定义一个哈希表，用于存储每个key对应的节点。

3. 定义一个双向链表，用于维护缓存数据的顺序。链表头表示最近使用的缓存，链表尾表示最久未使用的缓存。

4. 实现set(key, value)方法。当插入一个新的记录时，首先判断是否已经存在该key值，如果存在则更新value值，否则新建一个节点，并将其插入到哈希表和双向链表的头部。如果缓存已满，需要删除最久未使用的缓存，即链表尾部的节点，并从哈希表中删除该节点对应的key值。

5. 实现get(key)方法。当查询一个记录时，首先在哈希表中查找是否存在该key值，如果存在，则将该节点移动到链表头部，并返回对应的value值。如果不存在，则返回-1或抛出异常等错误提示。

代码实现如下：

class Node:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}
        self.head = Node(None, None)
        self.tail = Node(None, None)
        self.head.next = self.tail
        self.tail.prev = self.head

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self.move_to_head(node)
        return node.value

    def set(self, key: int, value: int) -> None:
        if key in self.cache:
            node = self.cache[key]
            node.value = value
            self.move_to_head(node)
        else:
            node = Node(key, value)
            self.cache[key] = node
            self.add_to_head(node)
            if len(self.cache) > self.capacity:
                node = self.remove_tail()
                del self.cache[node.key]

    def add_to_head(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node

    def remove_node(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

    def move_to_head(self, node):
        self.remove_node(node)
        self.add_to_head(node)

    def remove_tail(self):
        node = self.tail.prev
        self.remove_node(node)
        return node

在上述代码中，LRUCache类实现了一个缓存结构，使用双向链表和哈希表实现了set和get两个方法。其中，add_to_head方法将一个节点插入到链表头部，remove_node方法删除一个节点，move_to_head方法将一个节点移动到链表头部，remove_tail方法删除链表尾部的节点。在set方法中，当缓存已满时，使用remove_tail方法删除最久未使用的节点，并从哈希表中删除该节点对应的key值。