数据结构实验报告（一）

实验报告一 顺序表和链表
（1）实验内容
1．随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。
2．遍历单向链表。
3．把单向链表中元素逆置（不允许申请新的结点空间）。
4．在单向链表中删除所有的偶数元素结点。
5．编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表。
6．利用算法5建立两个非递减有序单向链表，然后合并成一个非递增链表。
7．利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。
8．利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。
* 9．采用单向链表实现一元多项式的存储并实现两个多项式相加并输出结果。
10．在主函数中设计一个简单的菜单，分别调试上述算法。
*11．综合训练：利用链表实现一个班级学生信息管理（数据录入、插入、删除、排序、查找等，并能够实现将数据存储到文件中）

1）顺序表实现基本操作
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10
using namespace std;
typedef int Elemtype;
//抽象化元素类型，到时候可根据需要将int修改成其他的基本数据类型
typedef struct {
Elemtype data[MaxSize];
int length;
}Sqlist;
//1.构造新的顺序表L
//这种创建方法在逻辑上是不对的，因为数组的长度已经规定，不能无限制地输入数据元素
Sqlist createSqlist(){
Sqlist l;//length此时不为0，而是随机分配的一个数字
int x;
scanf ("%d",&x);
int i=0;
l.length=0;
while (x!=-999){
    l.data[i]=x;
    l.length++;
    i++;
    scanf("%d",&x);//勿忘重新读入数据
}
return l;
}
void displaySqlist(Sqlist &l){//加不加引用的区别？？
for (int i=0;i<l.length;i++){
    printf("%d ",l.data[i]);
}
printf("
");
}
//初始化顺序表
void InitSqlist(Sqlist &l){
 l.length=0;
}
//插入：在第i个元素之前
void InsertSqlist(Sqlist &l,int i,Elemtype e){
//1.判断I的位置是否合理
if (i<1||i>l.length+1)//可以插在最后一个位置
    printf("positon error");
for (int j=l.length;j>i-1;j--){
    l.data[j]=l.data[j-1];
}
l.data[i-1]=e;
l.length++;
}

void readitemSqlist(Sqlist &l){
int x;
scanf ("%d",&x);
int i=0;
while (x!=-999&&l.length<=MaxSize){
    l.data[i]=x;
    i++;
    scanf ("%d",&x);
    l.length++;
}
}
//有返回值的插入方法
int InsertSqlist2(Sqlist &l,int i,Elemtype e){
//1.判断I的位置是否合理
if (i<1||i>l.length+1){
   printf("positon error");
   return 0;
}

for (int j=l.length;j>i-1;j--){
    l.data[j]=l.data[j-1];
}
l.data[i-1]=e;
l.length++;
return 1;
}
int deleteSqlist (Sqlist &l,int i,Elemtype &e){
//删除i之前的元素，回收到e中
if (i<1||i>l.length){
    printf("positon error");
    return 0;
}
e=l.data[i-1];
for (int j=i-1;j<l.length-1;j++){
    l.data[j]=l.data[j+1];
}
l.length--;
return 1;
}
int locateSqlist (Sqlist &l,Elemtype e){
for (int i=0;i<l.length;i++){
    if (l.data[i]==e)
        return i+1;//返回的是序号
}
printf("can not find it !");
return 0;
//另一种做法
//int i=l.length;
//while (i>=0&&l.data[i]!=x) i--;
//return i+1;
//if (i==-1)
//return 0;
}
int main()
{
   Sqlist l;
   InitSqlist(l);
   readitemSqlist(l);
   displaySqlist(l);
   Elemtype e=5;
   int i=locateSqlist(l,e);
   printf("%d",i);

}
2）单链表实现基本操作
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;


    typedef int Elemtype;
    typedef struct node
    {
        Elemtype data;
        struct node *next;
    } node,*linklist;
    linklist creatlinklist()
    {
        //尾插法建立单链表
        linklist l,p,q;
        l=(linklist)malloc(sizeof(node));
        p=l;
        int x;
        scanf("%d",&x);
        while (x!=-999)
        {
            q=(linklist)malloc(sizeof(node));
            q->data=x;
            p->next=q;
            q->next=NULL;
            p=q;
            scanf("%d",&x);
        }
        return l;
    }
    void displaylinklist(linklist l)
    {
        linklist p=l->next;
        while (p!=NULL)
        {
            printf("%d ",p->data);
            p=p->next;
        }
        printf("
");
    }
    void nizhilinklist(linklist &l)
    {
        linklist p,q;//p指向后面结点，q指向当前结点
        q=l;
        p=l->next;
        l->next=NULL;//解放头结点
        while(p!=NULL)
        {
            q=p;//q指向即将头插法的结点
            p=p->next;//保存后面的结点首地址；
            q->next=l->next;
            l-> next=q;
        }

    }
    void deletelinklist(linklist &l)
    {
        linklist p=l;
        //p指向待删除元素的前面的位置，必须要从L开始，不然第一个元素无法删除
        while (p!=NULL)
        {
            if(p->next==NULL)//如果最后一个元素是奇数要特别对待
                break;
            if (p->next->data%2==0)
            {
                p->next=p->next->next;
            }
            p=p->next;

        }
    }
    void insertlinklist(linklist &l)
    {
         Elemtype x;
        scanf("%d",&x);
        linklist p;
        linklist q;
        p=l;
        while (p->next!=NULL&&p->next->data < x)
        {
        p=p->next;
        }
        if (p->next!=NULL){
            q=(linklist )malloc(sizeof(node));
            q->data=x;
            q->next=p->next;
            p->next=q;
        }
        if (p->next==NULL)
        {
            p->next=q;
            q->next=NULL;
        }
    }
    void mergelinklist(linklist &la,linklist &lb,linklist &lc){
    //假设la与lb为非递减有序单向链表
    lc=la;
    linklist pa=la->next,pb=lb->next,pc=lc;
    lc->next=NULL;
    while (pa!=NULL&&pb!=NULL){
        if (pa->data > pb->data){
         pc->next=pb;
         pc=pb;
         pb=pb->next;
    }
     if (pa->data <= pb->data){
         pc->next=pa;
         pc=pa;
         pa=pa->next;
    }

    }
    if (pa!=NULL)
        pc->next=pa;
    if (pb!=NULL)
        pc->next=pb;
        free(lb);
        //free(la)??
        //这里判断条件如果用==，那么while循环出来的一定都满足该条件，所以要用不等于



    }
    void mergenizhilinklist(linklist &la,linklist &lb,linklist &lc){
    mergelinklist(la,lb,lc);
    nizhilinklist(lc);
    }
    linklist dividelinklist(linklist &l){
    linklist h=(linklist)malloc(sizeof(node));
    h->next=NULL;
    linklist p=l,q=h;
    while(p!=NULL){
            if(p->next==NULL)
            break;//最后为偶数
        if (p->next->data%2!=0){
            q->next=p->next;
            q=p->next;
            p->next=q->next;
            p=p->next;
        }
        p=p->next;
    }
    q->next=NULL;
    return h;
    //这里或许可以用头插法建立？？

    }
   //实现一元多项式
typedef struct {
float conf;
int expn;
}Elemtype;

typedef struct pnode{
Elemtype data;
struct pnode *next;
}pnode,*linklist;

linklist creatPolylist(){
linklist l=(linklist )malloc(sizeof(pnode));
linklist p=l,q;
float con;
int exp;
scanf ("%f %d",&con,&exp);

while (exp!=-1){
    q=(linklist )malloc(sizeof(pnode));
    (q->data).conf=con;
    (q->data).expn=exp;
    p->next=q;
    p=q;
    scanf ("%f %d",&con,&exp);
}
p->next=NULL;
return l ;
}
void displayPoly(linklist &l){
linklist p=l->next;
while (p!=NULL){
    printf("(%.2f %d)",((p->data).conf),((p->data).expn));
    p=p->next;
}
printf("
");
}
void addPoly(linklist &la,linklist &lb){
linklist pa=la,pb=lb,qa,qb;
qa=pa->next;
qb=pb->next;
int sum;
while (qa!=NULL&&qb!=NULL){
if (qa->data.expn < qb->data.expn){
pa=qa;
qa=qa->next;
}else if(qa->data.expn = qb->data.expn){
sum=qa->data.conf + qb->data.conf;
if (sum!=0){
qa->data.conf=sum;
pa=qa;
qa=qa->next;
pb=qb->next;
free(qb);
qb=qb->next;//释放B链表中的重复系数结点，这样不占用任何多余空间。
}else {
    pa=qa->next;
    pb=qb->next;
    free(qa);
    free(qb);
    qa=pa->next;
    qb=pb->next;//两个结点都要释放

}
}else {
pa->next=qb;
qb->next=qa;
pa=qb;
qb=qb->next;//在la链表中插入B中的一个结点，仍旧保持Pa为Qa的前驱，qb后移
}
}
if(qb!=NULL)
qa->next=qb;
}