数据结构实验报告1

1．随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。
typedef int Elemtype;
typedef struct node
{
    Elemtype data;
    struct node *next;
} Node,*LinkList;
LinkList Createlist()//构建先进后出链表；
{
    LinkList L,p;
    L=(LinkList)malloc(sizeof(Node));
    L->next=NULL;
    printf("please input the numbers :\n");
    Elemtype x;
    cin>>x;
while(x!=0)
    {
        p=(LinkList)malloc(sizeof(Node));
        p->data=x;
        p->next=L->next;
        L->next=p;
        cin>>x;
    }
return L;
}

2．遍历单向链表。
void put(LinkList H)//输出链表里的值
{
    LinkList L=H;
    LinkList q;
while(L->next!=NULL)
    {
        L=L->next;
        q=L;
        printf("%d ",q->data);
    }
    cout<<endl;
}

3．把单向链表中元素逆置（不允许申请新的结点空间）。
void nizhi(LinkList &H)//将链表逆置
{
    LinkList L=H;
    LinkList p,q;
    p=L->next;
    L->next=NULL;
while(p)
    {
        q=p;
        p=p->next;
        q->next=L->next;
        L->next =q;
    }
}

4.在单向链表中删除所有的偶数元素结点。
void deleteDE(LinkList &H)//删除值为偶数的元素
{
    LinkList L=H,q,p;
while(L->next!=NULL)
    {
        p=L->next;
if(p->data%2==0)
        {
            q=p->next;
            free(p);
            L->next=q;
        }
else
            L=L->next;
    }
}

5．编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表。
void insert(LinkList &H,int x)
{
    LinkList L=H,p,q;
while(L->next!=NULL)
    {
        L=L->next;
        p=L;
if(p->data<=x&&p->next->data>=x)
        {
            q=(LinkList)malloc(sizeof(Node));
            q->data=x;
            q->next=p->next;
            p->next=q;
            q=NULL;
            break;
        }
    }
if(q!=NULL)
    {
        q=(LinkList)malloc(sizeof(Node));
        q->data=x;
        q->next=NULL;
        L->next=q;
    }
}
LinkList Createlist1(LinkList &H)//构建非递减有序单向链表；
{
    LinkList L,p,q=H;
    L=(LinkList)malloc(sizeof(Node));
    L->next=NULL;
    Elemtype x;
    q=H->next;
while(q!=NULL)
    {
        x=q->data;
        p=(LinkList)malloc(sizeof(Node));
        p->data=x;
        p->next=L->next;
        L->next=p;
        q=q->next;
    }
return L;
}
6．利用算法5建立两个非递减有序单向链表，然后合并成一个非递增链表。
void hebing(LinkList &H,LinkList &L)
{
    LinkList p=H;
while(p->next!=NULL)
    {
        p=p->next;
        insert(L,p->data);
    }
    Createlist1(L);
    nizhi(L);
}

7．利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。
void hebing2(LinkList &H,LinkList &L)
{
    LinkList p=H;
while(p->next!=NULL)
    {
        p=p->next;
        insert(L,p->data);
    }
    Createlist1(L);
}
8．利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。
void sort4(LinkList H)//分为左右两部分，左边的元素为奇数，右边所有元素为偶数
{
    LinkList L=H,p,q,r,s;
    r=L;
    p=L->next;
    int j=0;
while(p!=NULL)
    {
        s=p;//s为最后一个节点；
        p=p->next;
        j++;
    }
    r=L;
    p=L->next;
    q=p->next;
    for(int i=0; i<j-1; i++)
    {
if((p->data)%2==0)
        {
            r->next=q;
            p->next=NULL;
            s->next=p;
            s=p;
            p=q;
            q=p->next;
        }
else
        {
            r=p;
            p=q;
            q=p->next;
        }
    }
}
void fenjie(LinkList H,LinkList L)
{
    LinkList q=H,p;
    q=q->next;
while(q->data%2==1)
    {
        Elemtype x;
        x=q->data;
        p=(LinkList)malloc(sizeof(Node));
        p->data=x;
        p->next=L->next;
        L->next=p;
        H->next=q->next;
        free(q);
        q=H->next;
    }
}

10．在主函数中设计一个简单的菜单，分别调试上述算法。
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;

//1．随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。
typedef int Elemtype;
typedef struct node
{
    Elemtype data;
    struct node *next;
} Node,*LinkList;
LinkList Createlist()//构建先进后出链表；
{
    LinkList L,p;
    L=(LinkList)malloc(sizeof(Node));
    L->next=NULL;
    printf("please input the numbers :\n");
    Elemtype x;
    cin>>x;
while(x!=0)
    {
        p=(LinkList)malloc(sizeof(Node));
        p->data=x;
        p->next=L->next;
        L->next=p;
        cin>>x;
    }
return L;
}

//2．遍历单向链表。
void put(LinkList H)//输出链表里的值
{
    LinkList L=H;
    LinkList q;
while(L->next!=NULL)
    {
        L=L->next;
        q=L;
        printf("%d ",q->data);
    }
    cout<<endl;
}

//3．把单向链表中元素逆置（不允许申请新的结点空间）。
void nizhi(LinkList &H)//将链表逆置
{
    LinkList L=H;
    LinkList p,q;
    p=L->next;
    L->next=NULL;
while(p)
    {
        q=p;
        p=p->next;
        q->next=L->next;
        L->next =q;
    }
}

//4.在单向链表中删除所有的偶数元素结点。
void deleteDE(LinkList &H)//删除值为偶数的元素
{
    LinkList L=H,q,p;
while(L->next!=NULL)
    {
        p=L->next;
if(p->data%2==0)
        {
            q=p->next;
            free(p);
            L->next=q;
        }
else
            L=L->next;
    }
}

//5．编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表。
void insert(LinkList &H,int x)
{
    LinkList L=H,p,q;
while(L->next!=NULL)
    {
        L=L->next;
        p=L;
if(p->data<=x&&p->next->data>=x)
        {
            q=(LinkList)malloc(sizeof(Node));
            q->data=x;
            q->next=p->next;
            p->next=q;
            q=NULL;
            break;
        }
    }
if(q!=NULL)
    {
        q=(LinkList)malloc(sizeof(Node));
        q->data=x;
        q->next=NULL;
        L->next=q;
    }
}
LinkList Createlist1(LinkList &H)//构建非递减有序单向链表；
{
    LinkList L,p,q=H;
    L=(LinkList)malloc(sizeof(Node));
    L->next=NULL;
    Elemtype x;
    q=H->next;
while(q!=NULL)
    {
        x=q->data;
        p=(LinkList)malloc(sizeof(Node));
        p->data=x;
        p->next=L->next;
        L->next=p;
        q=q->next;
    }
return L;
}

//6．利用算法5建立两个非递减有序单向链表，然后合并成一个非递增链表。
void hebing(LinkList &H,LinkList &L)
{
    LinkList p=H;
while(p->next!=NULL)
    {
        p=p->next;
        insert(L,p->data);
    }
    Createlist1(L);
    nizhi(L);
}

//7．利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。
void hebing2(LinkList &H,LinkList &L)
{
    LinkList p=H;
while(p->next!=NULL)
    {
        p=p->next;
        insert(L,p->data);
    }
    Createlist1(L);
}

//8．利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。
void sort4(LinkList H)//分为左右两部分，左边的元素为奇数，右边所有元素为偶数
{
    LinkList L=H,p,q,r,s;
    r=L;
    p=L->next;
    int j=0;
while(p!=NULL)
    {
        s=p;//s为最后一个节点；
        p=p->next;
        j++;
    }
    r=L;
    p=L->next;
    q=p->next;
    for(int i=0; i<j-1; i++)
    {
if((p->data)%2==0)
        {
            r->next=q;
            p->next=NULL;
            s->next=p;
            s=p;
            p=q;
            q=p->next;
        }
else
        {
            r=p;
            p=q;
            q=p->next;
        }
    }
}
void fenjie(LinkList H,LinkList L)
{
    LinkList q=H,p;
    q=q->next;
while(q->data%2==1)
    {
        Elemtype x;
        x=q->data;
        p=(LinkList)malloc(sizeof(Node));
        p->data=x;
        p->next=L->next;
        L->next=p;
        H->next=q->next;
        free(q);
        q=H->next;
    }
}
void freelist(LinkList H)//释放链表空间
{
    LinkList L=H;
    LinkList q;
while(L!=NULL)
    {
        q=L;
        L=L->next;
        free(q);
    }
}
void sort1(LinkList H)//交换值的排序
{
    LinkList L=H,p,q;
    p=L->next;
    int j=0;
while(p!=NULL)
    {
        p=p->next;
        j++;
    }
    for(int i=0;i<j;i++)
    {
        q=L->next;
        for(int k=i;k<j-1;k++)
        {
            p=q;
            q=p->next;
if(p->data > q->data)
            {
                int tmp;
                tmp=p->data;
                p->data=q->data;
                q->data=tmp;
            }
        }
    }
}
int main()
{
    LinkList S=Createlist();
    nizhi(S);
    int x=1;
while(x)
    {
        getchar();
        cout<<"按任意键继续......"<<endl;
        getchar();
        system("cls");
        cout<<"此时的数据为：";
        put(S);
        cout<<endl<<"请输入指令:"<<endl;
        cout<<"1,逆置:"<<endl;
        cout<<"2,删除偶数元素节点:"<<endl;
        cout<<"3,非递减有序链表中插入一元素使链表元素仍有序，并建立一个非递减有序单向链表:"<<endl;
        cout<<"4,分解成两个链表，其中一个全部为奇数，另一个全部为偶数,并结束程序:"<<endl;
        cin>>x;
if(x==1)
        {
            nizhi(S);
            put(S);
        }
else if(x==2)
        {
            deleteDE(S);
            put(S);
        }
else if(x==3)
        {
            sort1(S);
            put(S);
            cout<<"请输入插入的元素："<<endl;
            int a;
            cin>>a;
            insert(S,a);
            LinkList L=Createlist1(S);
            nizhi(L);
            put(L);
        }
else if(x==4)
        {
            sort4(S);
            LinkList L;
            L=(LinkList)malloc(sizeof(Node));
            L->next=NULL;
            fenjie(S,L);
            put(S);
            put(L);
            freelist(L);
            freelist(S);
            break;
        }
    }
}