在不使用内置函数的情况下在python中递归合并两个字符串

Question

在名为concat_strings.py的文件中编写 Python 程序，其中包含以下函数：

orderedConcat ，一个递归函数，它接受两个按字母顺序排列的字符串并合并它们，让字母按字母顺序排列。 请注意，字符串的长度可能不同。

输入两个有序字符串并调用orderedConcat方法以返回结果合并的有序字符串的主要方法。 您的主要方法应该打印两个输入字符串和结果。

注意：您不能使用任何内置方法进行字符串连接或排序，但可以使用len()函数和切片运算符 (:)。 您可以假设输入字符串已经排序。

示例输入/输出：

Enter the first ordered string: DEab
Enter the second ordered string: BFxz
First string: DEab
Second string: BFxz
Result: BDEFabxz

注意：我对编程完全陌生，并且很难弄清楚这一点。 理论上，字符串必须加在一起，但我如何按字母顺序对它们进行排序？ 如何处理大写和小写字母？ 我使用选择排序还是归并排序？ 我的基本情况和递归情况应该是什么？ 任何帮助将不胜感激。

到目前为止我尝试过的东西（不多，但我尽我所能）：

def orderedConcat(length):
    newString = string1 + string2
    length = len(newString)
    if length == 1 or length == "":
        return True
    elif length[0] <= length[1]:
        return orderedConcat(length[1:])
    else:
        return False

def main():
    string1 = "acdrt"
    string2 = "bdet"
    print("First string: ", string1)
    print("Second string: ", string2)
    print(newString)
main()

Answer 1

让我们一步一步来。 首先，我们的函数接受两个字符串，我们称它们为a和b ：

def orderedConcat(a, b):

在编写递归函数时，我们通常从基本情况开始。 在这种情况下，有两种基本情况：

1. a是空的，因此不需要合并，我们可以只返回b （因为b已排序）。
2. b为空，遵循与案例 1 相同的逻辑并返回a 。

在代码中：

if len(a) == 0:
    return b
elif len(b) == 0:
    return a
else:
    # ...

现在，对于递归情况，我们需要比较字符串a[0]和b[0]的第一个元素。 如果a[0] < b[0] （Python 已经为我们在字符串上实现了< ！注意'A' < 'a' ），那么a[0]需要被添加到输出字符串之前。 否则，需要预先添加b[0] 。

if a[0] < b[0]:
    return a[0] + ...
else:
    return b[0] + ...

我们仍然需要填写... . 在编写递归函数时，在脑海中假装已经编写了一个可以使用的工作函数是很有用的。 在这种情况下，请考虑“ orderedConcat的结果是a[0]和b[0]较小的a[0] ， orderedConcat到a / b其余部分的orderedConcat之前。

因此：

if a[0] < b[0]:
    return a[0] + orderedConcat(a[1:], b)
else:
    return b[0] + orderedConcat(a, b[1:])

Answer 2

我不知道如何递归处理大写和小写，但这可能是一个快速的解决方法。

def orderedConcat(string1, string2):
    if len(string1 + string2) == 0:
        return ''
    elif (len(string1) > 0 and len(string2) == 0) or (len(string1) == 0 and len(string2) > 0):
        return string1 + string2
    else:
        if string1[0] < string2[0]:
            return string1[0] + orderedConcat(string1[1:], string2)
        elif string2[0] < string1[0]:
            return string2[0] + orderedConcat(string1, string2[1:])
        else: # if they're equal
            return string1[0] + string2[0] + \
                orderedConcat(string1[1:], string2[1:])


def main():
    string1 = "acdrt"
    string2 = "bdet"
    print("First string: ", string1)
    print("Second string: ", string2)
    print("Result : ", end=' ')
    print(orderedConcat("acdrt", "bdet"))


main()

Answer 3

看看你的功能：

def orderedConcat(length):
    newString = string1 + string2
    length = len(newString) #cut

首先，您必须将字符串传递到您的函数中，而不是长度。 所以，从定义开始。 而且，为了在概念上更简单一些，让我们声明一个静态变量，一个空字符串来保存最终的连接，排序结果，使用 Python 范围规则（全局允许字符串newString在多个函数调用中持久化和增长，而不是被在每次调用时重新初始化）：

newString = ''          #outside of function
def oC(st1, st2):
    global newString    #scope modifier global

其次，任何递归问题的第一步是确定将停止递归的基本情况，这样您就不会无限递归。 由于我们正在处理字符串，并且会将它们切碎，因此基本情况将取决于 len。 此外，字符串是单独排序的，所以剩下的任何东西（如果一个比另一个长）都不是问题，我们只需将剩余的部分放在我们的 concat 上：

    if len(st1) == 0:
        newString += st2
        return
    elif len(st2) == 0:
        newString += st1
        return

整理出基本情况后，任何递归问题的下一步都是按顺序缩短问题 - 将其分解成越来越小的部分，以便最终达到基本情况。 这里我们可以使用切片操作符顺序比较字符串元素，并缩短字符串以反馈给函数：

    elif st1[:1] <= st2[:1]:
        newString = newString + st1[:1]
        return oC(st1[1:], st2[:])  #shorten here
    else: 
        newString = newString + st2[:1]
        return oC(st1[:], st2[1:])

要调用它，您必须说：

newString = ""
oC(st1, st2)

这有点不方便。 看看您是否可以弄清楚如何消除此代码中函数中的外部 concat 字符串和 global 的需要。

Answer 4

您的示例不是按字母顺序排序，而是按ASCIIbetical排序。 这很好，因为它简化了我们的问题。 与其让len()函数成为例外，我们也不要使用它：

def orderedConcat(a, b):
    if a:
        if b:
            if a[:1] < b[:1]:
                return a[:1] + orderedConcat(a[1:], b)

            return b[:1] + orderedConcat(a, b[1:])
        return a
    return b

print(orderedConcat('DEab', 'BFxz'))