Leetcode brushing record-402. Eliminar K dígitos

He implementado dos métodos:
1. El método de fuerza bruta.
Primero, considere una entrada y solo elimine 1 número para minimizar el resultado. ¿Cómo eliminarlo?
Luego, para una entrada num y k, realizamos las operaciones anteriores en num k veces, luego

class Solution:
    def removeKdigits(self, num: str, k: int) -> str:
        length = len(num)
        num_val = int(num)

        if num_val == 0 or length <= k:
            return "0"
        num_list = []
        for letter in num:
            num_list.append(int(letter))
        print(num_list)

        #num_list
        start_index = 0
        for i in range(k):#执行k次
            length = len(num_list)
            for j in range(length-1):
                if num_list[j] > num_list[j+1]:
                    num_list.pop(j)
                    break
                if j == length - 2 and num_list[j] <= num_list[j+1]:
                    num_list.pop(-1)
                    start_index
        newlist = num_list
        finallength = len(newlist)
        if list(set(newlist)) == [0]:
            return "0"
        index = 0
        while newlist[index] == 0:
            index += 1
        res = ''
        for value in newlist[index:]:
            res += str(value)
        return res

2. Operación de pila basada en algoritmo codicioso

Primero construimos una pila para almacenar los números reservados
Calcular índice = len (matriz) -k

Iterar sobre cada número de la matriz:
para el primer número, colóquelo primero en la pila
Para cada siguiente:

Si el número que se va a eliminar k == 0:
agregue los siguientes números de la matriz a la pila

Si el número que se va a eliminar k> 0 y el número que atraviesa la matriz <stack top:
while k> 0 y stack no empty and stack top> este número:
stack top pop
k- = 1 Después de
saltar del bucle, la
pila .append (esto Número)

Si el número que se va a eliminar k> 0 y el número que atraviesa la matriz> = stack top:
stack.append (este número)

Después de saltar fuera del recorrido,
si k> 0:
solo toma el frente de la pila [: index]

Si solo hay 0 en la pila:
devuelve str (0)

Si la pila [0] == 0
obtiene el primer número que no es igual a 0, de ella a la pila [-1], devuelve un str

class Solution:
    def removeKdigits(self, num: str, k: int) -> str:
        length = len(num)
        num_val = int(num)
        #oldk = k
        if num_val == 0 or length <= k:
            return "0"
        num_list = []
        for letter in num:
            num_list.append(int(letter))
        print(num_list)

        should = length - k
        #num_list
        zhan = []
        #zhan#.append(num_list[0])
        tempindex = 0
        shanwan = False
        for i in range(length):
            if k == 0:
                for value in num_list[i:]:  
                    zhan.append(value)#shanwan = True
                break
            elif zhan == []:
                zhan.append(num_list[i])
            else:
                if zhan[-1] <= num_list[i]:
                    zhan.append(num_list[i])

                elif zhan[-1] > num_list[i]:
                    while k > 0 and zhan != [] and zhan[-1] > num_list[i]:
                        zhan.pop(-1)
                        k -= 1
                    zhan.append(num_list[i])
        if k > 0:
            zhan = zhan[:should ]
        print(zhan)
        #while len(zhan) < should:
        #    zhan.append(num_list[tempindex + 1])
        #    tempindex += 1
        if list(set(zhan)) == [0]:#0
            return '0'
        while zhan[0] == 0:
            zhan.pop(0)
        res = ''
        for value in zhan:
            res += str(value)
        return res