数据结构实验1

一.目的和要求
1. 熟练掌握顺序存储结构和链式存储结构的描述方法；
2. 熟练掌握线性表在顺序存储结构上实现基本操作：查找，插入，删除；
3. 熟练掌握在各种链表结构中实现线性表操作的基本方法，能在实际应用中选用适当的链表结构，了解静态链表；
4. 掌握栈和队列这两种抽象数据类型的特点；
5. 熟练掌握栈类型的两种实现方法，即两种存储结构表实现的基本操作，特别应注意栈满和栈空的条件以及他们的描述方法；
6. 熟练掌握循环队列和链队列的基本操作实现算法，特别队满和队空的描述方法。
二.实验题目
1. 顺序表的插入；
2. 单链表的删除并使其逆置输出；
3. 数据元素弹出栈。
三.实验步骤与源程序
1． 顺序表的插入步骤：
1)构造一个空的线性表L;
2)建立顺序表；
3)在顺序表的第i个位置之前插入一个元素
4)输出插入之后的新的顺序表L.
其源程序如下:
#include<stdio.h>  
  #include<conio.h>  
  #include<stdlib.h>  
  #define    LIST_INIT_SIZE    100
  #define   OVERFLOW  0
  #define   OK   1  
  #define   ERROR   0  
  #define   LISTINCREMENT   10    
  typedef   struct{  
      int   *elem;  
      int   length;       /*表示表中元素数目*/  
      int   listsize;     /*表示表的长度*/  
  }SqList;  
int  InitList_sq(SqList& L)/*构造一个空的线性表*/
  {  
      L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));  
      if(!L.elem)exit(OVERFLOW);  
      L.length=0;  
      L.listsize=LIST_INIT_SIZE;  
      return   OK;  
  }
  int CreateList_sq(SqList&L)/*建立顺序表*/
  {int i;
  printf("Input the datas:");
   for(i=0;i<L.length;i++)
    scanf("%d",&L.elem[i]);
   return OK;
  }
int   InsertList_sq(SqList&L,int   i,int   e){  
      int   *newbase;/*一旦表不够长，重新申请空间所用 */ 
      int   *p,*q;  
      if((i<1)||(i>L.length+1))   return   ERROR;/*插入位置不能为0或负，也不能大于表长*/ 
      if(L.length>=L.listsize){  
          newbase=(int   *)realloc(L.elem,(L.listsize+LISTINCREMENT)   *sizeof(int));    
          if(!newbase)exit(OVERFLOW);  
        L.elem=newbase;  
         L.listsize+=LISTINCREMENT;  
      }  
      q=&(L.elem[i-1]);  
      for(p=&L.elem[L.length-1];p>=q;--p)   *(p+1)=*p;  
      *q=e;  
      ++L.length;  
      return   OK;  
  } 
 
  void   main(){  
      int i,n,e;
      SqList L;
   InitList_sq(L);
   printf("\nInput the length of the list L:");
   scanf("%d",&n);
   L.length=n;
   CreateList_sq(L);
   printf("Input the insert data:");
   scanf("%d",&e);
   printf("Input the insert location:");
   scanf("%d",&i);
   InsertList_sq(L,i,e);
  printf("Output the data:");
  for(i=0;i<L.length;i++)
   printf("%d\n",L.elem[i]);
  getch();
  }
2带头结点的单链表的删除步骤:
  1)构造一个空的线性表L;
  2)建立线性表L;
  3)在带头结点的单链表中删除第i的元素;
  4)输出新的单链表.
其源程序如下：  
# include <stdlib.h>
# include <stdio.h>
# include <conio.h>
#define  OVERFLOW 0
# define INIT_LENGTH 10
# define OK 1
# define ERROR 0
typedef struct LNode
{int data;
struct LNode *next;
}LNode,*LinkList;
int  InitList_L(LinkList *L)      /*构造一个空的线性表*/
  {  
      (*L)=(LinkList)malloc(sizeof(LNode));
      if(!(*L))return(OVERFLOW);
      (*L)->next=NULL;
      return   OK;  
}
int  CreateList_L(LinkList *L,int n)  /*建立线性表*/
{ int i;
  LNode *p;
  (*L)=(LinkList)malloc(sizeof(LNode));
  (*L)->next=NULL;
  for(i=0;i<n;++i)
  {
   p=(LinkList)malloc(sizeof(LNode));
   scanf("%d",&p->data);
   p->next=(*L)->next;
   (*L)->next=p;
   }
   return OK;
   }
int TraverseList_L(LinkList L) 
{
LinkList p;
p=L->next;
while(p)
{printf("%d\n",p->data);
      p=p->next;
}
return OK;
}
  int ListDelete_L(LinkList *L,int i,int *e)
{
   LNode *p,*q;
   int j=0;
   p=*L;
   while(p->next&&j<i-1)
   { p=p->next;++j;
   }
   if(!p->next||j>i-1)  return ERROR;
   q=p->next;
   p->next=q->next;
   *e=q->data;
   free(q);
   return OK;
}
void   main(){  
  int i,n,e;
  LinkList L;
  InitList_L(&L);
  printf("\nInput the length of the list L:");
  scanf("%d",&n);
  printf("Input the numbers:");
  CreateList_L(&L,n); 
   printf("Input the delete location:");
   scanf("%d",&i);
   ListDelete_L(&L,i,&e);
  printf("Output the data:\n");
  TraverseList_L(L);
   getch();
  }
3将元素弹出顺序栈的步骤：
   1）初始化旧栈；
   2）输出旧的栈；
   3）将栈顶元素弹出，并输出栈顶元素的值；
   4）输出新栈.
其源程序如下：
# include <malloc.h>
# include <stdio.h>
# include <conio.h>
# define STACK_INIT_SIZE 100
# define STACKINCREMENT 10
# define OK 1
# define ERROR 0
typedef int SElemType;

typedef struct SqStack   /*定义结构体SqStack*/
{    SElemType *base;
     SElemType *top;
     int stacksize;
}SqStack;

int Pop(SqStack &S,SElemType &e) /* 如果栈 S 空，返回 ERROR ；如果栈 S 不空，删除 S 栈顶元素，用 e 返回其值，并返回 OK */
{    if(S.top==S.base)
     {   printf("It's a empty SqStack!");
   return (ERROR);
     }
     e=*--S.top;
     return (OK);
}

void main()    /*main function*/
{   SElemType e;
    SqStack S;
    S.stacksize=STACK_INIT_SIZE;
    S.base=S.top=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    *S.top++=1;    /*初始化旧的栈*/
    *S.top++=3;
    *S.top++=6;
    *S.top++=8;
    *S.top++=7;
    *S.top++=9;
    SElemType *p; 
   printf("The old SqStack is (base to top)\n : ");
    for(p=S.base;p!=S.top;p++)  /*输出旧栈*/
       printf("%d\n",*p);
    if(Pop(S,e))
printf("\nthe pop nuber is:\n%d",e); /*输出栈顶元素*/
   printf("\nThe new SqStack is : ");
    for(p=S.base;p!=S.top;p++)  /*输出新栈*/
     printf("%d\n",*p);   
    getch();
}
四．测试数据与实验结果
1. 顺序表的插入实验结果如图一；
2. 单链表的删除实验结果如图二；
3. 将元素弹出顺序栈的实验结果如图三；


图一  顺序表的插入

               图二    单链表的删除（逆置读入）

图三   将元素弹出顺序栈
五．结果分析与实验体会

经过这次实验发现，学习数据结构对C语言将会有很大提高。以前我觉得写好一个程序使其可以运行是那么的可望而不可及，每次写完一段小程序，不管怎样还是有错误，于是便没有耐心去调试，但是这次的作业我必须得认真完成，这样我便要求自己努力的静下心来去调试程序，当程序调试成功之后的那种喜悦的心情我都不知道怎么用言语来表达。真的好欣慰，让我更确信“世上无难事只怕有心人”。
这次实验加深了我对刚学过的数据结构的基础知识理解。更深刻的理解了线性结构的特点：在数据元素的非空有限集中存在唯一的一个被叫做“第一个”的数据元素;存在唯一的一个被称做”最后一个”的数据元素;除第一个之外,集合中的每个数据元素均只有一个前驱;除最后一个之外集合中每个元素均只有一个后继.；用顺序方法存储的线性表称为顺序表，当线性表中很少做插入和删除操作，线性表的长度变化不大，易于事先确定其大小时，可以采用顺序表作为存储结构。用链接方法存储的线性表称为线性链表，当线性表的长度变化较大，难以估计其存储规模，另外对线性表频繁进行插入和删除操作时，则采用链表作为存储结构可能会更好一些。对于线性表在顺序存储结构上实现基本操作的算法如查找，插入，删除等也理解得更透彻了，也理解了栈和队列的插入和删除原则:(1),栈,后进先出,所有操作都是在栈顶进行的.(2),队列,先进先出,插入运算只能在对尾进行,删除运算只能在对头进行! 对于栈满和栈空的条件以及他们的描述方法；掌握了循环队列和链队列的基本操作实现算法，特别队满和队空的描述方法。
我也觉得自己动手编程是那么的重要，因为编程序是个实干的活，光说不练不行。刚开始学的时候可以多练习书上的习题。对于自己不明白的地方，自己编个小程序实验一下是最好的方法，能给自己留下深刻的印象。自己动手的过程中要不断纠正自己不好的编程习惯和认识错误。
这次实验使我觉得受益匪浅，我对以后的学习有了更得大的信心，但是学习的过程将会是很艰辛的，不过我不会放弃，希望自己可以在不断完善过程中达到不断提高的效果。