python 基础算法整理

# 1.删除链表中重复元素
'''class LinkNode:
    def __init__(self, num):
        if isinstance(num, int):
            self.val= num
            self.next = None
        elif isinstance(num, list):
            self.val = LinkNode(num[0])
            self.next = None
            head = self
            for i in range(0, len(num)):
                cur = LinkNode(num[i])
                head.next = cur
                head =  head.next

class Solution:
    def delete(self, elem:LinkNode)->LinkNode:
        q = p = LinkNode(0)
        while elem:
            p.next = elem
            while elem.next  and elem.val == elem.next.val:
                elem.next = elem.next.next
            elem = elem.next
            p = p.next


        return q.next

l = [1,1,1]
ll = LinkNode(l)
method = Solution()
output = method.delete(ll)
while output:
    print(output.val)
    output = output.next'''

# 2.二分法查找符合条件的元素->某个数的平方根
'''
1.取（1， x）中间元素
2.对中间元素进行平方运算
3.运算结果与X进行比较，大于，区间左移；小于，区间右移
'''
#<A>
'''class solution:
    def find(self, x:int)->int:
        left, right = 1, x
        while left <= right:
            mid = (left+right)//2
            if (mid*mid)>x:
                right = mid - 1
            elif (mid*mid)<x:
                left = mid + 1
            else:
                return mid
        return right
method = solution()
a = method.find(8)
print(a)'''
#<B>
'''class Solution:
    def search(self, nums: list[int], target: int) -> int:
        start, end = 0, len(nums)-1
        if len(nums)==0:
            return -1
        while start <= end:
            mid = (end+start)//2
            if nums[mid] > target:
                end = mid-1
            elif nums[mid] < target:
                start = mid + 1
            else :
                return mid
        return -1

target = 1
nums = [0,1]
ll = sorted(nums)
method = Solution()
a = method.search(ll, target)
print(a)'''

# 3.逆波兰数问题
'''
1.对列表中的元素进行出栈
2.在栈非空的情况下：
（1）栈元素为数字，入栈
（2）栈元素为数学操作，进行数学运算
    a.取栈的前两个元素进行运算，运算结果压栈
3.栈已经排空，输出最终结果，即栈中的元素
'''
'''from operator import mul, add, sub, truediv
class solution:
    def polan(self, x):
        num_stack = []
        method = {"+": add, "-": sub, "*": mul, "/": truediv}
        while x:
            i = x.pop(0)
            if i in method:
                if i == "/":
                    a = num_stack.pop()
                    b= num_stack.pop()
                    output = int( b/a)
                    num_stack.append(output)
                elif i == "/":
                    output = int(-num_stack.pop() + num_stack.pop())
                    num_stack.append(output)
                else:
                    output = method[i](num_stack.pop() , num_stack.pop())
                    num_stack.append(output)
            else:
                num_stack.append(int(i))
        return num_stack.pop()

method = solution()
#num_stack入站顺序：5,4
output = method.polan(["5", "4", "/","1","*"])
print(output)'''

# 4.查找重复元素，且判断存在的相同元素的间隔是否大于K
'''
1.遍历列表，判断是否有相同元素
2.判断重复元素的间隔
'''
'''ll = list(map(int, input().split()))
class solution:
    def delete(self, ll, k):
        i, j, b = 0, 0, []
        while i < len(ll):
            if ll[i] in b:return True
            b.append(ll[i])
            i +=1
            if j==k:
                b.pop(0)
            j +=1
        return False
method = solution()
print(method.delete(ll, 4))'''

#5.反转链表
'''class ListNode:
    def __init__(self, x):
        if isinstance(x, int):
            self.val = x
            self.next = None
        elif isinstance(x, list):
            self.val = x[0]
            self.next = None
            head = self
            for i in range(1, len(x)):
                node = ListNode(x[i])
                head.next = node
                head = head.next

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        a, b = None, head
        while b:
            c = b.next
            b.next = a
            a = b
            b = c
        return a

point = list(map(int, input().split()))
ll = ListNode(point)
k = Solution()
num = k.reverseList(ll)
while num:
    #单行输出，多行输出去掉end
    print(num.val, end='')
    num = num.next'''

#6.队列实现,队列：在队尾添加元素，在队首删除元素（先进先出），（对列表而言，队列的队首在列表的左端，队尾在列表的右端）
'''
import sys
def push(x:int, stack:list):
    stack.append(x)
    
def pop(stack):
    if len(stack)==0 :
        print('error')
    else:
        a = stack.pop(0)
        print(a)

def front(stack):
    if len(stack)==0:
        print('error')
    else:
        print(stack[0])
stack = []
for line in sys.stdin:
    ll = line.split()

    if ll[0] == "push":
        push(int(ll[1]), stack)
    elif ll[0] == "pop":
        pop(stack)
    elif ll[0]=="front":
        front(stack)'''

#ACM模式下的输入
#多行输入:
'''import sys
for line in sys.stdin:
    ll = line.split()
#按列表输入:1 2 3 4 6 -> [1,2,3,4,6]
n_list1 = list(map(int, input().split("")))
#按字符串输入，将其转为列表：
#<A>:
str_list1 = "[1,2,3,4,5,6]"
list_1 = eval(str_list)
#<B>:
str_list2 = '234567'
list_2 = list(str_list2)
list_2 = list(map(int, list_2))#字符串转数字
print(list_2)'''

'''#多行输入，同时未指定用例个数：
while True:
    try:
        data = input()
        #核心函数
        Solution()
    except:
        break
#多行输入，同时指定用例个数：
n = int(input())
for _ in range(n):
    data = input()
    Solution()

#多行输入，指定某个条件推出：
while True:
    data = input()
    if judge(data):#判断条件
        break
    Solution(data)'''

'''#输出列表，直接输出列表：[1, 2, 3]：
print(ll)
#输出列表，每个元素单独输出：
for i in range(len(ll)):
    print(ll[i])
#输出列表，每个元素单独输出，同时还需要在同一行输出, 以空格分隔(若以逗号分隔，则end=',')：
for i in range(len(ll)):
    print(ll[i], end='')
#输出字符串,''：无分隔；':以空格分隔；'*'：以*分隔：
print(''.join(ll))'''