合肥工业大学 数据结构与算法实验 顺序表、单链表和栈

顺序表

1.实验目标
熟练掌握线性表的顺序存储结构。
熟练掌握顺序表的有关算法设计。
根据具体问题的需要，设计出合理的表示数据的顺序结构，并设计相关算法。

2.实验内容和要求
实验要求
顺序表结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；
比如存储、算法实现放入文件：seqList.h
实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；
程序有适当的注释。

实验任务
编写算法实现下列问题的求解。
<1>求顺序表中第i个元素（函数），若不存在，报错。
实验测试数据基本要求：
第一组数据：顺序表长度n≥10，i分别为5，n，0，n+1，n+2
第二组数据：顺序表长度n=0，i分别为0，2
<2>在第i个结点前插入值为x的结点。
实验测试数据基本要求：
第一组数据：顺序表长度n≥10，x=100, i分别为5,n,n+1,0,1,n+2
第二组数据：顺序表长度n=0，x=100，i=5
<3>删除顺序表中第i个元素结点。
实验测试数据基本要求：
第一组数据：顺序表长度n≥10，i分别为5,n,1,n+1,0
第二组数据：顺序表长度n=0， i=5
<4>在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。
实验测试数据基本要求：
顺序表元素为 （10,20,30,40,50,60,70,80,90,100）,
x分别为25，85，110和8
<5>将顺序表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的顺序表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。
实验测试数据基本要求：
第一组数据：顺序表元素为 （1,2,3,4,5,6,7,8,9,10,20,30,40,50,60）
第二组数据：顺序表元素为 （10,20,30,40,50,60,70,80,90,100）
<6>求两个递增有序顺序表L1和L2中的公共元素，放入新的顺序表L3中。
实验测试数据基本要求：
第一组
第一个顺序表元素为 （1，3，6，10，15，16，17，18，19，20）
第二个顺序表元素为 （1，2，3，4，5，6，7，8，9，10，18，20，30）
第二组
第一个顺序表元素为 （1，3，6，10，15，16，17，18，19，20）
第二个顺序表元素为 （2，4，5，7，8，9，12，22）
第三组
第一个顺序表元素为 （）
第二个顺序表元素为 （1，2，3，4，5，6，7，8，9，10）
<7>删除递增有序顺序表中的重复元素，并统计移动元素次数，要求时间性能最好。
实验测试数据基本要求：
第一组数据：顺序表元素为 （1,2,3,4,5,6,7,8,9）
第二组数据：顺序表元素为 （1,1,2,2,2,3,4,5,5,5,6,6,7,7,8,8,9）
第三组数据：顺序表元素为 （1,2,3,4,5,5,6,7,8,8,9,9,9,9,9）

顺序表扩展实验
<1> 递增有序顺序表L1、L2，对2表进行合并，并使得合并后成为一个集合，集合的元素放回L1表中保存，要求时间性能最好。
<2>（递增有序）顺序表表示集合A、B，实现：
C=AB，C=AB，C=A-B
A=AB，A=AB，A=A-B
<3>（递增有序）顺序表表示集合A、B，判定A是否B的子集。
<4>(2011)（15 分）一个长度为L（L≥1）的升序序列S，处在第L/2个位置的数称为S 的中位数。例如，若序列S1=(11, 13, 15, 17, 19)，则S1 的中位数是15。两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2=(2, 4, 6, 8, 20)，则S1 和S2 的中位数是11。
现有两个等长升序序列A 和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A 和B 的中位数。要求：
（1）给出算法的基本设计思想。
（2）根据设计思想，采用C 或C++语言描述算法，关键之处给出注释。
（3）说明你所设计算法的时间复杂度和空间复杂度。

3.数据结构设计

#ifndef EXP1_H_INCLUDED
#define EXP1_H_INCLUDED

#include<stdio.h>
#include<stdlib.h>

struct Slist
{
    int listlen;
    int data[100];
};
typedef struct Slist slist;

slist createlist(void) //构建顺序表。
{
    slist newlist;
    int i,a;

    printf("输入顺序表的长度：\n");
    scanf("%d",&a);

    printf("依次输入顺序表元素：\n");
    for(i=0;i<a;i=i+1)
    {
        scanf("%d",&newlist.data[i]);
    }
    newlist.listlen = a;
    return (newlist);
}

int listgetelement(slist newlist,int k);
int listinsert(slist seqlist,int i,int x);
int listdelete(slist seqlist,int i);
void listorderinsert(slist seqlist,int x);
int listnewlist(slist seqlist);
void listnewx(slist newlist1,slist newlist2);
void listdeletex(slist newlist);
void listlinklisttofirst(slist list1,slist list2);
void listhelist(slist list1,slist list2);
void listbilist(slist list1,slist list2);
void listhexlist(slist list1,slist list2);
void listqlist(slist list1,slist list2);
void listbixlist(slist list1,slist list2);
void listqxlist(slist list1,slist list2);
int listzzlist(slist list1,slist list2);
void listzlistz(slist list1,slist list2);

void menu(void)
{
    int m;
    loop:
    printf("实验任务:\n");
    printf("<1>求顺序表中第i个元素（函数），若不存在，报错。\n");
    printf("<2>在第i个结点前插入值为x的结点。\n");
    printf("<3>删除顺序表中第i个元素结点。\n");
    printf("<4>在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。\n");
    printf("<5>将顺序表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的顺序表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。\n");
    printf("<6>求两个递增有序顺序表L1和L2中的公共元素，放入新的顺序表L3中。\n");
    printf("<7>删除递增有序顺序表中的重复元素，并统计移动元素次数，要求时间性能最好。\n");
    printf("\n");

    printf("顺序表扩展实验:\n");
    printf("<8> 递增有序顺序表L1、L2，对2表进行合并，并使得合并后成为一个集合，集合的元素放回L1表中保存，要求时间性能最好。\n");

    printf("<9>（递增有序）顺序表表示集合A、B，实现：C=A与B的交集\n");
    printf("<10>C=A与B的并集\n");
    printf("<11>C=A-B\n");
    printf("<12>A=A与B的交集\n");
    printf("<13>A=A与B的并集\n");
    printf("<14>A=A-B\n");

    printf("<15>（递增有序）顺序表表示集合A、B，判定A是否B的子集。\n");
    printf("<16>现有两个等长升序序列A 和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A 和B 的中位数。\n");

    printf("\n");
    printf("<17>清屏。\n");
    printf("<18>退出。\n");

    printf("\n");
    scanf("%d",&m);
    printf("\n");

    switch(m)
    {
        case 1:
            {
                slist l;
                int i;
                l = createlist();
                printf("输入元素的位置：\n");
                scanf("%d",&i);
                listgetelement(l,i);
                goto loop;
            }
        case 2:
            {
                slist l;
                int i,x;
                l = createlist();
                printf("输入结点的位置：\n");
                scanf("%d",&i);
                printf("输入值：\n");
                scanf("%d",&x);
                listinsert(l,i,x);
                goto loop;
            }
        case 3:
            {
                slist l;
                int i;
                l = createlist();
                printf("输入元素的位置：\n");
                scanf("%d",&i);
                listdelete(l,i);
                goto loop;
            }
        case 4:
            {
                slist l;
                int x;
                l = createlist();
                printf("输入值：\n");
                scanf("%d",&x);
                listorderinsert(l,x);
                goto loop;
            }
        case 5:
            {
                slist l;
                l = createlist();
                listnewlist(l);
                goto loop;
            }
        case 6:
            {
                slist l1,l2;
                l1 = createlist();
                l2 = createlist();
                listnewx(l1,l2);
                goto loop;
            }
        case 7:
            {
                slist l;
                l = createlist();
                listdeletex(l);
                goto loop;
            }
        case 8:
            {
                slist l1,l2;
                l1 = createlist();
                l2 = createlist();
                listlinklisttofirst(l1,l2);
                goto loop;
            }
        case 9:
            {
                slist l1,l2;
                l1 = createlist();
                l2 = createlist();
                listhelist(l1,l2);
                goto loop;
            }
        case 10:
            {
                slist l1,l2;
                l1 = createlist();
                l2 = createlist();
                listbilist(l1,l2);
                goto loop;
            }
        case 11:
            {
                slist l1,l2;
                l1 = createlist();
                l2 = createlist();
                listqlist(l1,l2);
                goto loop;
            }
        case 12:
            {
                slist l1,l2;
                l1 = createlist();
                l2 = createlist();
                listhexlist(l1,l2);
                goto loop;
            }
        case 13:
            {
                slist l1,l2;
                l1 = createlist();
                l2 = createlist();
                listbixlist(l1,l2);
                goto loop;
            }
        case 14:
            {
                slist l1,l2;
                l1 = createlist();
                l2 = createlist();
                listqxlist(l1,l2);
                goto loop;
            }
        case 15:
            {
                slist l1,l2;
                l1 = createlist();
                l2 = createlist();
                listzzlist(l1,l2);
                goto loop;
            }
        case 16:
            {
                slist l1,l2;
                l1 = createlist();
                l2 = createlist();
                listzlistz(l1,l2);
                goto loop;
            }
        case 18:
            {
                goto mmo;
            }
        case 17:
            {
                system("cls");
                goto loop;
            }
        default:
            {
                printf("输入错误。\n");
                goto loop;
            }
    }
    mmo: system("cls");
}

int listgetelement(slist newlist,int k) //实验任务 <1>求顺序表中第i个元素（函数），若不存在，报错。
{
    if(k<1 || k>newlist.listlen)
    {
        printf("第%d个元素不在顺序表中。\n",k);
        system("pause");
        return 0;
    }
    else
    {
        printf("第%d个元素为：\n",k);
        printf("%d\n",newlist.data[k-1]);
        system("pause");
        return 1;
    }
}

int listinsert(slist seqlist,int i,int x) //<2>在第i个结点前插入值为x的结点。
{
    int len;
    len = seqlist.listlen + 1;

    int datax[len];
    int j,k;

    if(i<1 || i>len)
    {
        printf("该结点不在顺序表中。\n");
        system("pause");
        return 0;
    }
    else
    {
        for(j=0,k=0;j<len;j=j+1)
        {
            if(j==i-1)
            {
                datax[j] = x;
            }
            else
            {
                datax[j] = seqlist.data[k];
                k = k+1;
            }
        }
    }
    printf("插入结点后的顺序表：\n");

    for(j=0;j<len;j=j+1)
    {
        seqlist.data[j] = datax[j];
        printf("%d\t",seqlist.data[j]);
    }
    seqlist.listlen = len;

    system("pause");
    return 1;
}

int listdelete(slist seqlist,int i) //<3>删除顺序表中第i个元素结点。
{
    int datax[seqlist.listlen];
    int j,k;

    if(i<1 || i>seqlist.listlen)
    {
        printf("该结点不在顺序表中。\n");
        system("pause");
        return 0;
    }
    else
    {
        for(j=0,k=0;j<seqlist.listlen;j=j+1)
        {
            if(j==i-1)
            {
                k = k;
            }
            else
            {
                datax[k] = seqlist.data[j];
                k = k+1;
            }
        }
    }
    printf("删除结点后的顺序表：\n");

    for(j=0;j<k;j=j+1)
    {
        seqlist.data[j] = datax[j];
        printf("%d\t",seqlist.data[j]);
    }
    seqlist.listlen = k;
    system("pause");
    return 1;
}

void listorderinsert(slist seqlist,int x) //<4>在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。
{
    int i,j,k;
    int datax[seqlist.listlen+1];

    for(i=0,j=0;i<seqlist.listlen;i=i+1)
    {
        if(x>seqlist.data[i])
        {
            j = j+1;
        }
        else
        {
            j = j;
        }
    }

    for(i=0,k=0;i<seqlist.listlen+1;i=i+1)
    {
        if(i==j)
        {
            datax[i] = x;
        }
        else
        {
            datax[i] = seqlist.data[k];
            k = k+1;
        }
    }
    printf("插入结点后的顺序表：\n");
    seqlist.listlen = seqlist.listlen+1;

    for(j=0;j<seqlist.listlen;j=j+1)
    {
        seqlist.data[j] = datax[j];
        printf("%d\t",seqlist.data[j]);
    }
    system("pause");
}

int listnewlist(slist seqlist) //<5>将顺序表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的顺序表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。
{
    int i,j,k;
    slist newlist[2];
    newlist[0].listlen = 0;
    newlist[1].listlen = 0;

    for(i=0,j=0,k=0;i<seqlist.listlen;i=i+1)
    {
        if(seqlist.data[i]%2!=0)
        {
            newlist[0].data[j] = seqlist.data[i];
            j = j+1;
            newlist[0].listlen = j;
        }
        else
        {
            newlist[1].data[k] = seqlist.data[i];
            k = k+1;
            newlist[1].listlen = k;
        }
    }

    printf("原来的顺序表：\n");
    for(i=0;i<seqlist.listlen;i=i+1)
    {
        printf("%d\t",seqlist.data[i]);
    }
    printf("\n");
    printf("原顺序表的奇数项：\n");

    for(j=0;j<newlist[0].listlen;j=j+1)
    {
        printf("%d\t",newlist[0].data[j]);
    }
    printf("\n");
    printf("原顺序表的偶数项：\n");

    for(k=0;k<newlist[1].listlen;k=k+1)
    {
        printf("%d\t",newlist[1].data[k]);
    }
    printf("\n");

    system("pause");
    return 1;
}

void listnewx(slist newlist1,slist newlist2) //<6>求两个递增有序顺序表L1和L2中的公共元素，放入新的顺序表L3中。
{
    int i,j,k;
    slist newlist3;

    for(i=0,k=0;i<newlist1.listlen;i=i+1)
    {
        for(j=0;j<newlist2.listlen;j=j+1)
        {
            if(newlist1.data[i]==newlist2.data[j])
            {
                newlist3.data[k] = newlist1.data[i];
                k = k+1;
                break;
            }
        }
    }
    newlist3.listlen = k+1;

    printf("新的顺序表为：\n");
    for(i=0;i<k;i=i+1)
    {
        printf("%d\t",newlist3.data[i]);
    }
    system("pause");
}

void listdeletex(slist newlist) //<7>删除递增有序顺序表中的重复元素，并统计移动元素次数，要求时间性能最好。
{
    int n=0,i;
    slist alist;

    alist.data[n] = newlist.data[0];

    for(i=0;i<newlist.listlen;i=i+1)
    {
        if(newlist.data[i]!=alist.data[n])
        {
            n = n+1;
            alist.data[n] = newlist.data[i];
        }
    }

    alist.listlen = n+1;
    newlist.listlen = alist.listlen;
    n = i;

    printf("新的顺序表为：\n");
    for(i=0;i<alist.listlen;i=i+1)
    {
        newlist.data[i] = alist.data[i];
        printf("%d\t",newlist.data[i]);
    }
    n = n+i;
    printf("\n移动元素次数：\n%d\n",n);
    system("pause");
}

void listlinklisttofirst(slist list1,slist list2) //顺序表扩展实验 <1>递增有序顺序表L1、L2，对2表进行合并，并使得合并后成为一个集合，集合的元素放回L1表中保存，要求时间性能最好。
{
    int i,j,k;
    slist list3;
    i = 0;
    j = 0;
    k = 0;

    while(i<list1.listlen && j<list2.listlen)
    {
        if(list1.data[i]==list2.data[j])
        {
            list3.data[k] = list1.data[i];
            i = i+1;
            k = k+1;
            list3.data[k] = list2.data[j];
            j = j+1;
            k = k+1;
        }
        else if(list1.data[i]>list2.data[j])
        {
            list3.data[k] = list2.data[j];
            k = k+1;
            j = j+1;
        }
        else
        {
            list3.data[k] = list1.data[i];
            k = k+1;
            i = i+1;
        }
    }

    if(i==list1.listlen && j<list2.listlen)
    {
        while(j<list2.listlen)
        {
            list3.data[k] = list2.data[j];
            k = k+1;
            j = j+1;
        }
    }
    else if(i<list1.listlen && j==list2.listlen)
    {
        while(i<list1.listlen)
        {
            list3.data[k] = list1.data[i];
            k = k+1;
            i = i+1;
        }
    }

    list3.listlen = k;
    list1.listlen = list3.listlen;
    printf("新的顺序表为：\n");
    for(i=0,k=0;i<list1.listlen;i=i+1)
    {
        list1.data[i] = list3.data[k];
        printf("%d\t",list1.data[i]);
        k = k+1;
    }
    printf("\n");
    system("pause");
}

void listhelist(slist list1,slist list2) //<2><1>（递增有序）顺序表表示集合A、B，实现：
{
   slist list3;
   int i,j,k;

   i = 0;
   j = 0;
   k = 0;

   while(i<list1.listlen && j<list2.listlen)
   {
       if(list1.data[i]==list2.data[j])
       {
           list3.data[k] = list1.data[i];
           k = k+1;
           i = i+1;
           j = j+1;
       }
       else if(list1.data[i]>list2.data[j])
       {
           j = j+1;
       }
       else
       {
           i = i+1;
       }
   }
   list3.listlen = k;

   printf("合成的顺序表为：\n");
   for(i=0;i<k;i=i+1)
   {
       printf("%d\t",list3.data[i]);
   }
   system("pause");
}

void listbilist(slist list1,slist list2) //<2><2>（递增有序）顺序表表示集合A、B，实现：
{
    slist list3;
    int i,j,k;

    i =0;
    j =0;
    k =0;

    while(i<list1.listlen && j<list2.listlen)
    {
        if(list1.data[i]==list2.data[j])
        {
            list3.data[k] = list1.data[i];
            i = i+1;
            j = j+1;
            k = k+1;
        }
        else if(list1.data[i]>list2.data[j])
        {
            list3.data[k] = list2.data[j];
            j = j+1;
            k = k+1;
        }
        else
        {
            list3.data[k] = list1.data[i];
            i = i+1;
            k = k+1;
        }
    }

    if(i==list1.listlen)
    {
        while(j<list2.listlen)
        {
            list3.data[k] = list2.data[j];
            k = k+1;
            j = j+1;
        }
    }
    else if(j==list2.listlen)
    {
        while(i<list1.listlen)
        {
            list3.data[k] = list1.data[i];
            k = k+1;
            i = i+1;
        }
    }
    list3.listlen = k;

    printf("合成的顺序表为：\n");
    for(i=0;i<k;i=i+1)
    {
        printf("%d\t",list3.data[i]);
    }
    system("pause");
}

void listqlist(slist list1,slist list2) //<2><3>（递增有序）顺序表表示集合A、B，实现：
{
    slist list3;
    int i,j,k;

    i =0;
    j =0;
    k =0;

    while(i<list1.listlen)
    {
        if(list1.data[i]<list2.data[j])
        {
            list3.data[k] = list1.data[i];
            i = i+1;
            k = k+1;
        }
        else if(list1.data[i]==list2.data[j])
        {
            i = i+1;
            j = j+1;
        }
        else
        {
            j = j+1;
        }
    }
    list3.listlen = k;

    printf("合成的顺序表为：\n");
    for(i=0;i<k;i=i+1)
    {
        printf("%d\t",list3.data[i]);
    }
    system("pause");
}

void listhexlist(slist list1,slist list2) //<2><4>（递增有序）顺序表表示集合A、B，实现：
{
   slist list3;
   int i,j,k;

   i = 0;
   j = 0;
   k = 0;

   while(i<list1.listlen && j<list2.listlen)
   {
       if(list1.data[i]==list2.data[j])
       {
           list3.data[k] = list1.data[i];
           k = k+1;
           i = i+1;
           j = j+1;
       }
       else if(list1.data[i]>list2.data[j])
       {
           j = j+1;
       }
       else
       {
           i = i+1;
       }
   }
   list3.listlen = k;
   list1.listlen = list3.listlen;

   printf("合成的顺序表为：\n");
   for(i=0;i<k;i=i+1)
   {
       list1.data[i] = list3.data[i];
       printf("%d\t",list1.data[i]);
   }
   system("pause");
}

void listbixlist(slist list1,slist list2) //<2><5>（递增有序）顺序表表示集合A、B，实现：
{
    slist list3;
    int i,j,k;

    i =0;
    j =0;
    k =0;

    while(i<list1.listlen && j<list2.listlen)
    {
        if(list1.data[i]==list2.data[j])
        {
            list3.data[k] = list1.data[i];
            i = i+1;
            j = j+1;
            k = k+1;
        }
        else if(list1.data[i]>list2.data[j])
        {
            list3.data[k] = list2.data[j];
            j = j+1;
            k = k+1;
        }
        else
        {
            list3.data[k] = list1.data[i];
            i = i+1;
            k = k+1;
        }
    }

    if(i==list1.listlen)
    {
        while(j<list2.listlen)
        {
            list3.data[k] = list2.data[j];
            k = k+1;
            j = j+1;
        }
    }
    else if(j==list2.listlen)
    {
        while(i<list1.listlen)
        {
            list3.data[k] = list1.data[i];
            k = k+1;
            i = i+1;
        }
    }
    list3.listlen = k;
    list1.listlen = list3.listlen;

    printf("合成的顺序表为：\n");
    for(i=0;i<k;i=i+1)
    {
        list1.data[i] = list3.data[i];
        printf("%d\t",list1.data[i]);
    }
    system("pause");
}

void listqxlist(slist list1,slist list2) //<2><6>（递增有序）顺序表表示集合A、B，实现：
{
    slist list3;
    int i,j,k;

    i =0;
    j =0;
    k =0;

    while(i<list1.listlen && j<list2.listlen)
    {
        if(list1.data[i]<list2.data[j])
        {
            list3.data[k] = list1.data[i];
            i = i+1;
            k = k+1;
        }
        else if(list1.data[i]==list2.data[j])
        {
            i = i+1;
            j = j+1;
        }
        else
        {
            j = j+1;
        }
    }

    if(i<list1.listlen && j==list2.listlen)
    {
        while(i<list1.listlen)
        {
            list3.data[k] = list1.data[i];
            i = i+1;
            k = k+1;
        }
    }
    list3.listlen = k;
    list1.listlen = list3.listlen;

    printf("合成的顺序表为：\n");
    for(i=0;i<k;i=i+1)
    {
        list1.data[i] = list3.data[i];
        printf("%d\t",list1.data[i]);
    }
    system("pause");
}

int listzzlist(slist list1,slist list2) //<3>（递增有序）顺序表表示集合A、B，判定A是否B的子集。
{
    int i,j;
    i = 0;
    j = 0;

    while(i<list1.listlen)
    {
        if(list1.data[i]>list2.data[j])
        {
            j = j+1;
        }
        else if(list1.data[i]==list2.data[j])
        {
            i = i+1;
            j = j+1;
        }
        else
        {
            printf("A不是B的子集。\n");
            system("pause");
            return 0;
        }
    }

    printf("A是B的子集。\n");
    system("pause");
    return 1;
}

void listzlistz(slist list1,slist list2) //<4>现有两个等长升序序列A 和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A 和B 的中位数。
{
    slist list3;

    int i,j,k;
    i = 0;
    j = 0;
    k = 0;

    while(i<list1.listlen && j<list2.listlen)
    {
        if(list1.data[i]==list2.data[j])
        {
            list3.data[k] = list1.data[i];
            i = i+1;
            k = k+1;
            list3.data[k] = list2.data[j];
            j = j+1;
            k = k+1;
        }
        else if(list1.data[i]>list2.data[j])
        {
            list3.data[k] = list2.data[j];
            k = k+1;
            j = j+1;
        }
        else
        {
            list3.data[k] = list1.data[i];
            k = k+1;
            i = i+1;
        }
    }

    if(i==list1.listlen && j<list2.listlen)
    {
        while(j<list2.listlen)
        {
            list3.data[k] = list2.data[j];
            k = k+1;
            j = j+1;
        }
    }
    else if(i<list1.listlen && j==list2.listlen)
    {
        while(i<list1.listlen)
        {
            list3.data[k] = list1.data[i];
            k = k+1;
            i = i+1;
        }
    }

    printf("中位数为：\n");
    list3.listlen = k;

    k = k/2-1;
    i = 0;
    while(i!=k)
    {
        i = i+1;
    }
    printf("%d\n",list3.data[i]);
    system("pause");
}
#endif

#include"seqList.h"

int main(void)
{
    menu();
}

单链表

1.实验目标
熟练掌握线性表的链式存储结构。
熟练掌握单链表的有关算法设计。
根据具体问题的需要，设计出合理的表示数据的链式存储结构，并设计相关算法。

2.实验内容和要求
本次实验中的链表结构指带头结点的单链表；
单链表结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；
比如存储、算法实现放入文件：linkedList.h
实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；
程序有适当的注释。

实验任务
编写算法实现下列问题的求解。
<1>尾插法创建单链表，打印创建结果。
<2>头插法创建单链表，打印创建结果。
<3>销毁单链表。
<4>求链表长度。
<5>求单链表中第i个元素（函数），若不存在，报错。
实验测试数据基本要求：
第一组数据：单链表长度n≥10，i分别为5，n，0，n+1，n+2
第二组数据：单链表长度n=0，i分别为0，2
<6>在第i个结点前插入值为x的结点。
实验测试数据基本要求：
第一组数据：单链表长度n≥10，x=100, i分别为5,n,n+1,0,1,n+2
第二组数据：单链表长度n=0，x=100，i=5
<7>链表中查找元素值为x的结点，成功返回结点指针，失败报错。
实验测试数据基本要求：
单链表元素为 （1，3，6，10，15，16，17，18，19，20）
x=1，17，20，88
<8>删除单链表中第i个元素结点。
实验测试数据基本要求：
第一组数据：单链表长度n≥10，i分别为5,n,1,n+1,0
第二组数据：单链表长度n=0， i=5
<9>在一个递增有序的单链表L中插入一个值为x的元素，并保持其递增有序特性。
实验测试数据基本要求：
单链表元素为 （10,20,30,40,50,60,70,80,90,100）,
x分别为25，85，110和8
<10>将单链表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的单链表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。
实验测试数据基本要求：
第一组数据：单链表元素为 （1,2,3,4,5,6,7,8,9,10,20,30,40,50,60）
第二组数据：单链表元素为 （10,20,30,40,50,60,70,80,90,100）
<11>求两个递增有序单链表L1和L2中的公共元素，放入新的单链表L3中。
实验测试数据基本要求：
第一组
第一个单链表元素为 （1，3，6，10，15，16，17，18，19，20）
第二个单链表元素为 （1，2，3，4，5，6，7，8，9，10，18，20，30）
第二组
第一个单链表元素为 （1，3，6，10，15，16，17，18，19，20）
第二个单链表元素为 （2，4，5，7，8，9，12，22）
第三组
第一个单链表元素为 （）
第二个单链表元素为 （1，2，3，4，5，6，7，8，9，10）
<12>删除递增有序单链表中的重复元素，要求时间性能最好。
实验测试数据基本要求：
第一组数据：单链表元素为 （1,2,3,4,5,6,7,8,9）
第二组数据：单链表元素为 （1,1,2,2,2,3,4,5,5,5,6,6,7,7,8,8,9）
第三组数据：单链表元素为 （1,2,3,4,5,5,6,7,8,8,9,9,9,9,9）
<13>递增有序单链表L1、L2，不申请新结点，利用原表结点对2表进行合并，并使得合并后成为一个集合，合并后用L1的头结点作为头结点，删除L2的头结点，要求时间性能最好。
实验测试数据基本要求：
第一组
第一个单链表元素为 （1，3，6，10，15，16，17，18，19，20）
第二个单链表元素为 （1，2，3，4，5，6，7，8，9，10，18，20，30）
第二组
第一个单链表元素为 （1，3，6，10，15，16，17，18，19，20）
第二个单链表元素为 （2，4，5，7，8，9，12，22）
第三组
第一个单链表元素为 （）
第二个单链表元素为 （1，2，3，4，5，6，7，8，9，10）

单链表扩展实验
<1>（递增有序）单链表表示集合A、B，实现：
C=AB，C=AB，C=A-B
A=AB，A=AB，A=A-B
<2>（递增有序）单链表表示集合A、B，判定A是否B的子集。
<3>(2009)（15分）已知一个带有表头结点的单链表，结点结构如下图。假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点（k为正整数）。若查找成功，算法输出该结点的data值，并返回1；否则，只返回0。要求：
（1）描述算法的基本设计思想
（2）描述算法的详细实现步骤
（3）根据设计思想和实现步骤，采用程序设计语言描述算法（使用C 或C++语言实现），关键之处请给出简要注释。
<4>(2011)（15 分）一个长度为L（L≥1）的升序序列S，处在第L/2个位置的数称为S 的中位数。例如，若序列S1=(11, 13, 15, 17, 19)，则S1 的中位数是15。两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2=(2, 4, 6, 8, 20)，则S1 和S2 的中位数是11。现有两个等长升序序列A 和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A 和B 的中位数。要求：
（1）给出算法的基本设计思想。
（2）根据设计思想，采用C 或C++语言描述算法，关键之处给出注释。
（3）说明你所设计算法的时间复杂度和空间复杂度。

3.数据结构设计

#ifndef LINKEDLIST_H_INCLUDED
#define LINKEDLIST_H_INCLUDED
#include<stdio.h>
#include<stdlib.h>

struct slnode
{
    int data;
    struct slnode *next;
};
typedef struct slnode node;

node * createlist(void);
node * createlisth(void);
void destroylist(node *l);
int listlength(node *l);
void getelement(node *l,int i);
int listinsert(node *l,int i,int x);
node * listlocate(node *l,int x);
int listdelete(node *l,int i);
void listinsertx(node *l,int x);
void listnewdlist(node *l);
void listnewlist(node *l1,node *l2);
void listdeletedx(node *l);
void listlinklist(node *la,node *lb);

int listhelist(node *la,node *lb);
void listbilist(node *la,node *lb);
void listqlist(node *la,node *lb);
void listhexlist(node *la,node *lb);
void listbixlist(node *la,node *lb);
void listqxlist(node *la,node *lb);
int listzzlist(node *la,node *lb);
int listkx(node *l,int k);
void listzlistz(node *la,node *lb);

void menu(void)
{
    int m;
    loopx:
    printf("实验任务：\n");

    printf("<1>尾插法创建单链表，打印创建结果。\n");
    printf("<2>头插法创建单链表，打印创建结果。\n");
    printf("<3>销毁单链表。\n");
    printf("<4>求链表长度。\n");
    printf("<5>求单链表中第i个元素（函数），若不存在，报错。\n");
    printf("<6>在第i个结点前插入值为x的结点。\n");
    printf("<7>链表中查找元素值为x的结点，成功返回结点指针，失败报错。\n");
    printf("<8>删除单链表中第i个元素结点。\n");
    printf("<9>在一个递增有序的单链表L中插入一个值为x的元素，并保持其递增有序特性。\n");
    printf("<10>将单链表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的单链表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。\n");
    printf("<11>求两个递增有序单链表L1和L2中的公共元素，放入新的单链表L3中。\n");
    printf("<12>删除递增有序单链表中的重复元素，要求时间性能最好。\n");
    printf("<13>递增有序单链表L1、L2，不申请新结点，利用原表结点对2表进行合并，并使得合并后成为一个集合，合并后用L1的头结点作为头结点，删除L2的头结点，要求时间性能最好。\n");
    printf("\n");

    printf("单链表扩展实验:\n");

    printf("<14>（递增有序）顺序表表示集合A、B，实现：C=A与B的交集\n");
    printf("<15>C=A与B的并集\n");
    printf("<16>C=A-B\n");
    printf("<17>A=A与B的交集\n");
    printf("<18>A=A与B的并集\n");
    printf("<19>A=A-B\n");
    printf("<20>（递增有序）单链表表示集合A、B，判定A是否B的子集。\n");
    printf("<21>已知一个带有表头结点的单链表，结点结构如下图。假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点（k为正整数）。若查找成功，算法输出该结点的data值，并返回1；否则，只返回0。\n");
    printf("<22>现有两个等长升序序列A 和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A 和B 的中位数。\n");
    printf("\n");

    printf("<23>清屏。\n");
    printf("<24>退出。\n");
    printf("\n");

    scanf("%d",&m);
    printf("\n");

    switch(m)
    {
        case 1:
            {
                node *l;
                l = createlist();
                destroylist(l);
                goto loopx;
            }
        case 2:
            {
                node *l;
                l = createlisth();
                destroylist(l);
                goto loopx;
            }
        case 3:
            {
                node *l;
                l = createlist();
                destroylist(l);
                goto loopx;
            }
        case 4:
            {
                node *l;
                l = createlist();
                listlength(l);
                destroylist(l);
                goto loopx;
            }
        case 5:
            {
                node *l;
                l = createlist();
                int i;
                printf("输入单链表中元素的位置：\n");
                scanf("%d",&i);
                getelement(l,i);
                destroylist(l);
                goto loopx;
            }
        case 6:
            {
                node *l;
                l = createlist();
                int i,x;
                printf("输入结点的值和位置：\n");
                scanf("%d %d",&x,&i);
                listinsert(l,i,x);
                destroylist(l);
                goto loopx;
            }
        case 7:
            {
                node *l;
                l = createlist();
                int x;
                printf("输入结点的值：\n");
                scanf("%d",&x);
                listlocate(l,x);
                destroylist(l);
                goto loopx;
            }
        case 8:
            {
                node *l;
                l = createlist();
                int i;
                printf("输入单链表中元素的位置：\n");
                scanf("%d",&i);
                listdelete(l,i);
                destroylist(l);
                goto loopx;
            }
        case 9:
            {
                node *l;
                l = createlist();
                int x;
                printf("输入结点的值：\n");
                scanf("%d",&x);
                listinsertx(l,x);
                destroylist(l);
                goto loopx;
            }
        case 10:
            {
                node *l;
                l = createlist();
                listnewdlist(l);
                destroylist(l);
                goto loopx;
            }
        case 11:
            {
                node *l1;
                l1 = createlist();
                node *l2;
                l2 = createlist();
                listnewlist(l1,l2);
                destroylist(l1);
                destroylist(l2);
                goto loopx;
            }
        case 12:
            {
                node *l;
                l = createlist();
                listdeletedx(l);
                destroylist(l);
                goto loopx;
            }
        case 13:
            {
                node *la,*lb;
                la = createlist();
                lb = createlist();
                listlinklist(la,lb);
                destroylist(la);
                goto loopx;
            }
        case 14:
            {
                node *la,*lb;
                la = createlist();
                lb = createlist();
                listhelist(la,lb);
                destroylist(la);
                destroylist(lb);
                goto loopx;
            }
        case 15:
            {
                node *la,*lb;
                la = createlist();
                lb = createlist();
                listbilist(la,lb);
                destroylist(la);
                destroylist(lb);
                goto loopx;
            }
        case 16:
            {
                node *la,*lb;
                la = createlist();
                lb = createlist();
                listqlist(la,lb);
                destroylist(la);
                destroylist(lb);
                goto loopx;
            }
        case 17:
            {
                node *la,*lb;
                la = createlist();
                lb = createlist();
                listhexlist(la,lb);
                destroylist(la);
                destroylist(lb);
                goto loopx;
            }
        case 18:
            {
                node *la,*lb;
                la = createlist();
                lb = createlist();
                listbixlist(la,lb);
                destroylist(la);
                destroylist(lb);
                goto loopx;
            }
        case 19:
            {
                node *la,*lb;
                la = createlist();
                lb = createlist();
                listqxlist(la,lb);
                destroylist(la);
                destroylist(lb);
                goto loopx;
            }
        case 20:
            {
                node *la,*lb;
                la = createlist();
                lb = createlist();
                listzzlist(la,lb);
                destroylist(la);
                destroylist(lb);
                goto loopx;
            }
        case 21:
            {
                node *l;
                l = createlist();
                int k;
                printf("输入想要查找的结点的倒数位置：\n");
                scanf("%d",&k);
                listkx(l,k);
                destroylist(l);
                goto loopx;
            }
        case 22:
            {
                node *la,*lb;
                la = createlist();
                lb = createlist();
                listzlistz(la,lb);
                destroylist(la);
                destroylist(lb);
                goto loopx;
            }
        case 23:
            {
                system("cls");
                goto loopx;
            }
        case 24:
            {
                goto mmo;
            }
        default:
            {
                printf("输入错误。\n");
                goto loopx;
            }
    }
    mmo:system("cls");
}
node * createlist(void) //实验任务 <1>尾插法创建单链表，打印创建结果。
{
    node *l;
    int x;
    node *u,*r;
    l = (node *)malloc(sizeof(node));
    l->next = NULL;

    r = l;
    printf("依次输入结点的值：（输入9999停止）\n");
    scanf("%d",&x);
    while(x!=9999)
    {
        u = (node *)malloc(sizeof(node));
        u->data = x;
        u->next = NULL;
        r->next = u;
        r = u;
        scanf("%d",&x);
    }

    if(l->next==NULL)
    {
        return l;
    }

    r = l->next;
    printf("创建的链表为：\n");
    while(r!=NULL)
    {
        printf("%d\t",r->data);
        r = r->next;
    }
    printf("\n");
    system("pause");
    return l;
}

node * createlisth(void) //<2>头插法创建单链表，打印创建结果。
{
    node *l;
    node *u,*r;
    int x;
    l = (node *)malloc(sizeof(node));

    l->next = NULL;
    printf("依次输入结点的值：（输入9999停止）\n");
    scanf("%d",&x);
    while(x!=9999)
    {
        u = (node *)malloc(sizeof(node));
        u->data = x;
        u->next = l;
        l = u;
        scanf("%d",&x);
    }

    r = l;
    printf("创建的链表为：\n");
    while(r->next!=NULL)
    {
        printf("%d\t",r->data);
        r = r->next;
    }
    printf("\n");
    system("pause");
    return l;
}

void destroylist(node *l) //<3>销毁单链表。
{
    node *q;

    while(l!=NULL)
    {
        q = l->next;
        free(l);
        l = q;
    }
}

int listlength(node *l) //<4>求链表长度。
{
    int len=0;
    node *p;
    p = l->next;

    while(p!=NULL)
    {
        len = len+1;
        p = p->next;
    }
    printf("链表的长度为:%d\n",len);
    system("pause");
    return len;
}

void getelement(node *l,int i) //<5>求单链表中第i个元素（函数），若不存在，报错。
{
    node *p;
    int j = 1;
    p = l->next;

    while(j!=i && p!=NULL)
    {
        j = j+1;
        p = p->next;
    }

    if(p==NULL)
    {
        printf("这个元素不在单链表中。\n");
        system("pause");
    }
    else
    {
        printf("第%d个元素为：\n%d\n",i,p->data);
        system("pause");
    }
}

int listinsert(node *l,int i,int x) //<6>在第i个结点前插入值为x的结点。
{
    node *p,*s,*k;
    int j = 1;
    p = l->next;
    k = l->next;
    s = (node *)malloc(sizeof(node));

    while(j!=i && p!=NULL)
    {
        if(p!=k)
        {
            p = p->next;
            j = j+1;
            k = k->next;
        }
        else
        {
            p = p->next;
        }
    }

    if(p==NULL)
    {
        if(i==j+1)
        {
            s->data = x;
            s->next = p;
            k->next = s;
            l = l->next;
        }
        else
        {
            printf("输入错误。\n");
            system("pause");
            return 1;
        }
    }
    else if(j==1)
    {
        s->data = x;
        s->next = p;
        l = s;
    }
    else
    {
        s->data = x;
        s->next = p;
        k->next = s;
        l = l->next;
    }

    printf("插入结点后的链表为:\n");
    p = l;
    while(p!=NULL)
    {
        printf("%d\t",p->data);
        p = p->next;
    }
    printf("\n");
    system("pause");
    return 1;
}

node * listlocate(node *l,int x) //<7>链表中查找元素值为x的结点，成功返回结点指针，失败报错。
{
    node *s;
    s = l;

    while(s!=NULL)
    {
        if(s->data==x)
        {
            printf("查找到相应结点。\n");
            system("pause");
            return s;
        }
        else
        {
            s = s->next;
        }
    }

    printf("未找到值为%d的结点。\n",x);
    system("pause");
    return s;
}

int listdelete(node *l,int i) //<8>删除单链表中第i个元素结点。
{
    node *p,*u;
    int j=0;
    p = l;

    while(j!=i && p!=NULL)
    {
        p = p->next;
        j = j+1;
    }

    if(p==NULL || j==0)
    {
        printf("输入错误。\n");
        system("pause");
        return 0;
    }
    else if(p->next==NULL && p!=NULL)
    {
        u = p;
        free(u);
    }
    else
    {
        u = p->next;
        p->next = u->next;
        free(u);
    }

    p = l->next;
    printf("删除结点后的单链表为:\n");
    while(p!=NULL)
    {
        printf("%d\t",p->data);
        p = p->next;
    }
    printf("\n");
    system("pause");
    return 1;
}

void listinsertx(node *l,int x) //<9>在一个递增有序的单链表L中插入一个值为x的元素，并保持其递增有序特性。
{
    node *p,*s,*u;
    p = l;
    s = l->next;
    u = (node *)malloc(sizeof(node));
    u->data = x;

    while(p->next!=NULL)
    {
        if(s->data>x)
        {
            break;
        }
        p = p->next;
        s = s->next;
    }

    u->next = p->next;
    p->next = u;

    s = l->next;
    printf("新的单链表为:\n");
    while(s!=NULL)
    {
        printf("%d\t",s->data);
        s = s->next;
    }
    printf("\n");
    system("pause");
}

void listnewdlist(node *l) //<10>将单链表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的单链表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。
{
    node *p,*la,*lb;
    node *s,*u,*k;
    p = l->next;

    la = (node *)malloc(sizeof(node));
    lb = (node *)malloc(sizeof(node));
    la->next = NULL;
    lb->next = NULL;

    while(p!=NULL)
    {
        if(p->data%2!=0)
        {
            break;
        }
        p = p->next;
    }

    if(p!=NULL)
    {
        s = (node *)malloc(sizeof(node));
        s->data = p->data;
        s->next = NULL;
        u = s;
        la->next = s;
        while(p!=NULL)
        {
            if(p->data%2!=0 && p->data!=la->next->data)
            {
                s = (node *)malloc(sizeof(node));
                s->data = p->data;
                s->next = NULL;
                u->next = s;
                u = s;
            }
            p = p->next;
        }
    }
    p = l->next;

    while(p!=NULL)
    {
        if(p->data%2==0)
        {
            break;
        }
        p = p->next;
    }

    if(p!=NULL)
    {
        k = (node *)malloc(sizeof(node));
        k->data = p->data;
        k->next = NULL;
        u = k;
        lb->next = k;
        while(p!=NULL)
        {
            if(p->data%2==0 && p->data!=lb->next->data)
            {
                k = (node *)malloc(sizeof(node));
                k->data = p->data;
                k->next = NULL;
                u->next = k;
                u = k;
            }
            p = p->next;
        }
    }
    p = l->next;

    printf("原来的单链表：\n");
    while(p!=NULL)
    {
        printf("%d\t",p->data);
        p = p->next;
    }
    printf("\n");

    p = la->next;

    printf("单链表的奇数项:\n");
    while(p!=NULL)
    {
        printf("%d\t",p->data);
        p = p->next;
    }
    printf("\n");
    destroylist(la);

    p = lb->next;

    printf("单链表的偶数项：\n");
    while(p!=NULL)
    {
        printf("%d\t",p->data);
        p = p->next;
    }
    printf("\n");
    destroylist(lb);
    system("pause");
}

void listnewlist(node *l1,node *l2) //<11>求两个递增有序单链表L1和L2中的公共元素，放入新的单链表L3中。
{
    node *l3,*p,*q,*s,*r;
    p = l1->next;
    q = l2->next;

    l3 = (node *)malloc(sizeof(node));
    l3->next = NULL;

    while(p!=NULL && q!=NULL)
    {
        if(p->data==q->data)
        {
            r = (node *)malloc(sizeof(node));
            r->data = p->data;
            r->next = NULL;
            s = r;
            l3->next = r;
            break;
        }
        else if(p->data>q->data)
        {
            q = q->next;
        }
        else
        {
            p = p->next;
        }
    }

    if(p==NULL || q==NULL)
    {
        printf("无相同的元素。\n");
        free(l3);
        system("pause");
        return;
    }

    p = p->next;
    q = q->next;

    while(p!=NULL && q!=NULL)
    {
        if(p->data==q->data)
        {
            r = (node *)malloc(sizeof(node));
            r->data = p->data;
            r->next = NULL;
            s->next = r;
            s = r;

            p = p->next;
            q = q->next;
        }
        else if(p->data>q->data)
        {
            q = q->next;
        }
        else
        {
            p = p->next;
        }
    }

    printf("新的单链表为：\n");
    s = l3->next;
    while(s!=NULL)
    {
        printf("%d\t",s->data);
        s = s->next;
    }
    printf("\n");
    destroylist(l3);
    system("pause");
}

void listdeletedx(node *l) //<12>删除递增有序单链表中的重复元素，要求时间性能最好。
{
    node *s,*p,*u;
    s = l;
    p = l->next;

    while(p!=NULL)
    {
        if(s->data==p->data)
        {
            u = p;
            p = p->next;
            s->next = p;
            free(u);
        }
        else
        {
            s = p;
            p = p->next;
        }
    }

    printf("新的单链表为：\n");
    s = l->next;
    while(s!=NULL)
    {
        printf("%d\t",s->data);
        s = s->next;
    }
    printf("\n");
    system("pause");
}

void listlinklist(node *la,node *lb) //<13>递增有序单链表L1、L2，不申请新结点，利用原表结点对2表进行合并，并使得合并后成为一个集合，合并后用L1的头结点作为头结点，删除L2的头结点，要求时间性能最好。
{
    node *p,*q,*s,*k;
    p = la->next;
    q = lb->next;
    free(lb);

    if(p!=NULL && q!=NULL && p->data>q->data)
    {
        s = p->next;
        k = q->next;
        la->next = q;
        while(p->data>=k->data && k!=NULL)
        {
            if(p->data<=k->data)
            {
                q->next = p;
                q = k;
                k = k->next;
            }
            else
            {
                q = q->next;
                k = k->next;
            }
        }
        if(k==NULL)
        {
            q->next = p;
        }
    }
    else if(p!=NULL && q!=NULL && p->data<=q->data)
    {
        s = p->next;
        k = q->next;
        la->next = p;
    }

    if(p==NULL && q!=NULL)
    {
        la->next = q;
        s = NULL;
        k = q->next;
    }
    else if(p!=NULL && q==NULL)
    {
        la->next = p;
        s = p->next;
        k = NULL;
    }

    while(s!=NULL && k!=NULL)
    {
        if(p->data>q->data)
        {
            if(p->data<=k->data)
            {
                q->next = p;
                q = k;
                k = k->next;
            }
            else
            {
                q = q->next;
                k = k->next;
            }
        }
        else if(p->data<q->data)
        {
            if(q->data<s->data)
            {
                p->next = q;
                p = s;
                s = s->next;
            }
            else
            {
                p = p->next;
                s = s->next;
            }
        }
        else
        {
            p->next = q;
            p = s;
            s = s->next;
            if(p->data<=k->data)
            {
                q->next = p;
            }
            else
            {
                q->next = k;
            }
            q = k;
            k = k->next;
        }
    }

    if(s==NULL && k!=NULL && p!=NULL && q!=NULL)
    {
        p->next = q;
    }
    else if(s!=NULL && k==NULL && p!=NULL && q!=NULL )
    {
        q->next = p;
    }

    printf("新的单链表为：\n");
    p = la->next;
    while(p!=NULL)
    {
        printf("%d\t",p->data);
        p = p->next;
    }
    printf("\n");
    system("pause");
}

int listhelist(node *la,node *lb) //单链表扩展实验 <1><1>（递增有序）单链表表示集合A、B，实现：
{
    node *lc,*p,*s,*k,*q;
    p = la->next;
    s = lb->next;
    lc = (node *)malloc(sizeof(node));

    while(p!=NULL && s!=NULL && p->data!=s->data)
    {
        if(p->data>s->data)
        {
            s = s->next;
        }
        else
        {
            p = p->next;
        }
    }

    if(p==NULL || s==NULL)
    {
        printf("A与B无交集。\n");
        free(lc);
        system("pause");
        return 0;
    }
    else
    {
        k = (node *)malloc(sizeof(node));
        k->data = p->data;
        k->next = NULL;
        q = k;
        lc->next = k;

        p = p->next;
        s = s->next;
    }

    while(p!=NULL && s!=NULL)
    {
        if(p->data==s->data)
        {
            k = (node *)malloc(sizeof(node));
            k->data = p->data;
            k->next = NULL;
            q->next = k;
            q = k;

            p = p->next;
            s = s->next;
        }
        else if(p->data>s->data)
        {
            s = s->next;
        }
        else
        {
            p = p->next;
        }
    }

    printf("新生成的单链表为：\n");
    q = lc->next;
    while(q!=NULL)
    {
        printf("%d\t",q->data);
        q = q->next;
    }
    printf("\n");
    destroylist(lc);
    system("pause");
    return 1;
}

void listbilist(node *la,node *lb) //<1><2>（递增有序）单链表表示集合A、B，实现：
{
    node *p,*q,*lc,*s,*k;
    p = la->next;
    q = lb->next;

    lc = (node *)malloc(sizeof(node));
    k = (node *)malloc(sizeof(node));

    lc->next = k;
    k->next = NULL;
    s = k;
    if(p->data>q->data)
    {
        k->data = q->data;
        q = q->next;
    }
    else
    {
        k->data = p->data;
        p = p->next;
    }

    while(p!=NULL && q!=NULL)
    {
        if(p->data==q->data)
        {
            k = (node *)malloc(sizeof(node));
            k->data = p->data;
            k->next = NULL;
            s->next = k;
            s = k;

            k = (node *)malloc(sizeof(node));
            k->data = p->data;
            k->next = NULL;
            s->next = k;
            s = k;

            p = p->next;
            q = q->next;
        }
        else if(p->data>q->data)
        {
            k = (node *)malloc(sizeof(node));
            k->data = q->data;
            k->next = NULL;
            s->next = k;
            s = k;

            q = q->next;
        }
        else
        {
            k = (node *)malloc(sizeof(node));
            k->data = p->data;
            k->next = NULL;
            s->next = k;
            s = k;

            p = p->next;
        }
    }

    if(p==NULL && q!=NULL)
    {
        while(q!=NULL)
        {
            k = (node *)malloc(sizeof(node));
            k->data = q->data;
            k->next = NULL;
            s->next = k;
            s = k;

            q = q->next;
        }
    }
    else if(p!=NULL && q==NULL)
    {
        while(p!=NULL)
        {
            k = (node *)malloc(sizeof(node));
            k->data = p->data;
            k->next = NULL;
            s->next = k;
            s = k;

            p = p->next;
        }
    }

    printf("新生成的单链表为：\n");
    s = lc->next;
    while(s!=NULL)
    {
        printf("%d\t",s->data);
        s = s->next;
    }
    printf("\n");
    destroylist(lc);
    system("pause");
}

void listqlist(node *la,node *lb) //<1><3>（递增有序）单链表表示集合A、B，实现：
{
    node *lc,*q,*p,*s,*k;
    p = la->next;
    q = lb->next;

    lc = (node *)malloc(sizeof(node));
    k = (node *)malloc(sizeof(node));
    lc->next = k;
    k->next = NULL;
    s = k;

    while(p!=NULL && q!=NULL && p->data==q->data)
    {
        p = p->next;
    }
    k->data = p->data;
    p = p->next;

    while(p!=NULL && q!=NULL)
    {
        if(p->data==q->data)
        {
            p = p->next;
            q = q->next;
        }
        else if(p->data>q->data)
        {
            q = q->next;
        }
        else
        {
            k = (node *)malloc(sizeof(node));
            k->data = p->data;
            k->next = NULL;
            s->next = k;
            s = k;

            p = p->next;
        }
    }

    if(p!=NULL && q==NULL)
    {
        while(p!=NULL)
        {
            k = (node *)malloc(sizeof(node));
            k->data = p->data;
            k->next = NULL;
            s->next = k;
            s = k;

            p = p->next;
        }
    }

    printf("新生成的单链表为：\n");
    s = lc->next;
    while(s!=NULL)
    {
        printf("%d\t",s->data);
        s = s->next;
    }
    printf("\n");
    destroylist(lc);
    system("pause");
}

void listhexlist(node *la,node *lb) //<1><4>（递增有序）单链表表示集合A、B，实现：
{
    node *p,*q,*s,*k;
    p = la->next;
    q = lb->next;
    k = la;

    while(p!=NULL && q!=NULL)
    {
        if(p->data<q->data)
        {
            k->next = p->next;
            free(p);
            p = k->next;
        }
        else if(p->data==q->data)
        {
            p = p->next;
            k = k->next;
            q = q->next;
        }
        else
        {
            q = q->next;
        }
    }

    if(p!=NULL && q==NULL)
    {
        k->next = NULL;
        while(p!=NULL)
        {
            s = p->next;
            free(p);
            p = s;
        }
    }

    printf("新生成的单链表为：\n");
    k = la->next;
    while(k!=NULL)
    {
        printf("%d\t",k->data);
        k = k->next;
    }
    printf("\n");
    system("pause");
}

void listbixlist(node *la,node *lb) //<1><5>（递增有序）单链表表示集合A、B，实现：
{
    node *p,*q,*s,*k;
    p = la;
    q = lb->next;
    s = p->next;

    while(s!=NULL && q!=NULL)
    {
        if(s->data>=q->data)
        {
            k = (node *)malloc(sizeof(node));
            k->data = q->data;
            p->next = k;
            k->next = s;
            p = k;

            q = q->next;
        }
        else
        {
            s = s->next;
            p = p->next;
        }
    }

    if(s==NULL && q!=NULL)
    {
        while(q!=NULL)
        {
            k = (node *)malloc(sizeof(node));
            k->data = q->data;
            p->next = k;
            k->next = NULL;
            p = k;

            q = q->next;
        }
    }

    p = la->next;
    printf("新生成的单链表为：\n");
    while(p!=NULL)
    {
        printf("%d\t",p->data);
        p = p->next;
    }
    printf("\n");
    system("pause");
}

void listqxlist(node *la,node *lb) //<1><6>（递增有序）单链表表示集合A、B，实现：
{
    node *p,*q,*s;
    p = la;
    q = lb->next;
    s = p->next;

    while(s!=NULL && q!=NULL)
    {
        if(s->data==q->data)
        {
            p->next = s->next;
            free(s);
            s = p->next;
        }
        else if(s->data>q->data)
        {
            q = q->next;
        }
        else
        {
            p = p->next;
            s = s->next;
        }
    }

    p = la->next;
    printf("新生成的单链表为：\n");
    while(p!=NULL)
    {
        printf("%d\t",p->data);
        p = p->next;
    }
    printf("\n");
    system("pause");
}

int listzzlist(node *la,node *lb) //<2>（递增有序）单链表表示集合A、B，判定A是否B的子集。
{
    node *p,*q;
    p = la->next;
    q = lb->next;

    while(p!=NULL)
    {
        if(p->data==q->data)
        {
            p = p->next;
            q = q->next;
        }
        else if(p->data<q->data)
        {
            printf("A不是B的子集。\n");
            system("pause");
            return 0;
        }
        else
        {
            q = q->next;
        }
    }
    printf("A是B的子集。\n");
    system("pause");
    return 1;
}

int listkx(node *l,int k) // <3>已知一个带有表头结点的单链表，结点结构如下图。假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点（k为正整数）。若查找成功，算法输出该结点的data值，并返回1；否则，只返回0。
{
    int i;
    node *p,*s;
    p = l->next;
    s = l->next;

    for(i=1;i<k;i=i+1)
    {
        s = s->next;
    }

    if(s==NULL)
    {
        printf("无相应结点。\n");
        system("pause");
        return 0;
    }
    else
    {
        while(s->next!=NULL)
        {
            p = p->next;
            s = s->next;
        }
    }

    printf("结点的值为：\n");
    printf("%d\n",p->data);
    system("pause");
    return 1;
}

void listzlistz(node *la,node *lb) // <4>现有两个等长升序序列A 和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A 和B 的中位数。
{
    int i=1,j=1;
    node *p,*q,*k;
    p = la->next;
    q = lb->next;

    while(p!=NULL)
    {
        p = p->next;
        i = i+1;
    }
    p = la->next;

    while(p!=NULL && q!=NULL && j!=i)
    {
        if(p->data>=q->data)
        {
            k = q;
            j = j+1;
            q = q->next;
        }
        else
        {
            k = p;
            j = j+1;
            p = p->next;
        }
    }
    printf("中位数为：\n");
    printf("%d\n",k->data);
    system("pause");
}
#endif // LINKEDLIST_H_INCLUDED

#include"linkedList.h"

int main(void)
{
    menu();
    return 0;
}

栈

1.实验目标
熟练掌握栈的顺序存储结构和链式存储结构。
熟练掌握栈的有关算法设计，并在顺序栈和链栈上实现。
根据具体给定的需求，合理设计并实现相关结构和算法。

2.实验内容和要求

顺序栈的实验要求
顺序栈结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；
实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；
程序有适当的注释。

链栈实验要求
本次实验中的链栈结构指带头结点的单链表；
链栈结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；
实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；
程序有适当的注释。

顺序栈实验任务
设计并实现一个顺序栈，编写算法实现下列问题的求解。
<1>利用顺序栈实现将10进制数转换为16进制数。
第一组数据：4
第二组数据：11
第三组数据：254
第四组数据：1357
<2>对一个合法的数学表达式来说，其中的各大小括号“{”，“}”，“[”，“]”，“(”和“)”应是相互匹配的。设计算法对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。

链栈实验任务
以带头结点的单链表表示链栈，编写算法实现下列问题的求解。
<1>利用顺序栈实现将10进制数转换为16进制数。
第一组数据：4
第二组数据：11
第三组数据：254
第四组数据：1357
<2>对一个合法的数学表达式来说，其中的各大小括号“{”，“}”，“[”，“]”，“(”和“)”应是相互匹配的。设计算法对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。

栈的扩展实验
<1>假设栈的输入序列为1、2、3、…、n，设计算法实现对给定的一个序列，判定其是否是此栈合法的输出序列。
<2>假设栈的输入序列为1、2、3、…、n，设计算法求出所有可能的出栈序列。
<3>利用栈求解算术表达式的值。

3.数据结构设计

#ifndef STACKLIST_H_INCLUDED
#define STACKLIST_H_INCLUDED
#include<stdio.h>
#include<stdlib.h>
#define maxlen 10000

typedef struct iStack
{
    int data[maxlen];
    int top;
}seqistack;

typedef struct cStack
{
    char data[maxlen];
    int top;
}seqcstack;

typedef struct slnode
{
    int data;
    struct slnode *next;
}node;

typedef struct slcnode
{
    char data;
    struct slcnode *next;
}cnode;

void tentosixteen(void);
int chjudge(void);
int rightout(void);
int allrightout(void);
void finz(void);
void tts(void);
int ljudg(void);

void menu(void)
{
    int m;
    loop:

    printf("顺序栈实验任务：\n");
    printf("<1>利用顺序栈实现将10进制数转换为16进制数。\n");
    printf("<2>设计算法对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。\n");
    printf("\n");

    printf("链栈实验任务:\n");
    printf("<3>利用链栈实现将10进制数转换为16进制数。\n");
    printf("<4>设计算法对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。\n");
    printf("\n");

    printf("栈扩展实验:\n");
    printf("<5>假设栈的输入序列为1、2、3、...、n，设计算法实现对给定的一个序列，判定其是否是此栈合法的输出序列。\n");
    printf("<6>假设栈的输入序列为1、2、3、...、n，设计算法求出所有可能的出栈序列。\n");
    printf("<7>利用栈求解算术表达式的值。\n");
    printf("\n");

    printf("<8>清屏。\n");
    printf("<9>退出。\n");
    printf("\n");

    scanf("%d",&m);
    printf("\n");

    switch(m)
    {
        case 1:
            {
                tentosixteen();
                goto loop;
            }
        case 2:
            {
                chjudge();
                goto loop;
            }
        case 3:
            {
                tts();
                goto loop;
            }
        case 4:
            {
                ljudg();
                goto loop;
            }
        case 5:
            {
                rightout();
                goto loop;
            }
        case 6:
            {
                allrightout();
                goto loop;
            }
        case 7:
            {
                finz();
                goto loop;
            }
        case 8:
            {
                system("cls");
                goto loop;
            }
        case 9:
            {
                goto mmo;
            }
        default:
            {
                printf("输入错误。\n");
                system("pause");
                goto loop;
            }
    }
    mmo:system("cls");
}

void tentosixteen(void) //<1>利用顺序栈实现将10进制数转换为16进制数。
{
    seqistack l;
    int i,s;

    printf("输入数字:\n");
    scanf("%d",&s);

    l.top = -1;
    i = 0;

    printf("转化为十六进制后：\n");
    if(s>16)
    {
        while(s/16!=0)
        {
            l.data[i] = s%16;
            l.top = l.top+1;

            s = s/16;
            i = i+1;
        }
        l.data[i] = s;
        l.top = l.top+1;

        for(i=l.top;i>=0;i=i-1)
        {
            switch(l.data[i])
            {
                case 10:printf("a");break;
                case 11:printf("b");break;
                case 12:printf("c");break;
                case 13:printf("d");break;
                case 14:printf("e");break;
                case 15:printf("f");break;
                default:printf("%d",l.data[i]);break;
            }
        }
        printf("\n");
    }
    else
    {
        switch(s)
        {
            case 10:printf("a\n");break;
            case 11:printf("b\n");break;
            case 12:printf("c\n");break;
            case 13:printf("d\n");break;
            case 14:printf("e\n");break;
            case 15:printf("f\n");break;
            default:printf("%d\n",s);break;
        }
    }
    system("pause");
}

int chjudge(void) //<2>设计算法对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。
{
    seqcstack l;
    char s[80];
    int i;

    l.top = -1;
    printf("输入表达式。（在表达式尾输入#）\n");
    for(i=0;i<80;i=i+1)
    {
        scanf("%c",&s[i]);
        if(s[i]=='#')
        {
            break;
        }
    }

    for(i=0;s[i]!='\0';i=i+1)
    {
        if(s[i]=='(' || s[i]=='[' || s[i]=='{')
        {
            l.top = l.top+1;
            l.data[l.top] = s[i];
        }
        else if(s[i]==')' && l.data[l.top]=='(')
        {
            l.top = l.top-1;
        }
        else if(s[i]==']' && l.data[l.top]=='[')
        {
            l.top = l.top-1;
        }
        else if(s[i]=='}' && l.data[l.top]=='{')
        {
            l.top = l.top-1;
        }
    }

    if(l.top==-1)
    {
        printf("匹配。\n");
        system("pause");
        return 0;
    }
    else
    {
        printf("不匹配。\n");
        system("pause");
        return 1;
    }
}

int rightout(void) //<1>假设栈的输入序列为1、2、3、...、n，设计算法实现对给定的一个序列，判定其是否是此栈合法的输出序列。
{
    seqistack l,lo;
    int x,y,len,p;
    int i=0,j=0,k=0;

    l.top = -1;
    printf("输入序列长度。\n");
    scanf("%d",&len);
    while(len!=j)
    {
        l.data[j] = j+1;
        j++;
        l.top++;
    }

    if(len<=0)
    {
        printf("输入错误。\n");
        return 0;
    }

    printf("输入出栈序列。\n");
    while(len!=i)
    {
        scanf("%d",&lo.data[i]);
        i = i+1;
    }

    x = lo.data[0];
    y = x;
    p = lo.data[0];
    for(lo.top=0;i>lo.top;lo.top++)
    {
        k = lo.top;

        if(lo.data[k]<lo.data[0])
        {
            if(lo.data[k]>x)
            {
                printf("不是合法的输出序列。\n");
                system("pause");
                return 0;
            }
            x = lo.data[k];
        }
        else
        {
            if(lo.data[k]>y)
            {
                y = lo.data[k];
            }

            if(p<y && p<lo.data[k])
            {
                if(y!=lo.data[k])
                {
                    printf("不是合法的输出序列。\n");
                    system("pause");
                    return 0;
                }
            }
        }
        p = lo.data[k];
    }
    printf("是合法的输出序列。\n");
    system("pause");
    return 1;
}

void allpl(int q,int z,int m[])
{
    int i,a,k,qs,y,j;
    int p;
    if(q==z-1)
    {
        k = 1;
        qs = m[0];
        y = qs;
        p = m[0];

        for(j=0;j<z;j=j+1)
        {
            if(m[j]<m[0])
            {
                if(m[j]>qs)
                {
                    k = 0;
                    break;
                }
                qs = m[j];
            }
            else
            {
                if(m[j]>y)
                {
                    y = m[j];
                }

                if(p<y && p<m[j])
                {
                    if(y!=m[j])
                    {
                        k = 0;
                        break;
                    }
                }
            }
            p = m[j];
        }
        if(k==1)
        {
            for(k=0;k<z;k=k+1)
            {
                printf("%d\t",m[k]);
            }
            printf("\n");
        }
    }
    else
    {
        for(i=q;i<z;i=i+1)
        {
            a = m[i];
            m[i] = m[q];
            m[q] = a;

            allpl(q+1,z,m);

            a = m[i];
            m[i] = m[q];
            m[q] = a;
        }
    }
}

int allrightout(void) //<2>假设栈的输入序列为1、2、3、...、n，设计算法求出所有可能的出栈序列。
{
    seqistack l;
    int len;
    int i=0,j,k;

    printf("输入序列长度。\n");
    scanf("%d",&len);
    printf("\n");
    while(len!=i)
    {
        l.data[i] = i+1;
        i++;
        l.top++;
    }

    if(len<=0)
    {
        printf("输入错误。\n");
        return 0;
    }

    int m[len];
    for(i=0;i<len;i=i+1)
    {
        m[i] = i+1;
    }
    j = 0;
    k = len;
    allpl(j,k,m);
    system("pause");
    return 1;
}

void finz(void) //<3>利用栈求解算术表达式的值。
{
    char s[80];
    char a[80];
    int i=0,j=0;
    int qc=0,hc=0;
    int lss=-2;
    seqcstack lf;
    seqistack ls;

    lf.top = -1;
    ls.top = -1;
    printf("输入表达式。（在表达式尾输入#）\n");
    for(i=0;s[i]!='#';i=i+1)
    {
        scanf("%c",&s[i]);
        if(s[i]=='#' && i!=0)
        {
            break;
        }
    }

    for(i=0;s[i]!='#';i=i+1)
    {
        if(s[i]=='(')
        {
            qc++;
        }
        else if(s[i]==')')
        {
            hc++;
        }
    }

    if(qc!=hc)
    {
        printf("表达式不合法。\n");
        system("pause");
        printf("\n");
        return;
    }

    for(i=0;i<80;i=i+1)
    {
        a[i] = '#';
    }

    for(i=0;s[i]!='\0';i=i+1)
    {
        if(s[i]>='0' && s[i]<='9')
        {
            a[j] = s[i];
            j = j+1;
            if(s[i+1]<'0' || s[i+1]>'9')
            {
                ls.top++;
                lss++;
                ls.data[ls.top] = atoi(a);
                //printf("%d\t",ls.top);

                for(j=0;j<80;)
                {
                    a[j] = '#';
                    j = j+1;
                    if(a[j]=='#')
                    {
                        break;
                    }
                }
                j = 0;
            }
        }
        else
        {
            if(s[i]=='(')
            {
                lf.top++;
                lf.data[lf.top] = s[i];
            }

            if(s[i]==')')
            {
                while(lf.data[lf.top]!='(')
                {
                    switch(lf.data[lf.top])
                    {
                        case '+':ls.data[lss] = ls.data[lss]+ls.data[ls.top]; break;
                        case '-':ls.data[lss] = ls.data[lss]-ls.data[ls.top]; break;
                        case '*':ls.data[lss] = ls.data[lss]*ls.data[ls.top]; break;
                        case '/':ls.data[lss] = ls.data[lss]/ls.data[ls.top]; break;
                    }
                    ls.top--;
                    lss--;
                    lf.top--;
                    //printf("%d\n",ls.top);
                }
                lf.top--;
            }

            if(s[i]=='*' || s[i]=='/')
            {
                if(lf.data[lf.top]=='+' || lf.data[lf.top]=='-')
                {
                    lf.top++;
                    lf.data[lf.top] = s[i];
                }
                else if(lf.data[lf.top]=='*' || lf.data[lf.top]=='/')
                {
                    switch(lf.data[lf.top])
                    {
                        case '*':ls.data[lss] = ls.data[lss]*ls.data[ls.top]; break;
                        case '/':ls.data[lss] = ls.data[lss]/ls.data[ls.top]; break;
                    }
                    ls.top--;
                    lss--;
                    lf.data[lf.top] = s[i];
                    //printf("%d\n",ls.top);
                }
                else if(lf.data[lf.top]=='(')
                {
                    lf.top++;
                    lf.data[lf.top] = s[i];
                }
                else if(lf.top<0)
                {
                    lf.top++;
                    lf.data[lf.top] = s[i];
                }
            }
            else if(s[i]=='+' || s[i]=='-')
            {
                if(lf.data[lf.top]=='(')
                {
                    lf.top++;
                    lf.data[lf.top] = s[i];
                }
                else if(lf.top<0)
                {
                    lf.top++;
                    lf.data[lf.top] = s[i];
                }
                else
                {
                    while(lf.data[lf.top]!='(' && lf.top>=0)
                    {
                        switch(lf.data[lf.top])
                        {
                            case '+':ls.data[lss] = ls.data[lss]+ls.data[ls.top]; break;
                            case '-':ls.data[lss] = ls.data[lss]-ls.data[ls.top]; break;
                            case '*':ls.data[lss] = ls.data[lss]*ls.data[ls.top]; break;
                            case '/':ls.data[lss] = ls.data[lss]/ls.data[ls.top]; break;
                        }
                        ls.top--;
                        lss--;
                        lf.top--;
                    }
                    lf.top++;
                    lf.data[lf.top] = s[i];
                }
            }

            if(s[i]=='#')
            {
                while(lf.top>=0)
                {
                    switch(lf.data[lf.top])
                    {
                        case '+':ls.data[lss] = ls.data[lss]+ls.data[ls.top]; break;
                        case '-':ls.data[lss] = ls.data[lss]-ls.data[ls.top]; break;
                        case '*':ls.data[lss] = ls.data[lss]*ls.data[ls.top]; break;
                        case '/':ls.data[lss] = ls.data[lss]/ls.data[ls.top]; break;
                    }
                    ls.top--;
                    lss--;
                    lf.top--;
                    //printf("%d\n",ls.top);
                }
            }
        }
    }
    //printf("%d\n",ls.top);
    printf("\n");
    printf("%d\n",ls.data[ls.top]);
    printf("\n");
    system("pause");
}

void tts(void) //<1>利用链栈实现将10进制数转换为16进制数。
{
    node *l,*r,*p;
    int i,s;
    l = (node *)malloc(sizeof(node));
    l->next = NULL;
    p = l->next;

    printf("输入数字:\n");
    scanf("%d",&s);
    i = 0;

    printf("转化为十六进制后：\n");
    if(s>16)
    {
        while(s/16!=0)
        {
            r = (node *)malloc(sizeof(node));
            r->data = s%16;
            r->next = p;
            p = r;

            s = s/16;
        }
        r = (node *)malloc(sizeof(node));
        r->data = s;
        r->next = p;
        p = r;
        l->next = p;

        r = l->next;
        for(i=0;r!=NULL;i=i+1)
        {
            switch(r->data)
            {
                case 10:printf("a");break;
                case 11:printf("b");break;
                case 12:printf("c");break;
                case 13:printf("d");break;
                case 14:printf("e");break;
                case 15:printf("f");break;
                default:printf("%d",r->data);break;
            }
            r = r->next;
        }
        printf("\n");
    }
    else
    {
        switch(s)
        {
            case 10:printf("a\n");break;
            case 11:printf("b\n");break;
            case 12:printf("c\n");break;
            case 13:printf("d\n");break;
            case 14:printf("e\n");break;
            case 15:printf("f\n");break;
            default:printf("%d\n",s);break;
        }
    }

    r = l;
    while(r!=NULL)
    {
        l = l->next;
        free(r);
        r = l;
    }
    system("pause");
}

int ljudg(void) //<2>链栈设计算法对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。
{
    cnode *l,*p,*r;
    char s[80];
    int i;

    l = (cnode *)malloc(sizeof(cnode));
    l->next = NULL;
    r = l;
    printf("输入表达式。（在表达式尾输入#）\n");
    for(i=0;i<80;i=i+1)
    {
        scanf("%c",&s[i]);
        if(s[i]=='#')
        {
            break;
        }
    }

    for(i=0;s[i]!='\0';i=i+1)
    {
        if(s[i]=='(' || s[i]=='[' || s[i]=='{')
        {
            p = (cnode *)malloc(sizeof(cnode));
            p->data = s[i];
            r->next = p;
            p->next = NULL;
            r = p;
        }
        else if(s[i]==')' && p->data=='(')
        {
            r = l;
            while(r->next!=p)
            {
                r = r->next;
            }
            free(p);
            p = r;
            p->next = NULL;
        }
        else if(s[i]==']' && p->data=='[')
        {
            r = l;
            while(r->next!=p)
            {
                r = r->next;
            }
            free(p);
            p = r;
            p->next = NULL;
        }
        else if(s[i]=='}' && p->data=='{')
        {
            r = l;
            while(r->next!=p)
            {
                r = r->next;
            }
            free(p);
            p = r;
            p->next = NULL;
        }
    }

    if(l->next==NULL)
    {
        printf("匹配。\n");
        free(l);
        system("pause");
        return 0;
    }
    else
    {
        printf("不匹配。\n");
        r = l;
        while(r!=NULL)
        {
            l = l->next;
            free(r);
            r = l;
        }
        system("pause");
        return 1;
    }
}
#endif // STACKLIST_H_INCLUDED

#include"stacklist.h"

int main(void)
{
    menu();
}