线性表单元测验用实训

第1关：顺序表基本操作及应用

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


typedef int DataType;
struct SeqList{
    DataType  *elem;
    int Max; //表示线性表最大长度
    int curNum;//表示线性表中数据元素的个数
} ;


typedef  struct SeqList *PseqList;

//函数功能：创建一个空的顺序线性表，线性表最多能存放max个数据元素
PseqList createNullList(int max)
{
    PseqList head =(struct SeqList*) malloc(sizeof(struct SeqList)) ;
    head->curNum = 0;
    head->Max = max ;
    head->elem = (DataType* )malloc(sizeof(DataType)*max);
    return head ;
}

//函数功能： 在顺序线性表表尾插入数据元素
void insertTail(PseqList slist, DataType x)
{
    //此处填写代码，实现在顺序表表尾插入数据元素x的功能
    /********** Begin **********/
    /*
    PseqList p= slist;
    int cnt=0;
    while (cnt<slist->curNum)
    {
        cnt++;
    }
   */
    if (slist->curNum+1<=slist->Max)
    {
    slist->elem[slist->curNum]=x;
    slist->curNum++;

    }
    /********** End **********/
}

//输出线性表中所有数据元素，以空格为分界符
void printList(PseqList slist)
{
    for(int i = 0 ;i < slist->curNum ;i++)
        printf("%d ",slist->elem[i]) ;
}

void replace(PseqList slist , DataType x , DataType y)
{
    //在此处填写代码，实现将线性表slist中数据元素值为x的替换为值y
    /********** Begin **********/
    for (int i = 0; i < slist->Max; ++i) {
        if (slist->elem[i]==x)
        {
            slist->elem[i]=y;
        }
    }

    /********** End **********/
}

int  main(void){
    PseqList  L1 ;
    int n=20, x , i;
    L1 = createNullList( n);
    int datanum;
    scanf("%d",&datanum) ; //输入待插入数据元素个数
    //读入待插入的数据元素，并插入到线性表尾部
    for(i =0 ;i < datanum ;i++)   {
        scanf("%d",&x);
        insertTail(L1 ,x );
    }

    scanf("%d",&x);
    replace(L1 , x , 999); //将线性表L1中值为x的数据元素替换为999
    printList(L1);
}

 第2关：链式线性表操作

#include <stdio.h>
#include <stdlib.h>
typedef int DataType;

struct node
{
    DataType saleAmount ;//销售数量
    struct node *next;//指向下一产品的指针
} ;


typedef struct node * pNode;

//函数功能： 遍历链表并输出链表中各数据元素的值 
void traverseList_link(pNode pllist) //功能是输出线性表pllist的元素，以空格为分界符；
{
    pNode temp = pllist->next ;
    while(temp != NULL)
    {
        printf("%d ",temp->saleAmount);
        temp = temp->next;
    }
}

//创建一个空的链表 
pNode  createNullList_link(void  )
{
    struct node* temp = (struct node*)malloc(sizeof(struct node)) ;
    temp->next = NULL;
    temp->saleAmount = 0;
    return temp;
}

void insert_link(pNode pllist ,DataType x )
{
    pNode temp =  (struct node*)malloc(sizeof(struct node)) ;
    temp->saleAmount = x ;
    temp->next = NULL;
    pNode p = pllist->next , pre = pllist;
    while(p!=NULL)
    {
        pre = p ;
        p = p->next ;
    }
    pre->next = temp ;
}


void reverseList_link( pNode pllist)
{
    //请在此处填入代码，实现链表逆置功能 
    /********** Begin **********/
    if (pllist==NULL||pllist->next==NULL)
    {
        return;
    }
pNode p,q,r;
p=q=NULL;
r=pllist->next;
while (r!=NULL)
{
    p=r->next;
    r->next=q;
    q=r;
    r=p;
}
pllist->next=q;

    /********** End **********/
}

int main(void)
{
    pNode pllist = createNullList_link() ;
    int num ;
    DataType data;
    scanf("%d",&num);
    for(int i = 0;i < num; i++)
    {
        scanf("%d",&data);
        insert_link(pllist, data);
    }
    reverseList_link(pllist)    ;
    traverseList_link(pllist);
}
 

 第3关：利用栈操作，实现平衡符号判定

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

typedef char DataType;

//采用链式栈 
struct node{
    DataType data;  //数据元素
    struct node *next; //指向下一个数据元素的指针
};

typedef struct node *PtrToNode;
typedef PtrToNode Stack;

//初始化一个空栈 
Stack createNullStack(void)
{
    PtrToNode head = (struct node* )malloc(sizeof(struct node));
    head->next = NULL;
    return head;
}

//入栈函数，参数：入栈数据元素，栈头指针
void push(DataType x , Stack s)
{
    //请在此处填写代码，实现入栈操作
    /********** Begin **********/
    //since functionPop is pop from head stack next one
    PtrToNode sta = (struct node* )malloc(sizeof(struct node));
    sta->data=x;
    sta->next=s->next;
    s->next=sta;
   /* PtrToNode p=s;
    while (p->next!=NULL)
    {
        p=p->next;
    }
    p->next=sta;
*/
    /********** End **********/
}

//判定栈是否为空，若栈为空，则返回1，否则返回0 
int isEmpty(Stack s)
{
    //请在此处填写代码，实现判定栈是否为空操作，若栈为空，则返回1，否则返回0
    /********** Begin **********/
if (s==NULL)
{
    return 1;

}
    return 0;

    /********** End **********/
}

//出栈，并返回栈顶元素
DataType pop(Stack s)
{
    if(isEmpty(s) == 0)
    {
        DataType x = s->next->data;
        PtrToNode p = s->next ;
        s->next = p->next ;
        free(p) ;
        return x ;
    }
    else
        return 0;
}

void balance( char str[])
{
    //请在此处填写代码，实现平衡符号的判定,若判断不匹配， 输出  不匹配， 否则输出  匹配
    /********** Begin **********/
int i=0;
Stack head=createNullStack();
while (str[i]!='\0')
{
if (str[i]=='('||str[i]=='{'||str[i]=='[')//left sign push to stack
{
    push(str[i],head);
}

if (str[i]==')'||str[i]=='}'||str[i]==']')//right sign pop from stack
{
    if (isEmpty(head))
    {
        printf("不匹配");
        return;
    }
    DataType d=pop(head);
    //match pop
    if (str[i]==')')
    {
        if (d!='(')
        {
            printf("不匹配");
            return;
        }
    }
    if (str[i]==']')
    {
        if (d!='[')
        {
            printf("不匹配");
            return;
        }
    }
    if (str[i]=='}')
    {
        if (d!='{')
        {
            printf("不匹配");
            return;
        }
    }
}
i++;
}
if (isEmpty(head))
{
    printf("不匹配");
    return;
}
printf("匹配");
    return;
    /********** End **********/
}

int main()
{
    char str[90] ;
    gets(str) ;
    balance(str);
}