2017-10-09 回答
用matlab解方程的三个实例
1、对于多项式p(x)=x3-6x2-72x-27，求多项式p(x)=0的根，可用多项式求根函数roots(p)，其中p为多项式系数向量，即
>>p =
p =
1.00 -6.00 -72.00 -27.00
p是多项式的matlab描述方法，我们可用poly2str(p,'x')函数 ，来显示多项式的形式:
>>px=poly2str(p,'x')
px =x^3 - 6 x^2 - 72 x - 27
多项式的根解法如下：
>> format rat %以有理数显示
>> r=roots(p)
r =
2170/179
-648/113
-769/1980
2、在matlab中，求解用符号表达式表示的代数方程可由函数solve实现，其调用格式为：solve(s,v)：求解符号表达式s的代数方程，求解变量为v。
例如，求方程(x+2)x=2的解,解法如下：
>> x=solve('(x+2)^x=2','x')
x =
.69829942170241042826920133106081
得到符号解，具有缺省精度。如果需要指定精度的解，则：
>> x=vpa(x,3)
x =
.698
3、使用fzero或fsolve函数 ，可以求解指定位置(如x0)的一个根，格式为：x=fzero(fun ,x0)或x=fsolve(fun,x0)。例如，求方程0.8x+atan(x)-=0在x0=2附近一个根，解法如下：
>> fu=@(x)0.8*x+atan(x)-pi;
>> x=fzero(fu,2)
x =
2.4482
或
>> x=fsolve('0.8*x+atan(x)-pi',2)
x =
2.4482
________________________________________
当然了，对于该方程也可以用第二种方法求解：
>> x=solve('0.8*x+atan(x)-pi','x')
x =
2.4482183943587910343011460497668
对于第一个例子，也可以用第三种方法求解：
>> f=@(x)x^3-6*x^2-72*x-27
f =
@(x)x^3-6*x^2-72*x-27
>> x=fzero(f,10)
x =
12.1229
对于第二个例子，也可以用第三种方法：
>> fun=@(x)(x+2)^x-2
fun =
@(x)(x+2)^x-2
>> x=fzero(fun,1)
x =
0.6983
最近有多人问如何用matlab解方程组的问题，其实在matlab中解方程组还是很方便的，例如，对于代数方程组ax=b(a为系数矩阵 ，非奇异)的求解，matlab中有两种方法：
(1)x=inv(a)*b — 采用求逆运算解方程组；
(2)x=a\b — 采用左除运算解方程组。
例:
x1+2x2=8
2x1+3x2=13
>>a=;b=;
>>x=inv(a)*b
x =
2.00
3.00
>>x=a\b
x =
2.00
3.00；
即二元一次方程组的解x1和x2分别是2和3。
对于同学问到的用matlab 解多次的方程组，有符号解法，方法是：先解出符号解,然后用vpa(f,n)求出n位有效数字的数值解.具体步骤如下：
第一步:定义变量syms x y z ...;
第二步:求解=solve('eqn1','eqn2',...,'eqnn','var1','var2',...'varn');
第三步:求出n位有效数字的数值解x=vpa(x,n);y=vpa(y,n);z=vpa(z,n);...。
如：解二(多)元二(高)次方程组：
x^2+3*y+1=0
y^2+4*x+1=0
解法如下：
>>syms x y;
>>=solve('x^2+3*y+1=0','y^2+4*x+1=0');
>>x=vpa(x,4);
>>y=vpa(y,4);
结果是：
x =
1.635+3.029*i
1.635-3.029*i
-.283
-2.987
y =
1.834-3.301*i
1.834+3.301*i
-.3600
-3.307。

小作业，大想法：Python计算多项式函数
偶然中接到了一项小作业，初看很简单，思路基本在脑中了，但是当我打开Pycharm后打了第一次，却显示结果不对，那说明逻辑错误了。



先来看看题吧：

编一个函数，计算多项式的取值，参数为系数数组和x的值。
乍一看很简单，我却在这上翻了车，先贴代码吧（这个代码是非常正确的）：
def Polynomial(x,*list):
    q = 0
    for i in range(len(list)):
        q = q+list[i]*(x**(len(list)-i-1))
    return q

一开始我打算采用秦九昭公式，即



但是却绕在循环里出不来了，由于作业的急迫性，我只好采取笨方法对多项式进行求值，即上边的那段代码。
至于秦九昭算法，以后有时间了在补充吧…

数据结构的课后习题：①求两个多项式的相加运算：掌握线性表的应用和有序单链表的二路归并算法设计。②求两个多项式的相乘运算：深入掌握单链表应用的算法设计。
首先是表示多项式的数据结构：使用的单链表，存储的信息包括系数和指数，以及后继结点。首先肯定要写好初始化函数（可以实现输入），析构函数和显示数据的打印函数。最重要的是如何实现多项式的相加和相乘，如果要相加的话根据多项式相加的规律是，次数相同的项合并在一起相加，次数不同的项单列，因此可以写一个判断语句判断多项式的次数，这里要注意输入的时候要满足降幂排列，这样才有利于这里的比较判断。从高位到低位因为是降幂所以可以逐项的比较多余的项放在最后面。相乘和相加的原理大致相同，最大的区别是运算的规则不一样，因为第一项要和第二项逐项相乘再相加。我的思路是并不将第一项和第二项的每一项相乘，这样时间复杂度会达到n2，根据规律只要第一项和第二项中的每一项相乘，其余项和第二项中的每一项相乘的结果系数成比例，次数也是只需减去一个数。这样的时间复杂度就大大降低了，现在的问题就变成了如何有序存储计算的结果。我是利用的一个哈希表存储计算的结果。
#include<stdio.h>
#include<stdlib.h>
#include<unordered_map>
#include<vector>
#define LEN sizeof(LinkList)

typedef struct LNode
{
    float coef;//定义系数
    int index;//定义指数
    struct LNode *next;//指向后继节点
} LinkList;

void Createpolyn(LinkList *&L);//创建多项式提供，其中p为首地址，数据和数据长度在函数内给出
void Printpolyn(LinkList *L);//打印多项式
LinkList* Addpolyn(LinkList *L1,LinkList *L2);//两个多项式相加
LinkList* Mulpolyn(LinkList *L1,LinkList *L2);//两个多项式相乘
void Destroypolyn(LinkList *&L);//释放单链表占用的内存空间

int main()
{
    LinkList *p1,*p2,*p_result;
    int choice;
    printf("请输入第一个多项式长度:");
    Createpolyn(p1);
    printf("第一个多项式为:\n");
    Printpolyn(p1);

    printf("\n请输入第二个多项式长度:");
    Createpolyn(p2);
    printf("第二个多项式为:\n");
    Printpolyn(p2);

    printf("请选择对多项式进行相加还是相乘:1.相加2.相乘3.相加和相乘:");
    scanf("%d",&choice);
    if(choice == 1)
    {
        p_result = Addpolyn(p1,p2);
        printf("相加后的结果为:\n");
        Printpolyn(p_result);
    }
    else if(choice == 2)
    {
        p_result = Mulpolyn(p1,p2);
        printf("相乘后的结果为:\n");
        Printpolyn(p_result);
    }    
    else if(choice == 3)
    {
        p_result = Addpolyn(p1,p2);
        printf("相加后的结果为:\n");
        Printpolyn(p_result);
        p_result = Mulpolyn(p1,p2);
        printf("相乘后的结果为:\n");
        Printpolyn(p_result);
    }
    else
    {
        printf("似乎没有找到你想要的选项");
    }
    
    Destroypolyn(p1);
    Destroypolyn(p2);
    Destroypolyn(p_result);
    return 0;
}

void Createpolyn(LinkList *&L)//采用尾插法建表
{
    LinkList *s,*r,*pre;//需要一个pre来保证下一次输入的指数一定比上一次的小,或者建立系数和指数数组再对指数排序后再插入表中
    int n = 0;//n表示要建立的单链表的长度
    scanf("%d",&n);
    L = (LinkList*)malloc(LEN);//创建头结点
    r = L;//r始终指向尾结点，开始时指向头结点
    for(int i=0;i<n;i++)
    {
        s=(LinkList*)malloc(LEN);
        printf("请输入第%d项的系数：",i+1);
        scanf("%f",&s->coef);
        printf("请输入第%d项的指数：",i+1);
        scanf("%d",&s->index); 
        if(r!=L)//第一次不能参与比较
        {
            while(r->index<=s->index)
            {
                printf("下一次输入的指数必须比上一次的小\n");
                printf("请重新输入第%d项的指数：",i+1);
                scanf("%d",&s->index);
            }
        }
        r->next = s;//将*s插入在*r之后，意味着只有在插入下一个数时才会给s->next赋值，或者插入完到最后一个数
        r = s; 
    }
    r->next = NULL;//尾结点next域置空
}

void Printpolyn(LinkList *L)
{
    LinkList *p = L->next;//p指向头结点
    bool flag = false;//flag要解决的问题是如果前一个数为0是否答应加号，如果是第一个数不答应否则要打印
    while(p!=NULL)
    {
        if(p->coef!=0)
        {
            if(p->index==0)
            {
                printf("%.2f",p->coef);//不打印x的0次方
            }
            else
            {
                printf("%.2fX^%d",p->coef,p->index);//如果不为0的话才打印
            }
            flag = true;
        }
        p = p->next;
        if(p!=NULL&&p->coef>0&&flag==true)
            printf("+");
    }
    printf("\n");
}

void Destroypolyn(LinkList *&L)
{
    LinkList *pre = L,*p = L->next;
    while(p!=NULL)
    {
        free(pre);
        pre = p;
        p = pre->next;
    }
    free(pre);
}

LinkList* Addpolyn(LinkList *L1,LinkList *L2)//将所有的指数项相加，结果降序排列
{
    LinkList *p1, *p2, *newp, *p_new, *s;
    newp = (LinkList*)malloc(LEN);
    p1 = L1->next;
    p2 = L2->next;
    p_new = newp;
    while(p1&&p2 != NULL)//p1和p2中都还剩余元素,之前的输入应该满足升序排列否则的话可能要用到哈希表
    {
        if(p1->index>p2->index)//p1的指数大于p2的指数
        {
            s=(LinkList*)malloc(LEN);
            s->coef = p1->coef;
            s->index = p1->index;
            p_new->next = s;
            p_new = s;
            p1=p1->next;//p1后移
        }
        else if(p1->index<p2->index)//p2的指数大于p1的指数
        {
            s=(LinkList*)malloc(LEN);
            s->coef = p2->coef;
            s->index = p2->index;
            p_new->next = s;
            p_new = s;
            p2=p2->next;//p2后移 
        }
        else if(p1->index==p2->index)
        {
            s=(LinkList*)malloc(LEN);
            s->coef = p1->coef+p2->coef;
            s->index = p1->index;
            p_new->next = s;
            p_new = s;
            p1=p1->next;//p1后移
            p2=p2->next;//p2后移
        }
    }
    while(p1!=NULL)//插入p1剩余部分
    {
        s=(LinkList*)malloc(LEN);
        s->coef = p1->coef;
        s->index = p1->index;
        p_new->next = s;
        s = p_new;
        p1=p1->next;//p1后移
    }
    while(p2!=NULL)//插入p2剩余部分
    {
        s=(LinkList*)malloc(LEN);
        s->coef = p2->coef;
        s->index = p2->index;
        p_new->next = s;
        p_new = s;
        p2=p2->next;//p2后移  
    }
    p_new->next = NULL;
    return newp;
}

LinkList* Mulpolyn(LinkList *L1,LinkList *L2)
{
    std::unordered_map<int,int> Hash;
    std::vector<float> Coef;//用来保存系数，可以不用确定长度
    std::vector<int> Index;//用来保存指数
    LinkList *p,*q,*newp,*p_new,*s,*pre_p;
    p = L1->next;
    q = L2->next;
    newp = (LinkList*)malloc(LEN);
    p_new = newp;

    float coef_result = 0;
    int index_result = 0;
    while(q!=NULL)//只要计算一次即可，后面的结果从第一次计算的结果中推导出
    {
        coef_result = p->coef * q->coef;
        index_result = p->index + q->index;
        //printf("First:coef_result=%.2f,index_result=%d\n",coef_result,index_result);
        Coef.push_back(coef_result);
        Index.push_back(index_result);
        Hash[index_result] = coef_result;
        q = q->next;
    }
    pre_p = p;
    p = p->next;
    while(p!=NULL)
    {
        float div = p->coef/pre_p->coef;
        int sub = p->index - pre_p->index;
        //printf("div=%.2f,sub=%d\n",div,sub);
        for(int i=0;i<Coef.size();i++)
        {
            Coef[i] = Coef[i]*div;
            Index[i] = Index[i]+sub;
            //printf("Second:coef_result=%.2f,index_result=%d\n",Coef[i],Index[i]); 
            if(Hash.count(Index[i]))//已经存在加系数
                Hash[Index[i]] += Coef[i];
            else
                Hash[Index[i]] = Coef[i];//新插入元素
        }
        pre_p = p;
        p = p->next;
    }
    for(auto item:Hash)//倒序输出不知道如何改为正序
    {
        s = (LinkList*)malloc(LEN);
        s->index = item.first;
        s->coef = item.second;
        p_new->next = s;
        p_new = s;
    }
    p_new->next = NULL;
    return newp;
}

实验结果截图：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
pass 关键字，代表什么都不干
exit(num) 强行退出(num:是一个数字，显示为退出码)
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
举例2：
2.函数的调用
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
3.函数的参数
形式参数和实际参数
在定义函数时，函数名后面，括号中的变量名称叫做形式参数，或者称为"形参"
在调用函数时，函数名后面，括号中的变量名称叫做实际参数，或者称为"实参"
4.函数的返回值
函数返回值：
函数被调用后会返回一个指定的值
函数调用后默认返回None
return返回值
返回值可以是任意类型
return执行后，函数终止
return与print区别
5.函数的变量
局部变量和全局变量：
Python中的任何变量都有特定的作用域
在函数中定义的变量一般只能在该函数内部使用，这些只能在程序的特定部分使用的变量我们称之为局部变量
在一个文件顶部定义的变量可以供文件中的任何函数调用，这些可以为整个程序所使用的变量称为全局变量。
统计程序中的变量，返回的是个字典
6.匿名函数
顾名思义就是没有名字的函数，那为什么要设立匿名函数，他有什么作用呢？
lambda 函数是一种快速定义单行的最小函数，可以用在任何需要函数的地方
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
7.高阶函数
（1）map(f, list)
返回每个元素通过f计算完的value的list
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
（3）filter()函数（过滤）
filter函数接收一个函数f和一个list，函数f的作用是对每个元素进行判断，返回True或者False，filter()根据判断结果自动过滤掉不符合条件的元素，返回符合要求的元素组成的list
filter(lamdba x: x%2 ==1, [1, 2, 3, 4, 5])
举例：计算list中小于7的数
举例：