有一个字段是A，有一个队列分别为字符串1，4，3，2.用B.getnext（）方法就可以依次按顺序获取队列。如果A与队列里面的1相等，得到a，与4相等，得到b，与3相等，得到c，与2相等，得到d

好的，我理解了你的问题。你可以使用以下代码实现此功能：

B = ["1", "4", "3", "2"]
mapping = {"1": "a", "4": "b", "3": "c", "2": "d"}

for item in B:
    if item == "1":
        print(mapping["1"])
    elif item == "4":
        print(mapping["4"])
    elif item == "3":
        print(mapping["3"])
    elif item == "2":
        print(mapping["2"])

输出结果将是：a，b，c，d。

这段代码中，我们首先定义了一个列表 `B`，其中包含了需要依次获取的队列元素。然后，我们使用一个字典 `mapping` 将每个队列元素与对应的输出值进行匹配。最后，我们使用循环遍历列表 `B`，并根据元素值从字典 `mapping` 中获取对应的输出值进行输出。

相关问题

定义Java类来实现一个字符串键/值对的哈希表，遵循下面的规范。1. 哈希表： 在一个名为StrHashTable.java的文件中定义一个名为StrHashTable的类。这个类要实现以下方法： insert(String k, String v) - 将字符串键/值对k,v添加到哈希表的适当索引处。不处理碰撞。delete(String k) - 从哈希表中删除一个键/值对，给出键k。hashFunction(String k) - 使用 "folding with strings "方法，创建一个哈希函数，返回字符串k的哈希代码。 ○ rehash() - 当负载率达到75%时，增加哈希表的大小（2倍） ○ contains(String k) - 如果字符串k在哈希表中，返回true，否则返回false。get(String k) - 返回哈希表中的项目，给定键k。isEmpty() - 如果哈希表中没有任何东西，返回true，否则返回false。size()--返回存储在哈希表中的项目数量。dump() - 将哈希表的内容打印到屏幕上，使其符合以下格式： index: key, value 0: key1, value1 1: key2, value2 2: key3, value3 3: ... 2. 节点：为你的StrHashTable中的节点定义一个叫做Node的类。它可以是一个单独文件中的外部类，名为Node.java，也可以是StrHashTable的一个内部类。它应该有以下内容： 一个成员变量来保存字符串的键。一个用于保存字符串值的成员变量。一个构造函数，将键/值对作为两个字符串参数，并将其复制到Node的私有成员变量中。3. 3. 调试： 编写一个程序类，创建一个或多个StrHashTable对象，并确保你的所有方法按照规范工作。例如，你可以写一个程序，从文本文件中读取单词，并将它们放入你的哈希表，计算发生碰撞的次数。

好的，我知道了。下面是实现Java类来实现一个字符串键/值对的哈希表的代码：

StrHashTable.java：

public class StrHashTable {
    private Node[] table;
    private int size;

    public StrHashTable(int initialSize) {
        table = new Node[initialSize];
        size = 0;
    }

    public void insert(String k, String v) {
        int index = hashFunction(k);
        table[index] = new Node(k, v, table[index]);
        size++;
        if (size >= 0.75 * table.length) {
            rehash();
        }
    }

    public void delete(String k) {
        int index = hashFunction(k);
        Node prev = null;
        Node current = table[index];
        while (current != null && !current.key.equals(k)) {
            prev = current;
            current = current.next;
        }
        if (current != null) {
            if (prev == null) {
                table[index] = current.next;
            } else {
                prev.next = current.next;
            }
            size--;
        }
    }

    public int hashFunction(String k) {
        int hash = 0;
        for (int i = 0; i < k.length(); i++) {
            hash += k.charAt(i);
        }
        return hash % table.length;
    }

    private void rehash() {
        Node[] oldTable = table;
        table = new Node[2 * oldTable.length];
        size = 0;
        for (int i = 0; i < oldTable.length; i++) {
            Node current = oldTable[i];
            while (current != null) {
                insert(current.key, current.value);
                current = current.next;
            }
        }
    }

    public boolean contains(String k) {
        int index = hashFunction(k);
        Node current = table[index];
        while (current != null) {
            if (current.key.equals(k)) {
                return true;
            }
            current = current.next;
        }
        return false;
    }

    public String get(String k) {
        int index = hashFunction(k);
        Node current = table[index];
        while (current != null) {
            if (current.key.equals(k)) {
                return current.value;
            }
            current = current.next;
        }
        return null;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }

    public void dump() {
        for (int i = 0; i < table.length; i++) {
            Node current = table[i];
            System.out.print(i + ": ");
            while (current != null) {
                System.out.print(current.key + ", " + current.value + " ");
                current = current.next;
            }
            System.out.println();
        }
    }

    private class Node {
        private String key;
        private String value;
        private Node next;

        public Node(String k, String v, Node n) {
            key = k;
            value = v;
            next = n;
        }
    }
}

Node.java：

public class Node {
    private String key;
    private String value;
    private Node next;

    public Node(String k, String v, Node n) {
        key = k;
        value = v;
        next = n;
    }

    public String getKey() {
        return key;
    }

    public String getValue() {
        return value;
    }

    public Node getNext() {
        return next;
    }
}

测试程序：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        StrHashTable table = new StrHashTable(16);
        int collisions = 0;
        try {
            BufferedReader reader = new BufferedReader(new FileReader("words.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                String[] words = line.split("\\s+");
                for (int i = 0; i < words.length; i++) {
                    if (table.contains(words[i])) {
                        collisions++;
                    }
                    table.insert(words[i], "");
                }
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("Collisions: " + collisions);
        System.out.println("Size: " + table.size());
        System.out.println("Empty: " + table.isEmpty());
        System.out.println("Contains \"the\": " + table.contains("the"));
        System.out.println("Get \"the\": " + table.get("the"));
        table.dump();
    }
}

注意：此代码仅供参考，实际使用时需要根据实际情况进行修改。

用C语言实现字符串模式匹配，给定主串s和模式串p，编写程序输出p在s中出现的首位置，若p不在s中则输出-1。字符串下标从0开始。 输入格式: 输入为2行，第1行主串s，第2行为模式串p。主串和模式串...

好的，这是一个经典的字符串匹配问题，可以使用 KMP 算法来解决。以下是实现该算法的 C 代码：

#include <stdio.h>
#include <string.h>

void getNext(char* p, int* next) {
    int i = 0, j = -1;
    next[0] = -1;
    while (p[i]) {
        if (j == -1 || p[i] == p[j]) {
            i++;
            j++;
            next[i] = j;
        } else {
            j = next[j];
        }
    }
}

int kmp(char* s, char* p) {
    int slen = strlen(s);
    int plen = strlen(p);
    int next[plen + 1];
    getNext(p, next);
    int i = 0, j = 0;
    while (i < slen && j < plen) {
        if (j == -1 || s[i] == p[j]) {
            i++;
            j++;
        } else {
            j = next[j];
        }
    }
    if (j == plen) {
        return i - j;
    } else {
        return -1;
    }
}

int main() {
    char s[1000], p[1000];
    fgets(s, sizeof(s), stdin);
    fgets(p, sizeof(p), stdin);
    s[strlen(s) - 1] = '\0';
    p[strlen(p) - 1] = '\0';
    int pos = kmp(s, p);
    printf("%d\n", pos);
    return 0;
}

输入的第一行为主串 s，第二行为模式串 p，使用 fgets 函数读入字符串，并将最后一个字符（\n）替换为 \0。然后调用 kmp 函数进行匹配，返回匹配结果。getNext 函数用于计算模式串的 next 数组，用于优化匹配。