NEFU-数据结构实验1-线性表_编写在非递减有序链表中插入一个元素(整型),使链表元素仍有序的函数(必须采用函数-CSDN博客

本文链接：https://blog.csdn.net/2301_80330802/article/details/135000351

1. 设有一个线性表存放在一个一维数组中的前n个数组元素位置。请编写一个顺序表的程序，将这个线性表原地逆置。(程序题, 10分)

2. 键盘输入一组元素，以0做结束输入的标记，建立一个带头结点的单向链表（无序，且值域为整型），遍历单向链表，显示相应元素。(程序题, 10分)

3. 试编写算法，把单向链表（值域为整型）中元素逆置（不允许申请新的结点空间）。(程序题, 10分)

4.编写在非递减有序链表中插入一个元素(整型)，使链表元素仍有序的函数（必须采用函数实现，否则不算成绩），并利用该函数建立一个非递减有序单向链表，之后输出这个有序的单链表。 (程序题, 10分)

5.试编写算法，在单向链表中删除所有的偶数元素结点。链表的创建和题目2要求一样。 (程序题, 10分)

6. 建立两个非递减有序单链表，然后合并成一个非递增有序的单链表。(程序题, 15分)

7. 编写算法建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。(程序题, 10分)

8.采用单向链表实现一元多项式的存储并，实现两个多项式相加，输出结果。 (程序题, 15分)

9. 将两个递增有序的单链表合并成一个递增有序的单链表，要求利用原表空间（注意重复值只保留一个）。输出合并后的单链表。设数据结点的值域为整型(程序题, 10分)

1. 设有一个线性表存放在一个一维数组中的前n个数组元素位置。请编写一个顺序表的程序，将这个线性表原地逆置。(程序题, 10分)

分别输出逆置前的顺序表和逆置后的顺序表。（顺序表的元素类型为整型）

输入：先输入一个整数n，表示顺序表的长度，之后输入n个整数

输出：两行（每个数之间用一个空格分隔）

第一行为原来的顺序表，第二行为逆置后的顺序表

#include <iostream>
#define MAXSIZE 100
typedef int ElemType;
typedef int Status;

using namespace std;

typedef struct
{
    ElemType *elem;
    int length;
}SqList;

Status InitList(SqList &L)
{
    L.elem=new int[MAXSIZE];
    if(!L.elem) exit(-2);
    L.length=0;
    return 1;
}

Status AddElem(SqList L,int n)
{
    int e;
    for(int i=0;i<n;i++)
    {
        cin >> e;
        L.elem[i]=e;
        L.length++;
    }
    return 1;
}

Status print(SqList L,int n)
{
    for(int i=0;i<n;i++)
    {
        cout << L.elem[i] << " ";
    }
    cout << endl;
    return 1;
}

Status nixu(SqList &L,int n)
{
    int sta=0;
    int mid;
    for(int i=1;i<=n/2;i++)
    {
        mid=L.elem[n-i];
        L.elem[n-i]=L.elem[sta];
        L.elem[sta]=mid;
        sta++;
    }
    return 1;
}

int main()
{
    int n;
    SqList L;
    InitList(L);
    cin >> n;
    AddElem(L,n);
    print(L,n);
    nixu(L,n);
    print(L,n);
}

2. 键盘输入一组元素，以0做结束输入的标记，建立一个带头结点的单向链表（无序，且值域为整型），遍历单向链表，显示相应元素。(程序题, 10分)

输入：1 2 3 4 5 6 7 8 0

输出：1 2 3 4 5 6 7 8

#include <iostream>
#define MAXSIZE 100
typedef int ElemType;
typedef int Status;

using namespace std;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

void CreatList(LinkList &L)
{
    LinkList r,s;
    ElemType num;
    L=new LNode;
    L->next=NULL;
    r=L;
    cin >> num;
    while(num!=0)
    {
        s=new LNode;
        s->data=num;
        s->next=NULL;
        r->next=s;
        r=s;
        cin >>num;
    }
}

void display(LinkList p)
{
    p=p->next;
    while(p!=NULL)
    {
        cout << p->data << " ";
        p=p->next;
    }
    cout << endl;
}

int main()
{
    LinkList L;
    CreatList(L);
    display(L);
    return 0;
}

3. 试编写算法，把单向链表（值域为整型）中元素逆置（不允许申请新的结点空间）。(程序题, 10分)

输入：输入方式和题目2 一样，以0作为结束输入的标记，元素不一样有序

输出：逆置后的单链表，元素之间用一个空格分隔

#include <iostream>
#define MAXSIZE 100
typedef int ElemType;
typedef int Status;

using namespace std;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

void CreatList(LinkList &L)
{
    LinkList r,s;
    ElemType num;
    L=new LNode;
    L->next=NULL;
    r=L;
    cin >> num;
    while(num!=0)
    {
        s=new LNode;
        s->data=num;
        s->next=NULL;
        r->next=s;
        r=s;
        cin >>num;
    }
}

void display(LinkList p)
{
    p=p->next;
    while(p!=NULL)
    {
        cout << p->data << " ";
        p=p->next;
    }
    cout << endl;
}

void nixu(LinkList &h)
{
    LinkList p,q;
    p=h->next;
    q=p->next;
    p->next=NULL;
    while(q!=NULL)
    {
        h->next=q;
        q=q->next;
        h->next->next=p;
        p=h->next;
    }
}

int main()
{
    LinkList L;
    CreatList(L);
    nixu(L);
    display(L);
    return 0;
}

4.编写在非递减有序链表中插入一个元素(整型)，使链表元素仍有序的函数（必须采用函数实现，否则不算成绩），并利用该函数建立一个非递减有序单向链表，之后输出这个有序的单链表。 (程序题, 10分)

输入：1 6 4 3 5 8 7 9 0

输出：1 3 4 5 6 7 8 9

#include <iostream>
#define MAXSIZE 100
typedef int ElemType;
typedef int Status;

using namespace std;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

void CreatList(LinkList &L)
{
    L=new LNode;
    L->next=NULL;
}

Status InsertList(LinkList &h,int x)
{
    LinkList r,p,q;
    q=h->next;
    p=h;
    while(q!=NULL&&q->data<x)
    {
        p=q;
        q=q->next;
    }
    r=new LNode;
    r->data = x;
    r->next=q;
    p->next =r;
    return 1;
}

void display(LinkList p)
{
    p=p->next;
    while(p!=NULL)
    {
        cout << p->data << " ";
        p=p->next;
    }
    cout << endl;
}

int main()
{
    LinkList L;
    CreatList(L);
    int x;
    cin >> x;
    while(x!=0)
    {
        InsertList(L,x);
        cin >> x;
    }
    display(L);
    return 0;
}

5.试编写算法，在单向链表中删除所有的偶数元素结点。链表的创建和题目2要求一样。 (程序题, 10分)

输入：-11 5 9 8 7 3 1 0

输出：-11 5 9 7 3 1

#include <bits/stdc++.h>
#define MAXSIZE 100
typedef int ElemType;
typedef int Status;

using namespace std;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

void CreatList(LinkList &L)
{
    LinkList r,s;
    ElemType num;
    L=new LNode;
    L->next=NULL;
    r=L;
    cin >> num;
    while(num!=0)
    {
        s=new LNode;
        s->data=num;
        s->next=NULL;
        r->next=s;
        r=s;
        cin >>num;
    }
}

/*
Status InsertList(LinkList &h,int x)
{
    LinkList r,p,q;
    q=h->next;
    p=h;
    while(q!=NULL&&q->data<x)
    {
        p=q;
        q=q->next;
    }
    r=new LNode;
    r->data = x;
    r->next=p->next;
    p->next =r;
    return 1;
}
*/

Status Deleteoushu(LinkList h)
{
    LinkList p,q;
    p=h;
    q=h->next;
    while(q!=NULL)
    {
        if(q->data%2==0)
        {
            p->next =q->next;
            free(q);
            q=p->next;
        }
        else
        {
            p=p->next;
            q=q->next;
        }
    }
    return 1;
}

void display(LinkList p)
{
    p=p->next;
    while(p!=NULL)
    {
        cout << p->data << " ";
        p=p->next;
    }
    cout << endl;
}

/*
void nixu(LinkList &h)
{
    LinkList p,q;
    p=h->next;
    q=p->next;
    p->next=NULL;
    while(q!=NULL)
    {
        h->next=q;
        q=q->next;
        h->next->next=p;
        p=h->next;
    }
}
*/

int main()
{
    LinkList L;
    CreatList(L);
    Deleteoushu(L);
    display(L);
    return 0;
}

6. 建立两个非递减有序单链表，然后合并成一个非递增有序的单链表。(程序题, 15分)

注意：建立非递减有序的单链表，需要采用题目4的算法

输入：

1 9 5 7 3 0

2 8 4 6 0

输出：

9 8 7 6 5 4 3 2 1

#include <iostream>
#define MAXSIZE 100
typedef int ElemType;
typedef int Status;

using namespace std;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

void CreatList(LinkList &L)
{
    L=new LNode;
    L->next=NULL;
}

Status InsertList(LinkList &h,int x)
{
    LinkList r,p,q;
    q=h->next;
    p=h;
    while(q!=NULL&&q->data<x)
    {
        p=q;
        q=q->next;
    }
    r=new LNode;
    r->data = x;
    r->next=q;
    p->next =r;
    return 1;
}

void RemakeList(LinkList h1,LinkList h2,LinkList &h3)
{
    LinkList l1,l2,l3,p;
    l1=h1->next;
    l2=h2->next;
    l3=h3;
    if(l1->data > l2->data)
    {
        l3->next=l2;
        l2=l2->next;
    }
    else
    {
        l3->next=l1;
        l1=l1->next;
    }
    l3=l3->next;
    l3->next=NULL;
    while(l2&&l1)
    {
       if(l1->data<l2->data)
       {
           l3->next=l1;
           l1=l1->next;
           l3=l3->next;
       }
       else
       {
           l3->next=l2;
           l2=l2->next;
           l3=l3->next;
       }
    }
    p=(l1!=NULL)?l1:l2;
    while(p)
    {
        l3->next=p;
        p=p->next;
        l3=l3->next;
    }
}

void display(LinkList p)
{
    p=p->next;
    while(p!=NULL)
    {
        cout << p->data << " ";
        p=p->next;
    }
    cout << endl;
}

void nixu(LinkList &h)
{
    LinkList p,q;
    p=h->next;
    q=p->next;
    p->next=NULL;
    while(q!=NULL)
    {
        h->next=q;
        q=q->next;
        h->next->next=p;
        p=h->next;
    }
}

int main()
{
    LinkList L1,L2,L3;
    CreatList(L1);
    CreatList(L2);
    CreatList(L3);
    int x;
    cin >> x;
    while(x!=0)
    {
        InsertList(L1,x);
        cin >> x;
    }
    cin >> x;
    while(x!=0)
    {
        InsertList(L2,x);
        cin >> x;
    }
    RemakeList(L1,L2,L3);
    nixu(L3);
    display(L3);
    return 0;
}

7. 编写算法建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。(程序题, 10分)

输入：1 2 3 4 5 6 7 8 9 0

输出：

1 3 5 7 9

2 4 6 8

#include <iostream>
#define MAXSIZE 100
typedef int ElemType;
typedef int Status;

using namespace std;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

void CreatList1(LinkList &L)
{
    LinkList r,s;
    ElemType num;
    L=new LNode;
    L->next=NULL;
    r=L;
    cin >> num;
    while(num!=0)
    {
        s=new LNode;
        s->data=num;
        s->next=NULL;
        r->next=s;
        r=s;
        cin >>num;
    }
}

void CreatList2(LinkList &L)
{
    L=new LNode;
    L->next=NULL;
}

void ChaifenList(LinkList &h1,LinkList &h2)
{
    LinkList l1,l2,l1p;
    l1=h1->next;
    l1p=h1;
    l2=h2;
    l2->next=NULL;
    while(l1!=NULL)
    {
        if(l1->data%2==0)
        {
            l1p->next=l1->next;
            l2->next=l1;
            l1=l1p->next;
            l2=l2->next;
        }
        else
        {
            l1p=l1p->next;
            l1=l1->next;
        }
    }
    l2->next=NULL;
}

void display(LinkList p)
{
    p=p->next;
    while(p!=NULL)
    {
        cout << p->data << " ";
        p=p->next;
    }
    cout << endl;
}

int main()
{
    LinkList L1,L2;
    CreatList1(L1);
    CreatList2(L2);
    ChaifenList(L1,L2);
    display(L1);
    display(L2);
    return 0;
}

8.采用单向链表实现一元多项式的存储并，实现两个多项式相加，输出结果。 (程序题, 15分)

输入说明：
4（请输入第一个一元多项式的项数）
2,2 3,3 5,5 7,7（请输入第一个一元多项式的系数和指数）
5（请输入第二个一元多项式的项数）
-2,2 2,3 4,4 5,7 9,9（请输入第二个一元多项式的系数和指数）

输出：

5*x^3 4*x^4 5*x^5 12*x^7 9*x^9

#include <bits/stdc++.h>
#define MAXSIZE 100

using namespace std;

typedef struct LNode
{
    int coef;
    int expn;
    struct LNode *next;
}LNode,*LinkList;

void CreatPolyn(LinkList &L,int n)
{
    LinkList pre,q,s;
    L=new LNode;
    L->next=NULL;
    for(int i=0;i<n;i++)
    {
        s=new LNode;
        scanf("%d,%d",&s->coef,&s->expn);
        pre=L;
        q=L->next;
        while(q&&q->expn < s->expn)
        {
            pre=q;
            q=q->next;
        }
        s->next=q;
        pre->next=s;
    }
}

void SumList(LinkList &h1,LinkList &h2)
{
    LinkList l1,l2,l3,r;
    int sum;
    l1=h1->next;
    l2=h2->next;
    l3=h1;
    while(l1&&l2)
    {
        if(l1->expn == l2->expn)
        {
            sum=l1->coef + l2->coef;
            if(sum!=0)
            {
                l1->coef=sum;
                l3->next=l1;
                l3=l1;
                l1=l1->next;
                r=l2;
                l2=l2->next;
                delete r;
            }
            else
            {
                r=l1;
                l1=l1->next;
                delete r;
                r=l2;
                l2=l2->next;
                delete r;
            }
        }
        else if(l1->expn < l2->expn)
        {
            l3->next=l1;
            l3=l1;
            l1=l1->next;
        }
        else
        {
            l3->next=l2;
            l3=l2;
            l2=l2->next;
        }
    }
    l3->next=l1?l1:l2;
    delete h2;
}

void display(LinkList p)
{
    p=p->next;
    while(p!=NULL)
    {
        cout << p->coef << "*x^" << p->expn << " ";
        p=p->next;
    }
    cout << endl;
}

int main()
{
    LinkList L1,L2;
    int a,b;
    cin >> a;
    CreatPolyn(L1,a);
    cin >> b;
    CreatPolyn(L2,b);
    SumList(L1,L2);
    display(L1);
    return 0;
}

9. 将两个递增有序的单链表合并成一个递增有序的单链表，要求利用原表空间（注意重复值只保留一个）。输出合并后的单链表。设数据结点的值域为整型(程序题, 10分)

输入说明：

输入n个有序的整数（无重复值），以0做结束，分别创建单链表A和B；

输出说明：

输出合并后的单链表，数据之间用一个空格分隔。

#include <bits/stdc++.h>
#define MAXSIZE 100
typedef int ElemType;
typedef int Status;

using namespace std;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

void CreatList(LinkList &L)
{
    L=new LNode;
    L->next=NULL;
}

Status InsertList(LinkList &h,int x)
{
    LinkList r,p,q;
    q=h->next;
    p=h;
    while(q!=NULL&&q->data<x)
    {
        p=q;
        q=q->next;
    }
    r=new LNode;
    r->data = x;
    r->next=q;
    p->next =r;
    return 1;
}

void RemakeList(LinkList &h1,LinkList &h2,LinkList &h3)
{
    LinkList l1,l2,l3,q;
    l1=h1->next;
    l2=h2->next;
    h3=h1;
    l3=h3;
    while(l1&&l2)
    {
        if(l1->data < l2->data)
        {
            l3->next=l1;
            l3=l1;
            l1=l1->next;
        }
        else if(l1->data > l2->data)
        {
            l3->next=l2;
            l3=l2;
            l2=l2->next;
        }
        else
        {
            l3->next=l1;
            l3=l1;
            l1=l1->next;
            q=l2;
            l2=l2->next;
            free(q);
        }
    }
    if(l1) l3->next=l1;
    else l3->next=l2;
}

void display(LinkList p)
{
    p=p->next;
    while(p!=NULL)
    {
        cout << p->data << " ";
        p=p->next;
    }
    cout << endl;
}

int main()
{
    LinkList L1,L2,L3;
    CreatList(L1);
    CreatList(L2);
    int x;
    cin >> x;
    while(x!=0)
    {
        InsertList(L1,x);
        cin >> x;
    }
    cin >> x;
    while(x!=0)
    {
        InsertList(L2,x);
        cin >> x;
    }
    RemakeList(L1,L2,L3);
    display(L1);
    return 0;
}