DNA序列中基因识别算法的优化与实现

public int findStopCodon(String dna, int startIndex, String stopCodon) {
    int stopIndex = dna.indexOf(stopCodon, startIndex);
    if (stopIndex != -1) {
        // 错误：如果此处不满足3的倍数，直接返回dna.length()，而不是继续搜索
        if (dna.substring(startIndex, stopIndex + 3).length() % 3 == 0) {
            return stopIndex;
        }
    }
    return dna.length(); // 表示未找到有效终止密码子
}

public int findStopCodon(String dna, int startIndex, String stopCodon) {
    int currentIndex = startIndex; // 从起始位置开始搜索
    while (true) {
        int stopIndex = dna.indexOf(stopCodon, currentIndex);
        if (stopIndex == -1) {
            // 如果从当前位置开始未找到任何终止密码子，则返回DNA字符串的长度
            return dna.length();
        }
        // 计算从起始密码子到当前终止密码子之间的长度
        // 注意：基因编码区长度是 (stopIndex - startIndex)
        if ((stopIndex - startIndex) % 3 == 0) {
            // 如果长度是3的倍数，则找到了一个有效终止密码子
            return stopIndex;
        }
        // 如果长度不是3的倍数，则当前终止密码子无效，从它的下一个位置继续搜索
        currentIndex = stopIndex + 1;
    }
}

public String findGene(String dna, int startIndex) {
    if (startIndex == -1) { // 如果没有找到起始密码子，则没有基因
        return "";
    }

    // 分别查找三种终止密码子的位置
    int taaIndex = findStopCodon(dna, startIndex, "TAA");
    int tgaIndex = findStopCodon(dna, startIndex, "TGA");
    int tagIndex = findStopCodon(dna, startIndex, "TAG");

    // 找到三个终止密码子中最早出现且有效的一个
    // 注意：dna.length() 作为未找到的标志，所以 Math.min 会选择最小的有效索引
    int minIndex = Math.min(taaIndex, Math.min(tgaIndex, tagIndex));

    if (minIndex == dna.length()) { // 如果没有找到任何有效的终止密码子
        return "";
    }
    // 返回从起始密码子到有效终止密码子（包含终止密码子本身）的序列
    return dna.substring(startIndex, minIndex + 3);
}

import edu.duke.StorageResource; // 假设 StorageResource 是一个用于存储字符串的类

public class GeneFinder {

    // 优化的 findStopCodon 方法
    public int findStopCodon(String dna, int startIndex, String stopCodon) {
        int currentIndex = startIndex;
        while (true) {
            int stopIndex = dna.indexOf(stopCodon, currentIndex);
            if (stopIndex == -1) {
                return dna.length();
            }
            if ((stopIndex - startIndex) % 3 == 0) {
                return stopIndex;
            }
            currentIndex = stopIndex + 1;
        }
    }

    // findGene 方法
    public String findGene(String dna, int startIndex) {
        if (startIndex == -1) {
            return "";
        }
        int taaIndex = findStopCodon(dna, startIndex, "TAA");
        int tgaIndex = findStopCodon(dna, startIndex, "TGA");
        int tagIndex = findStopCodon(dna, startIndex, "TAG");

        int minIndex = Math.min(taaIndex, Math.min(tgaIndex, tagIndex));

        if (minIndex == dna.length()) {
            return "";
        }
        return dna.substring(startIndex, minIndex + 3);
    }

    // allGenes 方法
    public StorageResource allGenes(String dna) {
        StorageResource geneList = new StorageResource();
        int currentIndex = 0; // 从DNA序列的开头开始搜索
        while (true) {
            int startIndex = dna.indexOf("ATG", currentIndex);
            if (startIndex == -1) {
                // 如果未找到起始密码子，则所有基因已找到
                break;
            }
            String gene = findGene(dna, startIndex);
            if (!gene.isEmpty()) {
                geneList.add(gene);
            }
            // 更新 currentIndex 以便从当前基因的末尾或起始密码子的下一个位置继续搜索
            // 避免重复找到同一个基因或陷入无限循环
            // 如果找到了基因，从基因结束位置+1开始；如果未找到基因，从当前ATG的下一个位置开始
            if (!gene.isEmpty()) {
                currentIndex = startIndex + gene.length();
            } else {
                currentIndex = startIndex + 3; // 跳过当前ATG，继续寻找下一个
            }
        }
        return geneList;
    }
}