2. 程式人生 > >連結串列 （自寫模板）和一個簡單的應用（多項式相加和相乘）

連結串列 （自寫模板）和一個簡單的應用（多項式相加和相乘）

阿新 • • 發佈：2019-02-01

   CreateList(list_own *&L,int n)                         建立連結串列
   print(list_own *L)                                             列印連結串列
   List_insert(list_own *L,int i,int num)                 連結串列插入，插入在i之後。
   select(list_own *L,int i)                                     查詢第i個元素
   revise(list_own *L,int i,int num)                        將第i個元素替換為
   list_spot_delete(list_own *L,int i)                      將連結串列中第i個節點刪除
   DestroyList(list_own* &L)                                 刪除連結串列
   ListEmpty(list_own* &L)                                   判斷連結串列是否為空
   ListLength(list_own* L)                                     返回連結串列長度
   select_0(list_own *L,int num)                           查詢連結串列中是否含有某個節點的值
   Connect(list_own *&L1,list_own *&L2)            將倆個連結串列連線在一起
   Insert(list_own*&L,list_own*&num,int n)          將一個節點插入到連結串列中

#include<bits/stdc++.h>
using namespace std;
struct list_own
{
    int num;
    list_own *next;
};
void CreateList(list_own *&L,int n)
{
    L=(list_own*)malloc(sizeof(list_own));
    list_own* p1=(list_own*)malloc(sizeof(list_own));
    L->next=NULL;
    p1=L;
    list_own* p;
    for(int i=0;i<n;i++)
    {
        int tmp_num;
        p=(list_own*)malloc(sizeof(list_own));
        scanf("%d",&tmp_num);
        p->num=tmp_num;
        p->next=p1->next;
        p1->next=p;
        p1=p;
    }
}
void print(list_own *L)
{
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        printf("%d ",p_i->num);
    }
    printf("\n");
}
void List_insert(list_own *L,int i,int num)
{
    list_own *tmp_p=L->next;
    int t=0;
    if(i==0)
    {
        list_own*s=(list_own*)malloc(sizeof(list_own));
        s->next=tmp_p;
        L->next=s;
        s->num=num;
        return;
    }
    for(list_own* p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            list_own*s=(list_own*)malloc(sizeof(list_own));
            s->next=p_i->next;
            s->num=num;
            p_i->next=s;
            break;
        }
    }
}
int select(list_own *L,int i)
{
    list_own *tmp_p=L->next;
    int t=0;
    bool falg=false;
    for(list_own* p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            falg=true;
            return p_i->num;
        }
    }
    if(!falg)
    {
        printf("i>0&&i<=n");
        return 0;
    }
}
void revise(list_own *L,int i,int num)
{
    list_own *tmp_p=L->next;
    int t=0;
    bool falg=false;
    for(list_own *p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            p_i->num=num;
            falg=true;
            return ;
        }
    }
    if(!falg)
    {
        printf("i>0&&i<=n");
        return ;
    }
}
void list_spot_delete(list_own *L,int i)
{
    list_own *tmp_p=L->next;
    int t=0;
    if(i==1)
    {
        L->next=(tmp_p->next);
        free(tmp_p);
        return ;
    }
    for(list_own *p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==(i-1))
        {
            list_own *q=p_i->next;
            p_i->next=((p_i->next)->next);
            q->next=NULL;
            free(q);
            return ;
        }
    }
}
void DestroyList(list_own* &L)
{
    list_own* p;
    while(L)
    {
       p=L->next;
       free(L);
       L=p;
    }
    printf("連結串列空間釋放\n");
}
bool ListEmpty(list_own* &L)
{
    if(L->next==NULL) return true;
    else
    {
        return false;
    }
}
int ListLength(list_own* L)
{
    int ans=0;
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        ans++;
    }
    return ans;
}
void select_0(list_own *L,int num)
{
    int t=0;
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        t++;
       if(p_i->num==num)
       {
           printf("尋找成功，在%d位置",t);
           return ;
       }
    }
    printf("沒有找到\n");
}
void Connect(list_own *&L1,list_own *&L2)
{
    for(list_own *tmp_L1=L1->next;;tmp_L1=tmp_L1->next)
    {
        if((tmp_L1->next)==NULL)
        {
            tmp_L1->next=L2->next;
            break;
        }
    }
    DestroyList(L2);
    printf("連結串列連線成功，頭節點為第一個連結串列的頭節點\n");
}
void Insert(list_own*&L,list_own*&num,int n)
{
    if(num>0)
    {
        int t=0;
        for(list_own *i=L->next;i!=NULL;i=i->next)
        {
           t++;
           if(t==n-1)
           {
               num->next=i->next;
               i->next=num;
               break;
           }
        }
    }
}
/*
功能:
   CreateList(list_own *&L,int n)             建立連結串列
   print(list_own *L)                         列印連結串列
   List_insert(list_own *L,int i,int num)     連結串列插入，插入在i之前。
   select(list_own *L,int i)                  查詢第i個元素
   revise(list_own *L,int i,int num)          將第i個元素替換為
   list_spot_delete(list_own *L,int i)        將連結串列中第i個節點刪除
   DestroyList(list_own* &L)                  刪除連結串列
   ListEmpty(list_own* &L)                    判斷連結串列是否為空
   ListLength(list_own* L)                    返回連結串列長度
   select_0(list_own *L,int num)              查詢連結串列中是否含有某個節點的值
   Connect(list_own *&L1,list_own *&L2)       將倆個連結串列連線在一起
   Insert(list_own*&L,list_own*&num,int n)    將一個節點插入到連結串列中
*/
int main ()
{
}

多項式相加與相乘：

#include<bits/stdc++.h>
using namespace std;
struct list_own
{
    int num;
    list_own *next;
};
const int maxn=1e5;
int a[maxn];
void CreateList(list_own *&L,int n)
{
    L=(list_own*)malloc(sizeof(list_own));
    list_own* p1=(list_own*)malloc(sizeof(list_own));
    L->next=NULL;
    p1=L;
    list_own* p;
    for(int i=0;i<n;i++)
    {
        int tmp_num;
        p=(list_own*)malloc(sizeof(list_own));
        scanf("%d",&tmp_num);
        p->num=tmp_num;
        p->next=p1->next;
        p1->next=p;
        p1=p;
    }
}
void print(list_own *L)
{
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        printf("%d ",p_i->num);
    }
    printf("\n");
}
void List_insert(list_own *L,int i,int num)
{
    list_own *tmp_p=L->next;
    int t=0;
    if(i==0)
    {
        tmp_p=NULL;
        list_own*s=(list_own*)malloc(sizeof(list_own));
        s->next=tmp_p;
        L->next=s;
        s->num=num;
        return;
    }
    for(list_own* p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            list_own*s=(list_own*)malloc(sizeof(list_own));
            s->next=p_i->next;
            s->num=num;
            p_i->next=s;
            break;
        }
    }
}
int select(list_own *L,int i)
{
    list_own *tmp_p=L->next;
    int t=0;
    bool falg=false;
    for(list_own* p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            falg=true;
            return p_i->num;
        }
    }
    if(!falg)
    {
        printf("i>0&&i<=n");
        return 0;
    }
}
void revise(list_own *L,int i,int num)
{
    list_own *tmp_p=L->next;
    int t=0;
    bool falg=false;
    for(list_own *p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==i)
        {
            p_i->num=num;
            falg=true;
            return ;
        }
    }
    if(!falg)
    {
        printf("i>0&&i<=n");
        return ;
    }
}
void list_spot_delete(list_own *L,int i)
{
    list_own *tmp_p=L->next;
    int t=0;
    if(i==1)
    {
        L->next=(tmp_p->next);
        free(tmp_p);
        return ;
    }
    for(list_own *p_i=tmp_p;p_i!=NULL;p_i=p_i->next)
    {
        t++;
        if(t==(i-1))
        {
            list_own *q=p_i->next;
            p_i->next=((p_i->next)->next);
            q->next=NULL;
            free(q);
            return ;
        }
    }
}
void DestroyList(list_own* &L)
{
    list_own* p;
    while(L)
    {
       p=L->next;
       free(L);
       L=p;
    }
    printf("連結串列空間釋放\n");
}
bool ListEmpty(list_own* &L)
{
    if(L->next==NULL) return true;
    else
    {
        return false;
    }
}
int ListLength(list_own* L)
{
    int ans=0;
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        ans++;
    }
    return ans;
}
void select_0(list_own *L,int num)
{
    int t=0;
    for(list_own* p_i=L->next;p_i!=NULL;p_i=p_i->next)
    {
        t++;
       if(p_i->num==num)
       {
           printf("尋找成功，在%d位置",t);
           return ;
       }
    }
    printf("沒有找到\n");
}
void Connect(list_own *&L1,list_own *&L2)
{
    for(list_own *tmp_L1=L1->next;;tmp_L1=tmp_L1->next)
    {
        if((tmp_L1->next)==NULL)
        {
            tmp_L1->next=L2->next;
            break;
        }
    }
    DestroyList(L2);
    printf("連結串列連線成功，頭節點為第一個連結串列的頭節點\n");
}
void Insert(list_own*&L,list_own*&num,int n)
{
    if(num>0)
    {
        int t=0;
        for(list_own *i=L->next;i!=NULL;i=i->next)
        {
           t++;
           if(t==n-1)
           {
               num->next=i->next;
               i->next=num;
               break;
           }
        }
    }
}
/*
功能:
   CreateList(list_own *&L,int n)             建立連結串列
   print(list_own *L)                         列印連結串列
   List_insert(list_own *L,int i,int num)     連結串列插入，插入在i之後。
   select(list_own *L,int i)                  查詢第i個元素
   revise(list_own *L,int i,int num)          將第i個元素替換為
   list_spot_delete(list_own *L,int i)        將連結串列中第i個節點刪除
   DestroyList(list_own* &L)                  刪除連結串列
   ListEmpty(list_own* &L)                    判斷連結串列是否為空
   ListLength(list_own* L)                    返回連結串列長度
   select_0(list_own *L,int num)              查詢連結串列中是否含有某個節點的值
   Connect(list_own *&L1,list_own *&L2)       將倆個連結串列連線在一起
   Insert(list_own*&L,list_own*&num,int n)    將一個節點插入到連結串列中
*/
int main ()
{
    list_own *La;
    list_own *Lb;
    int n,m,x;
     cout<<"規則如下："<<endl<<"1:格式為：a*x^0+b*x^1+c*x^2+......"<<endl;
     cout<<"2:輸入1進入多項式相加，輸入2進入多項式相乘"<<endl;
     scanf("%d",&x);
    if(x==1)
    {
    cout<<"請分別輸入倆個多項式的最高次冪是多少"<<endl;
    scanf("%d%d",&n,&m);
    cout<<"輸入係數a,b,c........."<<endl;
    CreateList(La,n);
    CreateList(Lb,m);
    list_own *Lc;
    Lc=(list_own*)malloc(sizeof(list_own));
    int t=0;
    int num1,num2;
    for(list_own *p1=La->next,*p2=Lb->next;p1!=NULL||p2!=NULL;)
    {
        if(p1!=NULL&&p2==NULL)
        {
            num2=0;
            num1=p1->num;
            p1=p1->next;
        }
        else if(p2!=NULL&&p1==NULL)
        {
            num1=0;
            num2=p2->num;
            p2=p2->next;
        }
        else
        {
            num1=p1->num;
            num2=p2->num;
            p1=p1->next;
            p2=p2->next;
        }
        List_insert(Lc,t++,num1+num2);
    }
    t=0;
    for(list_own *p1=Lc->next;p1!=NULL;p1=p1->next)
    {
        if(p1->next!=NULL) printf("%d*x^%d+",p1->num,t++);
        else
        {
            printf("%d*x^%d=0\n",p1->num,t++);
        }
    }
    }
    else if(x==2)
    {
            cout<<"請分別輸入倆個多項式的最高次冪是多少"<<endl;
            scanf("%d%d",&n,&m);
            cout<<"輸入係數a,b,c........."<<endl;
             CreateList(La,n);
             CreateList(Lb,m);
             list_own *Lc;
             Lc=(list_own*)malloc(sizeof(list_own));
             int tmp=0;
             int t=0;
             int t1=1,t2=1;
             for(list_own *p1=La->next;p1!=NULL;p1=p1->next)
             {
                 int tmp_num=0;
                 for(list_own *p2=La->next;p2!=NULL;p2=p2->next)
                 {
                     tmp_num=(p1->num*p2->num);
                     a[t1+t2]=tmp_num;
                     t2++;
                 }
                 t1++;
                 t2=1;
             }
             t2=ListLength(Lb);
             t1=ListLength(La);
             cout<<"t2:"<<t2<<endl;
             cout<<"t1:"<<t1<<endl;
             for(int i=2;i<=t1+t2;i++)
             {
                 List_insert(Lc,i-2,a[i]);
             }
              t=0;
             for(list_own *p1=Lc->next;p1!=NULL;p1=p1->next)
             {
                 if(p1->next!=NULL)
                 {
                     printf("%d*x^%d+",p1->num,t++);
                 }
                 else
                 {
                     printf("%d*x^%d\n",p1->num,t++);
                 }
             }
    }
    return 0;
}

相關推薦

連結串列 （自寫模板）和一個簡單的應用（多項式相加和相乘）

   CreateList(list_own *&L,int n)                         建立連結串列    print(list_own *L)                                             列

支持向量機（SVM）的一個簡單應用實例及matlab代碼

.com 自帶 under 內容 AD 軟件 tex 分類器 ref 數據集下載地址 ：http://pan.baidu.com/s/1geb8CQf 一、實驗目的 1．掌握支持向量機（SVM）的原理、核函數類型選擇以及核參數選擇原則等； 2．熟悉基於libSVM二分類的一

withRouter的作用和一個簡單應用

通過 必須 情況下 style route 瀏覽器中 type red 用途 作用：把不是通過路由切換過來的組件中，將react-router 的 history、location、match 三個對象傳入props對象上 默認情況下必須是經過路由匹配渲染的組件才存在t

python入門：求1-2+3-4+5...99的所有數的和（自寫）

== 余數 奇數 nbsp int 當前 pre span bre 1 #!/usr/bin/env pyhton 2 # -*- coding:utf-8 -*- 3 #求1-2+3-4+5...99的所有數的和（自寫） 4 """ 5 給x賦值為0，給y賦值

寫一個簡單的配置文件和日誌管理（shell）

客戶端 數據 時間 r+ socket編程 har stdout scan 語言 最近在做一個Linux系統方案的設計，寫了一個之前升級服務程序的配置和日誌管理。 共4個文件，服務端一個UpdateServer.conf配置文件和一個UpdateServer腳本，客戶端一個

三級菜單、購物車程序（自寫，待優化）

pan 余額 設立 ike dig 查詢 lag pass 菜單 一、三級菜單程序： 要求： 1. 可依次進入各子菜單 2.可從任意一層往回退到上一層 3. 可從任意一層退出程序 各級菜單詳情見代碼： menu = { ‘北京‘:{ ‘海澱‘:

vue alert外掛（標題為圖片）（自寫）

<template> <div class="modelSelf"> <div class="model" @click="modelHide"></div> <div class="modelTip"> <

Zabbix4.0.1使用自帶模板監控Linux主機基本選項（CPU、記憶體、硬碟、網絡卡）

zabbix_agent 端            ip : 192.168.1.206      hostname:  www.test3.com   1、新增主機  

Pico手柄互動（自寫指令碼）

因為近期公司談了一個小怪獸一體機的專案需要使用到Pvr_SDK，然後在網上找了好久發現有關的文章寥寥無幾，並且找了官方技術問了一下才發現在我需要的手柄互動方面官方提供的API上簡直了我去，就一種UI互動而且。並且SDK上面的手柄互動的那個DEMO上面，我發現你把UI往前或者往後條一下位置都會

資料結構實驗之連結串列七：單鏈表中重複元素的刪除（SDUT 2122）

#include <bits/stdc++.h> using namespace std; typedef struct node { int data; struct no

歐幾裏德算法（自寫理解）

約數 但是 們的 這樣的 拓展 軌跡 等於 spa -- gcd歐幾裏德算法 求取最大公約數gcd(a,b) 這個不用多說了 extgcd拓展歐幾裏德算法 用於求解 ax+by=gcd(a,b)的解 這個要多說一下 ax+by=c,（a,b,c都

連結串列的簡單應用（C語言）

#include <stdio.h> #include<stdlib.h> #include<string.h> #include<conio.h> typedef struct List{ char na

python 核心程式設計第二版9章習題答案（自寫）

test 9.1 fileload = 'C:/Users/Administrator/Desktop/test/test9.1.txt' f = open(fileload,'r') for eachline in f: for ps in ea

jquery圖片輪播，點選左右按鈕輪播，可控制是否自動播放，是否迴圈輪播（自寫）

<!DOCTYPE html> <html lang="zh-CN"> <head>     <meta charset="UTF-8">     <title>輪播</title>     <

俄羅斯方塊程式碼（自寫）

所用編譯器：Visual Studio 2013 所用語言：C 所寫程式碼簡單易學耐心看完全可看懂 #include <Windows.h> #include <time.h> #include <stdio.h> #include

單向連結串列反轉，就地逆置與遞迴反轉（無表頭結點）

最近在看連結串列，今天刷到一道連結串列的反轉題，連結串列反轉可以說是基礎操作，但是可提供的方案也有很多，簡單通過了該題後又學習了一下遞迴反轉，現在把三種方法都公開出來做一個總結。 1.就地逆置 2.單引數的遞迴逆置 3.雙引數的遞迴逆置 一、就地逆置 方法：頭插。 由於這裡是不帶表頭結點的單向連結串列，所以頭

IOS xib在tableview上的簡單應用（通過xib自定義cell）

make aso eat 常用 last creat path ins div UITableView是一種常用的UI控件，在實際開發中，由於原生api的局限，自定義UITableViewCell十分重要，自定義cell可以通過代碼，也可以通過xib。 這篇隨筆介紹的是通過

洗禮靈魂，修煉python（3）--從一個簡單的print代碼揭露編碼問題，運行原理和語法習慣

比較 編譯 windows 機器 函數 容易 打印字符 出現 無法 前期工作已經準備好後，可以打開IDE編輯器了，你可以選擇python自帶的IDLE，也可以選擇第三方的，這裏我使用pycharm——一個專門為python而生的編譯器 第一個python代碼當然是所有開發語

我的第一個RN應用（漂亮的首頁和笑話列表）

native exp index shee str import 折騰 load port 　　對於不想折騰Android(or Kotlin)的Phper來說，要寫app，RN真的是個不錯的選擇。 　　開發環境就不多說了，用npm輕松搞定，容易被墻，自行解決。 　　先看下

nodejs 模板引擎ejs的簡單使用（3）

技術 head http html bsp alt {} 輸出 body 1.ejs <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <ti