数据结构课程设计之一元多项式的计算

2023-05-16

数据结构不是听会的，也不是看会的，是练会的，对于写这么长的代码还是心有余也力不足啊，对于指针的一些操作，也还是不熟练，总出现一些异常错误，对于数据结构掌握还是不够啊，还是要多练，这个课程设计做的还是有点粗糙，还有待改进啊！！

对代码有进行了一下改进，增加了排序的模块；可能还存在着一下小bug，发现了再更新：减法还可以写的更简便一点。

<pre name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <conio.h>/*屏幕操作函数库*/
using namespace std;
struct node //结构体储存系数和指数
{
    float coef; //系数
    int expn;  //指数
};
typedef node polynomial; // 创建一个多项式的节点
struct Lnode// 储存数据，指针域
{
    polynomial data;
    Lnode *next;
};
typedef Lnode Link; // 链表的数据类型
void CreatPolyn(Link *L,int n) //创建多项式
{
   Link *q; //创建一个新的节点
   for(int i=1;i<=n;i++)
   {
       q=(Link*)malloc(sizeof(Link));
       q->next=NULL;
       printf("输入第%d项的系数和指数:\n",i);
       scanf("%f%d",&q->data.coef,&q->data.expn);
       L->next=q;
       L=L->next; //把节点链到多项式中
   }
}

void DestoryPolyn(Link *L)// 销毁多项式
{
    Link *p;
    p=L->next;
    while(p!=NULL)
    {
        L->next=p->next;
        free(p);//释放节点的内存
        p=L->next;
    }
    free(p);
}

void PrintPolyn(Link *L) //打印多项式
{
    Link *p;
    if(L==NULL||L->next==NULL) //多项式为空的情况
        cout<<"该一元多项式为空！"<<endl;
    else
        {
            p=L->next;
            while(p!=NULL)
         {
               if((p->data).coef>0)//多项式的系数大于0的五种情况
                 {
                    if((p->data).expn==0)
                    cout<<(p->data).coef;
                    else if((p->data).coef==1&&(p->data).expn==1)
                        cout<<"x";
                    else if((p->data).coef==1&&(p->data).expn!=1)
                        cout<<"x^"<<(p->data).expn;
                    else if((p->data).expn==1&&(p->data).coef!=1)
                        cout<<(p->data).coef<<"x";
                    else
                        cout<<(p->data).coef<<"x^"<<(p->data).expn;
                    }
                    if((p->data).coef<0)//多项式的系数小于0的五种情况
                        {
                        if((p->data).expn==0)
                            cout<<(p->data).coef;
                            else if((p->data).coef==-1&&(p->data).expn==1)
                                cout<<"-x";
                            else if((p->data).coef==-1&&(p->data).expn!=1)
                                cout<<"-x^"<<p->data.expn;
                            else if((p->data).expn==1)
                                cout<<(p->data).coef<<"x";
                            else
                            cout<<(p->data).coef<<"x^"<<(p->data).expn;
                        }
                    if(p->next!=NULL&&(p->next->data).coef>0&&p->data.coef!=0)
                        cout<<"+";
                        p=p->next;
            }
        }
   cout<<endl;
}

void SortPolyn(Link *L)//给多项式排序按递减顺序排序
{
    Link *p,*q,*r;//建立新节点
    p=L->next;
    if(p!=NULL)//链表不为空
    {
        r=p->next;
        p->next=NULL;
        p=r;
        while(p!=NULL)
        {
            r=p->next;
            q=L;
            while(q->next!=NULL&&q->next->data.expn>p->data.expn)//指数比较
                q=q->next;
            p->next=q->next;//如果q的指数大于p就继续遍历，不大于p就把p插到q后面
            q->next=p;
            p=r;
        }
    }
}

Link *AddPolyn(Link *L,Link *La,Link *Lb) //多项式的相加
{
    Link *p,*q,*s,*r;
    float x;
    p=La;
    q=Lb;
    r=L;
   while(q!=NULL&&p!=NULL)
    {
        if(p->data.expn==q->data.expn) //两个多项式的系数相等的情况
        {
            x=p->data.coef+q->data.coef;
            if(x!=0)
                {
                    s=(Link*)malloc(sizeof(Link));
                    s->data.coef=x;
                    s->data.expn=p->data.expn;
                    r->next=s;
                    r=s;
                }
                q=q->next;
                p=p->next;
        }
        else if(p->data.coef<q->data.coef) //第一个多项式的指数小于第二个多项式的指数
            {
                s=(Link *)malloc(sizeof(Link));
                s->data.coef=q->data.coef;
                s->data.expn=q->data.expn;
                r->next=s;
                r=s;
                q=q->next;
            }
            else {
                s=(Link*)malloc(sizeof(Link));
                s->data.coef=p->data.coef;
                s->data.expn=p->data.expn;
                r->next=s;
                r=s;
                p=p->next;
                }
        }
        while(p!=NULL) //第一个多项式的长度比第二个长，把剩余的部分链入L中
        {
            s=(Link *)malloc(sizeof(Link));
            s->data.coef=p->data.coef;
            s->data.expn=p->data.expn;
            r->next=s;
            r=s;
            p=p->next;
        }
        while(q!=NULL)
        {
            s=(Link *)malloc(sizeof(Link));
            s->data.coef=q->data.coef;
            s->data.expn=q->data.expn;
            r->next=s;
            r=s;
            q=q->next;
        }
        r->next=NULL;
        L=L->next;
  return L;
}

Link *SubstractPolyn(Link *L,Link *La,Link *Lb)//多项式相减
{
    Link *p,*q,*s,*r;
    float x;
    p=La;
    q=Lb;
    r=L;
   while(q!=NULL&&p!=NULL)
    {
        if(p->data.expn==q->data.expn)
        {
            x=p->data.coef-q->data.coef;
            if(x!=0)
                {
                    s=(Link*)malloc(sizeof(Link));
                    s->data.coef=x;
                    s->data.expn=p->data.expn;
                    r->next=s;
                    r=s;
                }
                q=q->next;
                p=p->next;
        }
        else if(p->data.coef<q->data.coef)
            {
                s=(Link *)malloc(sizeof(Link));
                s->data.coef=-q->data.coef;
                s->data.expn=q->data.expn;
                r->next=s;
                r=s;
                q=q->next;
            }
            else {
                s=(Link*)malloc(sizeof(Link));
                s->data.coef=p->data.coef;
                s->data.expn=p->data.expn;
                r->next=s;
                r=s;
                p=p->next;
                }
        }
        while(p!=NULL)
        {
            s=(Link *)malloc(sizeof(Link));
            s->data.coef=p->data.coef;
            s->data.expn=p->data.expn;
            r->next=s;
            r=s;
            p=p->next;
        }
        while(q!=NULL)
        {
            s=(Link *)malloc(sizeof(Link));
            s->data.coef=-q->data.coef;
            s->data.expn=q->data.expn;
            r->next=s;
            r=s;
            q=q->next;
        }
        r->next=NULL;
        L=L->next;
  return L;
}

void Clear()//清屏函数
{
    system("pause");//输入任意键继续
    system("cls");//清屏
}

void Quit()//退出函数
{
    printf("\n\n\n\n\n");
    printf("\t\t★★★★★★★★★★★★★★★★★★★★★\n");
    printf("\t\t★★★★★★★感谢您的使用★★★★★★★★\n");
    printf("\t\t★★★★★★★欢迎再次使用★★★★★★★★\n");
    printf("\t\t★★★★★★★★★谢谢★★★★★★★★★★\n");
    printf("\n\n\n\n\n\t\t\t\t\t\tBy Mr.wang\n");
    exit(0);
}

void Meun()//菜单
{
    printf("\n\n\n\n===========================一元多项式的计算===============================\n");
    printf("\t\t[1] 创建要运算的两个一元多项式\n");
    printf("\t\t[2] 显示两个一元多项式\n");
    printf("\t\t[3] 将两个一元多项式相加\n");
    printf("\t\t[4] 将两个一元多项式相减\n");
    printf("\t\t[5] 将多项式递减排序\n");
    printf("\t\t[6] 销毁所创建的二个多项式\n");
    printf("\t\t[7] 退出\n");
    printf("请输入您的选择:\n");
}

int main()
{
    Link *L,*La,*Lb;;
    int chioce,n,m;
    La=(Link*)malloc(sizeof(Link));
    La->next=NULL;
    Lb=(Link*)malloc(sizeof(Link));
    Lb->next=NULL;
    L=(Link *)malloc(sizeof(Link));
    L->next=NULL;
    while(1)
    {
        system("color 2E");/*改变控制台颜色*/
        Meun();
        scanf("%d",&chioce);
        switch(chioce)
        {
          case 1:
            system("cls");
            printf("输入第一个多项式的长度：\n");
            scanf("%d",&n);
            printf("创建第一个多项式A：\n");
            if(n==0)
            {
                printf("您的输入有误，请重新输入：\n");
                Clear();
                break;
            }
            CreatPolyn(La,n);
            system("cls");
            printf("输入第二个多项式的长度：\n");
            scanf("%d",&m);
            if(m==0)
            {
                 printf("您的输入有误，请重新输入：");
                 Clear();
                 break;
            }
            printf("创建第二个多项式B：\n");
            CreatPolyn(Lb,m);
            Clear();
            break;
          case 2:
            system("cls");
            if(La->next==NULL||Lb->next==NULL)
            {
                  printf("您的多项式创建有误，请重新选择:\n");
                  Clear();
                  break;
            }
            printf("多项式A为：\n");
            PrintPolyn(La);
            printf("多项式B为：\n");
            PrintPolyn(Lb);
            Clear();
            break;
          case 3:
            system("cls");
            if(La->next==NULL||Lb->next==NULL)
            {
                  printf("您的多项式创建有误，请重新选择:\n");
                  Clear();
                  break;
            }
            printf("设相加的两个多项式为：\n");
            printf("多项式A为：\n");
            PrintPolyn(La);
            printf("多项式B为：\n");
            PrintPolyn(Lb);
            printf("相加的结果为：\n");
            L=AddPolyn(L,La,Lb);
            SortPolyn(L);
            PrintPolyn(L);
            Clear();
            break;
          case 4:
              system("cls");
               if(La->next==NULL||Lb->next==NULL)
            {
                  printf("您的多项式创建有误，请重新选择:\n");
                  Clear();
                  break;
            }
            printf("设相减的两个多项式为：\n");
            printf("多项式A为：\n");
            PrintPolyn(La);
            printf("多项式B为：\n");
            PrintPolyn(Lb);
            printf("相减的结果为：\n");
            L=SubstractPolyn(L,La,Lb);
            SortPolyn(L);
            PrintPolyn(L);
            Clear();
            break;
          case 5:
            system("cls");
            if(La->next==NULL||Lb->next==NULL)
            {
                  printf("您的多项式创建有误，请重新选择:\n");
                  Clear();
                  break;
            }
            printf("给多项式A排序:\n");
            printf("多项式A为:\n");
            PrintPolyn(La);
            printf("排序后的结果为:\n");
            SortPolyn(La);
            PrintPolyn(La);
            getch();
            system("cls");
            printf("给多项式B排序:\n");
            printf("多项式B为:\n");
            PrintPolyn(Lb);
            printf("排序后的结果为:\n");
            SortPolyn(Lb);
            PrintPolyn(Lb);
            Clear();
            break;
          case 6:
             system("cls");
             if(La->next&&Lb->next)
             {
                 DestoryPolyn(La);
                 DestoryPolyn(Lb);
                 printf("多项式销毁成功！\n");
                 Clear();
             }
             else
             {
                 printf("多项式不存在，请重新输入：\n");
                 Clear();
             }
             break;
          case 7:
            system("cls");
            Quit();
            Clear();
            break;
          default :
            printf("您的输入有误，请重新输入：\n");
            Clear();
            break;
    }
    }
    return 0;
}

要加强数据结构和指针的训练，要达到熟练运用的程度！！！

更新了一下程序代码：

Link *SubstractPolyn(Link *L,Link *La,Link *Lb)//多项式相减
{
   Link *q,*p;
   q=Lb;
   p=Lb->next;
   while(p!=NULL)
   {
       p->data.coef*=-1;//把Lb的系数变为它的相反数
       p=p->next;
   }
   L=AddPolyn(L,La,q);
   return L;
}

Link* CreatPolyn(Link *L) //创建多项式
{
   Link *q,*p; //创建一个新的节点
   int flag=0,i=1;
   L=(Link*)malloc(sizeof(Link));
   L->next=NULL;
   p=L;
   while(flag!=1)
   {
       q=(Link*)malloc(sizeof(Link));
       q->next=NULL;
       printf("输入第%d项的系数和指数:\n",i++);
       scanf("%f%d",&q->data.coef,&q->data.expn);
       p->next=q;
       p=q; //把节点链到多项式中
       printf("多项式是否输入完毕？（0/1）输入1结束输入\n");  //输入0继续输入 输入1结束输入
       scanf("%d",&flag);
   }
   p->next=NULL;
   if(flag==1)
   {
      printf("多项式输入完毕！\n");
   }
   return L;
}

int main()
{
    Link *L,*La,*Lb;
    int chioce;
    while(1)
    {
        system("color 2E");/*改变控制台颜色*/
        Menu();
        scanf("%d",&chioce);
        switch(chioce)
        {
          case 1:
            system("cls");
            printf("创建第一个多项式A：\n");
            La=CreatPolyn(La);
            getch();
            system("cls");
            printf("创建第二个多项式B：\n");
            Lb=CreatPolyn(Lb);
            Clear();
            break;
          case 2:
            system("cls");
            if(La->next==NULL||Lb->next==NULL)
            {
                  printf("您的多项式创建有误，请重新选择:\n");
                  Clear();
                  break;
            }
            printf("多项式A为：\n");
            PrintPolyn(La);
            printf("多项式B为：\n");
            PrintPolyn(Lb);
            Clear();
            break;
          case 3:
            system("cls");
            if(La->next==NULL||Lb->next==NULL)
            {
                  printf("您的多项式创建有误，请重新选择:\n");
                  Clear();
                  break;
            }
            printf("设相加的两个多项式为：\n");
            printf("多项式A为：\n");
            PrintPolyn(La);
            printf("多项式B为：\n");
            PrintPolyn(Lb);
            printf("相加的结果为：\n");
            L=AddPolyn(L,La,Lb);
            SortPolyn(L);
            PrintPolyn(L);
            Clear();
            break;
          case 4:
              system("cls");
               if(La->next==NULL||Lb->next==NULL)
            {
                  printf("您的多项式创建有误，请重新选择:\n");
                  Clear();
                  break;
            }
            printf("设相减的两个多项式为：\n");
            printf("多项式A为：\n");
            PrintPolyn(La);
            printf("多项式B为：\n");
            PrintPolyn(Lb);
            printf("相减的结果为：\n");
            L=SubstractPolyn(L,La,Lb);
            SortPolyn(L);
            PrintPolyn(L);
            Clear();
            break;
          case 5:
            system("cls");
            if(La->next==NULL||Lb->next==NULL)
            {
                  printf("您的多项式创建有误，请重新选择:\n");
                  Clear();
                  break;
            }
            printf("给多项式A排序:\n");
            printf("多项式A为:\n");
            PrintPolyn(La);
            printf("排序后的结果为:\n");
            SortPolyn(La);
            PrintPolyn(La);
            getch();
            system("cls");
            printf("给多项式B排序:\n");
            printf("多项式B为:\n");
            PrintPolyn(Lb);
            printf("排序后的结果为:\n");
            SortPolyn(Lb);
            PrintPolyn(Lb);
            Clear();
            break;
          case 6:
             system("cls");
             if(La->next&&Lb->next)
             {
                 DestoryPolyn(La);
                 DestoryPolyn(Lb);
                 printf("多项式销毁成功！\n");
                 Clear();
             }
             else
             {
                 printf("多项式不存在，请重新输入：\n");
                 Clear();
             }
             break;
          case 7:
            system("cls");
            Quit();
            Clear();
            break;
          default :
            printf("您的输入有误，请重新输入：\n");
            Clear();
            break;
    }
    }
    return 0;
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

数据结构课程设计之一元多项式的计算

数据结构课程设计之一元多项式的计算的相关文章

二叉树的镜像

题目描述操作给定的二叉树 xff0c 将其变换为源二叉树的镜像输入描述二叉树的镜像定义 xff1a 源二叉树 8 6 10 5 7 9 11 镜像二叉树 8 10 6 11 9 7 5 思路 xff1a 根节点下面的左子树和右子树分别
顺时针打印矩阵

题目描述输入一个矩阵 xff0c 按照从外向里以顺时针的顺序依次打印出每一个数字 xff0c 例如 xff0c 如果输入如下矩阵 xff1a 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1
包含min函数的栈

题目描述定义栈的数据结构 xff0c 请在该类型中实现一个能够得到栈最小元素的min函数思路 xff1a 用一个栈去存储所有元素然后一个一个去比较将小的那个值放到变量min里面 xff1b 代码如下 xff1a import jav
栈的压入、弹出序列

题目描述输入两个整数序列 xff0c 第一个序列表示栈的压入顺序 xff0c 请判断第二个序列是否为该栈的弹出顺序假设压入栈的所有数字均不相等例如序列1 2 3 4 5是某栈的压入顺序 xff0c 序列4 xff0c 5 3 2 1是
从上往下打印二叉树

题目描述从上往下打印出二叉树的每个节点 xff0c 同层节点从左至右打印思路 xff1a 意思就是按层遍历然后放到一个list集合里面去 xff0c 所以创建一个队列每次把一层的结点放进去 xff0c 然后一个一个判别是否有left结点
二叉搜索树的后序遍历序列

题目描述输入一个整数数组 xff0c 判断该数组是不是某二叉搜索树的后序遍历的结果如果是则输出Yes 否则输出No 假设输入的数组的任意两个数字都互不相同思路 xff1a 因为是二叉搜索树 xff0c 所以根节点的左子树小于右子树 x
二叉树中和为某一值的路径

题目描述输入一颗二叉树和一个整数 xff0c 打印出二叉树中结点值的和为输入整数的所有路径路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径思路 xff1a 用先序遍历递归的思想去实现 xff0c 到最后叶节点如果不能
复杂链表的复制

题目描述输入一个复杂链表 xff08 每个节点中有节点值 xff0c 以及两个指针 xff0c 一个指向下一个节点 xff0c 另一个特殊指针指向任意一个节点 xff09 xff0c 返回结果为复制后复杂链表的head xff08 注意
ubantu20下python安装和卸载

查看系统版本 python3 version 卸载ubantu上的python版本 sudo apt get remove python3 卸载python3及其依赖 sudo apt get remove auto remove pyth
[转]DBSCAN聚类算法——机器学习（理论+图解+python代码）

原文链接 xff1a https blog csdn net huacha article details 81094891 一前言二 DBSCAN聚类算法三参数选择四 DBSCAN算法迭代可视化展示五常用的评估方法 xff1
求1+2+3+...+n

题目描述求1 43 2 43 3 43 43 n xff0c 要求不能使用乘除法 for while if else switch case等关键字及条件判断语句 xff08 A B C xff09 思路 xff1a 用递归 xff08
把字符串转换成整数

题目描述将一个字符串转换成一个整数 xff0c 要求不能使用字符串转换整数的库函数思路 xff1a 设置两个标志位一个tag 为1表示是正数 xff0c 为0表示是负数 xff0c 一个index xff0c 为 43 则index是
数组中重复的数字

题目描述在一个长度为n的数组里的所有数字都在0到n 1的范围内数组中某些数字是重复的 xff0c 但不知道有几个数字是重复的也不知道每个数字重复几次请找出数组中任意一个重复的数字例如 xff0c 如果输入长度为7的数组 2 3 1
表示数值的字符串

题目描述请实现一个函数用来判断字符串是否表示数值 xff08 包括整数和小数 xff09 例如 xff0c 字符串 34 43 100 34 34 5e2 34 34 123 34 34 3 1416 34 和 34 1E 16 34 都
字符流中第一个不重复

题目描述请实现一个函数用来找出字符流中第一个只出现一次的字符例如 xff0c 当从字符流中只读出前两个字符 34 go 34 时 xff0c 第一个只出现一次的字符是 34 g 34 当从该字符流中读出前六个字符 google 34 时
链表中环的入口结点

需要学习资料的 43 微信公众号学习资源后台找我本人比较忙我看到了会在后台帮你 xff0c 谢谢关注啦题目描述一个链表中包含环 xff0c 请找出该链表的环的入口结点思路 xff1a 设置两个引用 A和B 指向头 xff0c 然
删除链表中重复的结点

需要学习资料的 43 微信公众号学习资源后台找我本人比较忙我看到了会在后台帮你 xff0c 谢谢关注啦题目描述在一个排序的链表中 xff0c 存在重复的结点 xff0c 请删除该链表中重复的结点 xff0c 重复的结点不保留 xf
二叉树的下一个结点

需要学习资料的 43 微信公众号学习资源后台找我本人比较忙我看到了会在后台帮你 xff0c 谢谢关注啦题目描述给定一个二叉树和其中的一个结点 xff0c 请找出中序遍历顺序的下一个结点并且返回注意 xff0c 树中的结点不仅包含

随机推荐

按之字形顺序打印二叉树

需要学习资料的 43 微信公众号学习资源后台找我本人比较忙我看到了会在后台帮你 xff0c 谢谢关注啦 import java util ArrayList import java util Queue import java uti
对称的二叉树

需要学习资料的 43 微信公众号学习资源后台找我本人比较忙我看到了会在后台帮你 xff0c 谢谢关注啦请实现一个函数 xff0c 用来判断一颗二叉树是不是对称的注意 xff0c 如果一个二叉树同此二叉树的镜像是同样的 xff0c
【unix】unix环境高级编程

文章目录 1 UNIX基础知识1 基本知识2 文件和目录3 输入和输出4 程序和进程5 出错处理6 用户标识7 信号8 时间9 系统调用和库函数标准化和实现1 标准化 ISO C POSIX Single UNIX Specificati
序列化反序列二叉树

需要学习资料的 43 微信公众号学习资源后台找我本人比较忙我看到了会在后台帮你 xff0c 谢谢关注啦题目描述请实现两个函数 xff0c 分别用来序列化和反序列化二叉树思路 xff1a 序列化的时候遇到null的结点就补充 xf
java 判断字符串是否为null的四种方法:

以下是java 判断字符串是否为空的四种方法 xff1a 方法一最多人使用的一个方法直观方便但效率很低 if s 61 61 null s equals 34 34 方法二比较字符串长度效率高是我知道的最好一个方法 if s
spring-boot推送实时日志到前端页面显示

个人技术网站欢迎关注网上有很多后台推送日志到前端页面的例子 xff0c 这里我也借鉴了别人的做法稍加改进一下以前做前端页面显示日志一般都会想到ajax轮询去做 xff0c 这样太耗费服务器资源了 xff0c 性能也很差使用长连接来
[Ubuntu][Android]快速配置Android USB设备的权限

1 复制如下内容到新建文本文件中 xff0c 并保存为51 android rules SUBSYSTEM 61 61 34 usb 34 ENV DEVTYPE 61 61 34 usb device 34 MODE 61 34 0666
shell脚本一次性将tab制表符改为4空格的方法

问题描述今天需要修改一些bash脚本 xff0c 因为考虑到pycharm里面能够直接写 xff0c 而我用pycharm比较多 xff0c 所以直接用pycharm写了 xff0c 由于改的那个bash脚本是别的同事写的 xff0c 里
matlab 并行计算 parfor

转自 xff1a http www xiongfuli com E5 B9 B6 E8 A1 8C E8 AE A1 E7 AE 97 2016 05 Matlab Parfor html 在Matlab下使用parfor实现多核并行计算
Windows安装和完全卸载MySQL8（以MySQL8.0.31版本为例）之 Zip 方式（超详细教程）

文章目录一前言二安装1 下载MySQL2 安装MySQL3 小结 xff1a 4 修改环境变量 3 完全卸载一前言 MySQL8相比之前版本改动还是挺大 xff0c 主要有以下几点 xff1a MySQL8之后并不需要my ini
Nginx显示500错误原因和解决方法

文章目录 1 背景2 Nginx 常见的几种报错3 解决500错误 1 背景最近在操作nginx 的时候出现了 Nginx 500 内部错误 xff0c 在此记录一下原因 xff0c 项目采用的是前后端分离方式 xff0c 后端Sprin
Cause: java.sql.SQLException: Expression #1 of ORDER BY clause is not in SELECT list

文章目录原因分析 xff1a 解决方法 xff1a 原因分析 xff1a mysql 8里sql mode 中 select distinct 不允许和 order by 连用可以查看 sql model show variables
14.2 shell函数参数

2 shell函数参数 2 1 位置参数2 2 选项参数2 2 1 getopts getopt的区别2 2 2 getopts的使用2 2 3 getopt的使用 Shell 函数参数的传递和其它编程语言不同 xff0c 没有所谓的形参和
protoc和protoc-gen-go-grpc安装及编译

一 install protocol buffer compiler PB REL 61 34 https github com protocolbuffers protobuf releases 34 curl LO PB REL dow
powershell 脚本解压zip文件到指定目录

span class token keyword Function span Unzip span class token operator span File span class token punctuation span span
不用第三方软件用DISM命令备份与还原win8系统

分享一个来自远景论坛的的教程如何通过dism命令给自己的win8系统备份和如何通过dism命令还原系统用 DISM 命令进行系统备份与还原不需要任何第三方软件 xff0c 是利用 Windows 7 Windows 8 系统自带的 DIS
ubuntu20.04+anaconda3+tensorflow-gpu2.1安装

磁盘分区 WIN系统中 xff0c 右键我的电脑管理磁盘管理 xff0c 首先留给Ubuntu一定的空间 xff0c 这里为600G左右 Ubuntu系统盘制作下载Ubuntu对应版本 xff0c 制作启动盘 Ubuntu安装 U盘启
nyist 27 水池数目（dfs搜索）

xfeff xfeff 水池数目时间限制 xff1a 3000 ms 内存限制 xff1a 65535 KB 难度 xff1a 4 描述南阳理工学院校园里有一些小河和一些湖泊 xff0c 现在 xff0c 我们把它们通一看成水池 xff
XTUOJ 1176 I Love Military Chess(模拟）

xfeff xfeff I Love Military Chess Accepted 45 Submit 141Time Limit 1000 MS Memory Limit 65536 KB 题目描述陆军棋 xff0c 又称陆战棋 xf
数据结构课程设计之一元多项式的计算

数据结构不是听会的 xff0c 也不是看会的 xff0c 是练会的 xff0c 对于写这么长的代码还是心有余也力不足啊 xff0c 对于指针的一些操作 xff0c 也还是不熟练 xff0c 总出现一些异常错误 xff0c 对于数据结构掌握还

数据结构课程设计之一元多项式的计算

数据结构课程设计之一元多项式的计算 的相关文章

随机推荐

热门标签

数据结构课程设计之一元多项式的计算的相关文章