第三次作业:顺序表与链表

C语言的顺序表与链表知识

这个作业属于哪个课程	[https://edu.cnblogs.com/campus/qdu/DS2020/homework/11232]
这个作业的要求在哪里	[https://edu.cnblogs.com/campus/qdu/DS2020/homework/11232]
这个作业的目标	C语言的顺序表与链表 1、掌握线性表中元素的前驱、后续的概念。 2、掌握顺序表与链表建立、插入元素、删除表中某元素的算法。 3、对线性表的相应算法的时间复杂度进行分析。 4、理解顺序表、链表数据结构的特点（优缺点）。

实验目的

  1、掌握线性表中元素的前驱、后续的概念。<br>
  2、掌握顺序表与链表建立、插入元素、删除表中某元素的算法。<br>
  3、对线性表的相应算法的时间复杂度进行分析。<br>
  4、理解顺序表、链表数据结构的特点（优缺点）。<br>

实验预习

  说明一下概念
  - 1、线性表：
  线性表是由n(n>=0) 个数据元素（结点）a1，a2...an组成的有序列。
  其中，数据元素的个数为n定义为表的长度。
  - 2、顺序表：
  顺序表是指用顺序存储方法存储的线性表。
  将一个线性表存储到计算机中，可以采用许多不同的方法，其中既简单有自然的是顺序存储方法：即把线性表的结点按逻辑次序依次存放在一个地址连续的储存单元里。
  - 3、链表：
  采用链接方式存储的线性表成为链表。
  从实现的角度看，链表可分为动态链表和静态链表；从链接方式的角度看，链表可分为单链表、循环链表和双链表。

实验内容和要求

  1、阅读程序，
  ~~~
  #include<stdio.h>
  #include<malloc.h>
  #define ERROR 0
  #define OK 1
  #define INIT_SIZE 5     /*初始分配的顺序表长度*/
  #define INCREM 5        /*溢出时，顺序表长度的增量*/
  typedef  int ElemType;  /*定义表元素的类型*/
  typedef struct Sqlist{
      ElemType *slist;      /*存储空间的基地址*/
      int length;           /*顺序表的当前长度*/
      int listsize;         /*当前分配的存储空间*/
  }Sqlist;

  int InitList_sq(Sqlist *L); /*初始化顺序表L，并将其长度设为0*/
  int CreateList_sq(Sqlist *L,int n); /*构造顺序表的长度为n*/
  int ListInsert_sq(Sqlist *L,int i,ElemType e);/*在顺序线性表L中第i个元素之前插入新的元素e*/
  int PrintList_sq(Sqlist *L);  /*输出顺序表的元素*/
  int ListDelete_sq(Sqlist *L,int i); /*删除第i个元素*/
  int ListLocate(Sqlist *L,ElemType e); /*查找值为e的元素*/

  int InitList_sq(Sqlist *L){
      L->slist=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));
      if(!L->slist) return ERROR;      
      L->length=0;                     
      L->listsize=INIT_SIZE;           
      return OK;                   
  }/*InitList*/

  int CreateList_sq(Sqlist *L,int n){
      ElemType e;
      int i;
      for(i=0;i<n;i++){
          printf("input data %d",i+1);
          scanf("%d",&e);
          if(!ListInsert_sq(L,i+1,e))
              return ERROR;
      }
      return OK;
  }/*CreateList*/

  /*输出顺序表中的元素*/
  int PrintList_sq(Sqlist *L){
      for(int i=1;i<=L->length;i++)
          printf("%5d",L->slist[i-1]);
      return OK;
  }/*PrintList*/

  int ListInsert_sq(Sqlist *L,int i,ElemType e){
      int k;
      if(i<1||i>L->length+1) 
          return ERROR;    
      if(L->length>=L->listsize){  
          L->slist=(ElemType*)realloc(L->slist,
          (INIT_SIZE+INCREM)*sizeof(ElemType));
            if(!L->slist) 
                return ERROR; 
                L->listsize+=INCREM;                
      }
      for(k=L->length-1;k>=i-1;k--){         
          L->slist[k+1]= L->slist[k];
      }
      L->slist[i-1]=e;                     
      L->length++;                         
      return OK;
  }/*ListInsert*/

  /*在顺序表中删除第i个元素*/
  int ListDelete_sq(Sqlist *L,int i){
      int p; 
      if((i<1)||(i>L->length)) return ERROR;
      for(p=i-1;p<=L->length-1;p++){ 
            L->slist[p]=L->slist[p+1];
      } 
      L->length--;
      return OK;
  }/*ListDelete*/
  /*在顺序表中查找指定值元素，返回其序号*/
  int ListLocate(Sqlist *L,ElemType e){    
      int i,z=0;
      for(i=1;i<L->length;i++){
	      if(L->slist[i-1]==e){
		      return i;
	      }
      }
  }/*ListLocate*/

  int main(){
      Sqlist sl;
      int n,m,k,d;
      printf("please input n:");  /*输入顺序表的元素个数*/
      scanf("%d",&n);
      if(n>0){
          printf("
1-Create Sqlist:
");
          InitList_sq(&sl);
          CreateList_sq(&sl,n);
          printf("
2-Print Sqlist:
");
          PrintList_sq(&sl);
          printf("
please input insert location and data:(location,data)
");
          scanf("%d,%d",&m,&k);
          ListInsert_sq(&sl,m,k);
          printf("
3-Print Sqlist:
");
          PrintList_sq(&sl);
          printf("
");

          printf("
please input delete location:
");
          scanf("%d",&d);
          ListDelete_sq(&sl,d);

          printf("
4-Print Sqlist:
");
          PrintList_sq(&sl);
          printf("
");

    }else
          printf("ERROR");
      return 0;
  }
  ~~~

运行结果

分析

  1、初始化链表 调用ListInsrt_sq()函数插入数据，并输出
  2、插入数据 2，12 在位置2 处插入12
  3、删除 位置2处的数据

删除算法代码

  ~~~
  int ListDelete_sq(Sqlist *L,int i){
        //判断链表长度 长度为0表示不存在
        if(L->length == 0)return 0;
        //判断传入值位置是否存在
        if(i<1 ||| i>L->length)return 0;
        //循环替换 开始数据处用后面一个替换前面一个数据
        for(int j=i-1;j<=L->length;j++){
             L->slist[j] = L->slist[j+1];                   
        }
        L->length--;
        return OK;
  }  
  ~~~

查询算法代码

   ~~~
  /*在顺序表中查找指定元素,返回其序号*/
  int ListLocate(Sqlist * L,ElemType e)
  {
      int i,z=0;
      for ( i = 1; i < L->length; i++)
      {
          if(L->slist[i-1]==e)
              return i;
      }
  }/*ListLocate*/
  ~~~

执行以下程序

  ~~~
  #include<stdio.h>
  #include<malloc.h>
  #define ERROR 0
  #define OK 1

  typedef int ElemType; /*定义元素的类型*/
  typedef struct LNode /*线性表的单链表存储*/
  {
      ElemType data;
      struct LNode *next;
  }LNode,*LinkList;

  LinkList CreateList(int n); /*初始化链表*/
  void PrintList(LinkList L); /*输出带头结点单链表的所有元素*/
  int GetElem(LinkList L,int i,ElemType *e); /*获取链表*/

  LinkList InitList(LinkList L,int i,ElemType *e); /*插入数据*/
  void DeleteList(LinkList L,int i);/*删除数据*/

  /*初始化链表*/
  LinkList CreateList(int n)
  {
      LNode *p,*q,*head;
      int i;
      head =(LinkList)malloc(sizeof(LNode)); /*sizeof() 是一个表达式长度的运算符字节,malloc是分配一个内存空间*/
      head->next = NULL;
      p=head;
      for(i=0;i<n;i++){
          q=(LinkList)malloc(sizeof(LNode));
          printf("input datae %i:",i+1);
          scanf("%d",&q->data);
          q->next = NULL;
          p->next = q;
          p=q;
      }
      return head;
  }/*CreateList*/

  /*打印链表*/
  void PrintList(LinkList L)
  {
      LNode *P;
      P=L->next; /*p指向单链表的第1个元素*/
      while (P!=NULL)
      {
          printf("%5d",P->data);
          P=P->next;
      }  
  }/*PrintList*/

  /*获取数据*/
  int GetElem(LinkList L,int i,ElemType *e)
  {
      LNode *p;int j=1;
      p=L->next;
      while (p&&j<i)
      {
          p=p->next;
          j++;
      }
      if(!p||j>i)
          return ERROR;
      *e = p->data;
      return OK;
  }/*GetElem*/


  void DeleteList(LinkList L,int i)
  {
      LNode *p,*q;
      int j;
      p=L;j=0;
      while (p->next&&j<i-1)
      {
          p=p->next;
          ++j;
      }
      q=p->next;
      p->next = q->next;
      free(q);
  }//DeleteList


  /*插入数据*/
  LinkList InitList(LinkList L,int i,ElemType *e)
  {
      LNode *p,*s;
      int j;
      p=L;j=0;
      while (p&&j<i-1)
      {
          p=p->next;
          ++j;
      }
      if(!p||j>i-1)return ERROR;
      s=(LinkList)malloc(sizeof(LNode));
      s->data=*e;
      s->next=p->next;
      p->next=s;
      return OK;
  }//InitList




  int main()
  {
      int n,i;
      ElemType e;
      LinkList L =NULL;       /*定义指向单链表的指针*/
      printf("please input n:");/*输入单链表的元素个数*/
      scanf("%d",&n);
      if(n>0){
          printf("n1-Create LinkList:
");
          L=CreateList(n);
          printf("
2-Print LinkList:
");
          PrintList(L);
          printf("
3-GetElem form LinkList:
");
          printf("input i=");
          scanf("%d",&i);
          if(GetElem(L,i,&e))
          {
              printf("No%i is %d",i,e);
          }else
          {
              printf("not exists");
          }
    
          printf("
4-InitList ");

      }else
      {
          printf("ERROR");
      }

      return 0;
  }
  ~~~