Python字符串重排问题：双数组处理逻辑及代码纠错求助

给定一个字符串，需创建两个并行数组，按以下规则从左到右逐个处理字符：

1. 将每个字符按字母顺序插入第一个数组（若字符已存在，则插在现有该字符的前面）
2. 同时为第二个数组赋值：
   • 第一个字符的值为0
   • 若新字符插入后位于数组首尾，值为相邻字符的值+1
   • 若新字符在数组中间，值为左右相邻两值的较大值+1
3. 最终按第二个数组的值从小到大输出字符（同值的字符按插入顺序排列）

示例：输入"PYTHONN"，输出"PHYOTNN"

我尝试用if-else实现，但代码混乱且报错，代码如下：

def ltnb(i):
    return i.split()

def listByValue(input):
    process_str=input
    converted_list=[]
    test_v=[]
    arr_1=[]
    arr_2=[]
    full_list=[]
    x=0
    for letter in process_str:
        test_v.clear()
        for i in converted_list:
            test_v.append(ltnb(i)[0])
        test_v.append(letter)
        test_v.sort()
        
        if len(converted_list)==0:
            number=0
        elif x==0:
            x=test_v.index(letter)
            number=int(ltnb(converted_list[x-1])[1])+1
        elif x==len(converted_list):
            x=test_v.index(letter)
            number=int(ltnb(converted_list[x])[1])+1
        else:
            x=test_v.index(letter)
            number=max(int(ltnb(converted_list[x-1])[1]), int(ltnb(converted_list[x])[1]))  
        converted_list.insert(x, f"{letter} {number}")
        for i in range(0,len(converted_list)):
            ltnb(converted_list)[1]

我不清楚该如何返回正确结果，请问我的代码存在哪些问题？该如何解决这个问题？

1. 数据结构设计不合理：用字符串拼接（f"{letter} {number}"）存储字符和值，拆分、操作时容易出错，完全违背了题目要求的「并行数组」设计思路。
2. 插入位置逻辑混乱：变量x的初始化和更新逻辑错误，旧值会干扰后续边界判断，没有每次重新计算正确的插入位置。
3. 边界条件处理错误：插入首尾时的取值逻辑搞反，比如插在开头时错误取左边不存在的元素，导致索引越界。
4. 无效代码冗余：最后那个遍历converted_list的循环完全没有作用，既不赋值也不返回结果。
5. 无结果返回：函数没有任何返回语句，无法输出最终处理后的字符串。

直接用两个并行数组分别存储字符和对应值，逻辑更清晰，符合题目要求：

def listByValue(input_str):
    chars = []  # 第一个数组：存储字符，按规则排序
    values = []  # 第二个数组：存储对应的值

    for letter in input_str:
        # 计算插入位置：按字母顺序，相同字符插在现有字符前面
        insert_pos = 0
        # 先找到第一个大于当前字符的位置
        while insert_pos < len(chars) and chars[insert_pos] < letter:
            insert_pos += 1
        # 处理相同字符：找到第一个相同字符的位置，插在它前面
        while insert_pos < len(chars) and chars[insert_pos] == letter:
            insert_pos += 1

        # 计算当前字符对应的值
        if len(chars) == 0:
            val = 0
        elif insert_pos == 0:
            # 插在开头，取右侧相邻值+1
            val = values[insert_pos] + 1
        elif insert_pos == len(chars):
            # 插在末尾，取左侧相邻值+1
            val = values[insert_pos - 1] + 1
        else:
            # 中间位置，取左右值的较大值+1
            val = max(values[insert_pos - 1], values[insert_pos]) + 1

        # 插入到两个并行数组
        chars.insert(insert_pos, letter)
        values.insert(insert_pos, val)

    # 按值从小到大排序，同值保持插入顺序（稳定排序）
    paired = list(zip(values, chars))
    paired.sort(key=lambda x: x[0])
    return ''.join([char for val, char in paired])

# 测试示例
print(listByValue("PYTHONN"))  # 输出 PHYOTNN

1. 插入位置计算：先遍历找到第一个大于当前字符的位置，再处理相同字符的情况，确保相同字符插在现有实例的前面。
2. 值的计算：严格按照题目规则处理边界和中间情况，避免索引越界。
3. 结果生成：用zip将两个数组配对，通过稳定排序保证同值字符的插入顺序不变，最后拼接成结果字符串。

内容的提问来源于stack exchange，提问作者user21485801