一元多项式 python

一、 问题描述

输入一个中缀表示形式的整数简单算术表达式，如1+3*4-6/2，或5+（1+3-5）*（8-2）/3，用栈操作实现的程序，完成表达式的求值计算。

 

二、 算法思路

2.1 中缀表达式转后缀表达式，求值

①当我们采用堆栈的方法来实现时，对于 python 而言，即建立一个Stack类，同时定义符合栈相关性质的函数。如图：

 

②随后我们进行主函数的构建，首先将中缀表达式转变成后缀表达式的列表形式（这个接下来详细讲），随后构建数值栈，对后缀列表中的元素逐个读取并进行条件判断。将计算结果入栈。如图：

 

③而运算到最后，我们会发现数值栈中只会存在一个数值，我们将这个数值读取出来就是我们要求的结果，当然最后将栈清空，整个程序完成，如图：

 

④格式化表达，主要注意±1的特殊情况，以及是否在最前方有+的符号即可。

2.2 链表

①链表的思路和向量相似，只是在构造的过程中不太一样。

②对链表的节点进行如下构造：

 

③同样是通过循环的方式构建链表，同时构建Cx

④计算方式与向量相同，同样是分成三种情况，进行指针的变化。

 

三、 代码实现

 

1. 向量

 

def Callcupolynomials1():
    # 生成Ax
    print('---------Ax---------')
    n1 = int(input())
    Ax = [[0 for m in range(2)]for n in range(n1)]
    for i in range(0, n1):
        coe, ind = input('请输入系数和指数，中间用空格分开:').split(' ')
        Ax[i][0] = int(coe)
        Ax[i][1] = int(ind)
    # 生成Bx
    print('---------Bx---------')
    n2 = int(input())
    Bx = [[0 for m in range(2)]for n in range(n2)]
    for j in range(0, n2):
        coe, ind = input('请输入系数和指数，中间用空格分开:').split(' ')
        Bx[j][0] = int(coe)
        Bx[j][1] = int(ind)
    # 进行加减法运算
    addres = Addpolynomials(Ax, Bx)
    print(addres)
    res = print_lis(addres)
    print('加法运算结果:\nc(x):', res)
    # 格式化输出


# 一元多项式加法计算
def Addpolynomials(Ax, Bx):
    # 创建指针
    i = 0
    j = 0
    k = 0
    # 创建输出结果
    res = [[0 for m in range(2)]for n in range(len(Ax) + len(Bx))]
    # 进行指数匹配并运算
    while True:
        # 临界条件判断
        if i >= len(Bx):
            res.extend(Ax[j:])
            break
        if j >= len(Ax):
            res.extend(Bx[i:])
            break
        # 运算
        if Bx[i][1] > Ax[j][1]:
            res[k] = Bx[i]
            i += 1
            k += 1
            continue
        elif Bx[i][1] == Ax[j][1]:
            res[k][0] = Bx[i][0] + Ax[j][0]
            res[k][1] = Bx[i][1]
            i += 1
            j += 1
            k += 1
            continue
        elif Bx[i][1] < Ax[j][1]:
            res[k] = Ax[j]
            j += 1
            k += 1
            continue
    return res

# 格式化输出
def print_lis(lis):
    string = ''
    for i in range(len(lis)):
        if lis[i][1] == 0:
            if lis[i][0] != 0:
                string = ('+{0}'.format(lis[i][0]) if lis[i][0] > 0 else str(lis[i][0])) + string
            else:
                continue
        elif lis[i][1] == 1:
            if lis[i][0] != 0:
                if lis[i][0] == 1 or lis[i][0] == -1:
                    string = 'x' + string
                else:
                    string = '{0}x'.format(abs(lis[i][0])) + string
                if lis[i][0] > 0:
                    string = '+' + string
                else:
                    string = '-' + string
        else:
            if lis[i][0] != 0:
                if lis[i][0] == 1 or lis[i][0] == -1:
                    string = 'x^{0}'.format(lis[i][0]) + string
                else:
                    string = '{0}x^{1}'.format(abs(lis[i][0]), lis[i][1]) + string
                if lis[i][0] > 0:
                    string = '+' + string
                else:
                    string = '-' + string
            else:
                continue

    if len(string) == 0:
        string = '0'
    else:
        if string[0] == "+":
            string = string[1:]

    return string
Callcupolynomials1()

 

 

 

1. 链表

 

class ListNode:  # 链表结点定义
    def __init__(self, exp=-1, coe=0, next=None):  # 结点初始化
        self.coe = coe
        self.exp = exp
        self.next = next

class LinkedList:  # 链表定义
    def __init__(self, head):  # 链表初始化
        self.head = head
        self.tail = head

    def AddNode(self, node):  # 尾插实现增加结点
        self.tail.next = node
        self.tail = node

    def traverse(self):  # 遍历链表，返回包含链表信息的列表
        lis = []
        node = self.head
        while (node != None):
            lis.append([node.exp, node.coe])
            node = node.next
        return lis

def Callcupolynomials2():
    # 生成Ax
    print('---------Ax---------')
    n1 = int(input())
    Ax = LinkedList(ListNode())
    for i in range(n1):
        coe, exp = input('请输入系数和指数，中间用空格分开:').split(' ')
        node = ListNode(int(exp), int(coe))
        Ax.AddNode(node)
    # 生成Bx
    print('---------Bx---------')
    n2 = int(input())
    Bx = LinkedList(ListNode())
    for i in range(n2):
        coe, exp = input('请输入系数和指数，中间用空格分开:').split(' ')
        node = ListNode(int(exp), int(coe))
        Bx.AddNode(node)

    p1 = Ax.head.next      #设置遍历指针
    p2 = Bx.head.next
    Cx = LinkedList(ListNode())   #建立新链表c
    while(True):
        if p1 == None:         #当链表a遍历完成时，复制b链表到c链表之后
            while(p2 != None):
                node = ListNode(p2.exp, p2.coe)
                p2 = p2.next
                Cx.AddNode(node)
            break
        elif p2 == None:       #当链表b遍历完成时，复制a链表到c链表之后
            while(p1 != None):
                node = ListNode(p1.exp, p1.coe)
                p1 = p1.next
                Cx.AddNode(node)
            break

        # 当a的指数大时，b的该项直接落下，指针向后移动一位
        if p1.exp > p2.exp:
            node = ListNode(p2.exp, p2.coe)
            Cx.AddNode(node)
            p2 = p2.next
        # 当b的指数大时，a的该项直接落下，指针向后移动一位
        elif p2.exp > p1.exp:
            node = ListNode(p1.exp, p1.coe)
            Cx.AddNode(node)
            p1 = p1.next
        # 当a和b指数相等时，a和b的系数相加，a和b的指针都向后移动一位
        else:
            node = ListNode(p1.exp, p1.coe + p1.coe)
            Cx.AddNode(node)
            p1 = p1.next
            p2 = p2.next


    print('加法运算结果:\nc(x):', print_lis(Cx.traverse()[1:]))

# 格式化输出
def print_lis(lis):
    string = ''
    for i in range(len(lis)):
        if lis[i][1] == 0:
            if lis[i][0] != 0:
                string = ('+{0}'.format(lis[i][0]) if lis[i][0] > 0 else str(lis[i][0])) + string
            else:
                continue
        elif lis[i][1] == 1:
            if lis[i][0] != 0:
                if lis[i][0] == 1 or lis[i][0] == -1:
                    string = 'x' + string
                else:
                    string = '{0}x'.format(abs(lis[i][0])) + string
                if lis[i][0] > 0:
                    string = '+' + string
                else:
                    string = '-' + string
        else:
            if lis[i][0] != 0:
                if lis[i][0] == 1 or lis[i][0] == -1:
                    string = 'x^{0}'.format(lis[i][0]) + string
                else:
                    string = '{0}x^{1}'.format(abs(lis[i][0]), lis[i][1]) + string
                if lis[i][0] > 0:
                    string = '+' + string
                else:
                    string = '-' + string
            else:
                continue

    if len(string) == 0:
        string = '0'
    else:
        if string[0] == "+":
            string = string[1:]

    return string


# 输出
Callcupolynomials2()

 

 

 

 

 

 

四、 输入与输出