浙江中医药大学-《数据结构》（C语言版）-第一章-第二章概念与代码

ZCMU-Data Structure（C language）

Part 1 Exordium

1、Data：能够输入到计算机中并被计算机程序处理的符号的总称。

2、Data Element：数据的基本单位，数据元素用以完整的描述一个对象。

3、Data Item：组成数据元素、有独立含义、不可分割的最小单位。

4、Data Object：性质相同的数据元素的集合。

5、数据结构的三要素：数据逻辑结构、数据存储结构、数据运算：

     其中：数据的逻辑结构包含

 

           

      数据的存储结构（物理结构）包含：顺序存储结构、链式存储结构。

6、算法的五个特性：

      1）有穷性

      2）确定性

      3）可行性

      4）输入

      5）输出

7、算法评价标准：

      1）正确性

      2）可读性

      3）健壮性

      4）高效性

8、算法复杂性分析：定义1.1 在计算算法时间复杂度时，可以忽略所有低次幂项和最高次幂项的系数，简化算法分析，体现增长率的含义。（实例见《数据结构 C语言版》严蔚敏 P13-P14 P17习题6）

Part 2 Linear List

9、对于非空的线性表或线性结构，包含以下特点：

      1）存在唯一的一个被称作“第一个”的数据元素。

      2）存在唯一的一个被称作“最后一个”的数据元素。

      3）除第一个之外，结构中的每个数据元素均只有一个前驱。

      4）除最后一个之外，结构中的每个数据元素只有一个后继。

10、线性表应用实例：稀疏多项式运算、图书管理系统。

11、线性表的顺序表示（顺序存储结构）指的是用一组地址连续的存储单元依次存储线性表的数据元素，特点是：逻辑上相邻的数据元素、物理次序也相邻；因此只要确定了存储线性表的起始位置，线性表中任一数据元素都可以随机存储，所以线性表的顺序存储结构是一种随机存储的存储结构。

12、顺序表中基本操作的实现：

        1）初始化

        为顺序表动态分配一个预定大小的数组空间，使elem指向这段空间的基地址。

Status InitList（Sqlist &L）
{
   L.elem=new ElemType[MAXSIZE];
   if(!L.elem) exit(OVERFLOW);
   L.length=0;
   return OK;
}

        2）取值

        由于顺序存储结构具有随机存储的特点，可以直接通过数组下标定位得到。elem[i-1]存储第i个数据元素。

  

if(i<1||i>L.length)return ERROR; //判断i是否合理
  e=L.elem[i-1];
  return OK;

        3）查找

        从第一个元素起，依次和e比较，若找到与e相等的元素L.elem[i]，则查找成功，返回该元素的序号i+1。

 

for(i=0;i<L.length;i++)
    if(L.elem[i]==e) return i+1;
 return 0;

       顺序表查找平均时间复杂度为O（n）。

        4）插入

        一般情况下，在第i个位置插入一个元素时，需要从最后一个元素即第n个元素开始，依次向后移动一个位置，直至第i个元素（共n-i+1个元素）。

  

if((i<1)||(i>L.length+1) return ERROR; //i值不合法
  if(L.length==MAXSIZE) return ERROR; //当前存储空间已满
  for(j=L.length-1;j>=i-1;j--)
     L.elem[j+1]=L.elem[j];//插入位置之后元素后移
  L.elem[i-1]=e;//将新元素e放入第i个位置
  ++L.length;//表长+1

       顺序表插入算法的平均时间复杂度为O(n)。

       5）删除

       一般情况下，删除第i个元素需要将第i+1个元素至第n个元素（共n-i）个元素依次向前移动一个位置（i=n时无需移动）。

  

if((i<1)||(i>L.length)) return ERROR ;
  for(j=i;j<=L.lenrth-1;j++)
    L.elem[j-1]=L.elem[j];//前移
    --L.length;
    return OK;

       顺序表删除算法平均时间复杂度为O(n)。

13、线性表链式存储的特点：用一组任意的存储单元存储线性表内的数据元素，这组存储单元可以是连续的，也可以是不连续的，因此需要包含两个部分，一是数据本身，二是结点，结点包含两个域，存储数据元素信息的为数据域，存储直接后继位置的域成为指针域，链表中的每个结点只包含一个指针域。同时由于最后一个数据元素没有直接后继，单链表中最后一个结点的指针为空。

14、链表增加头结点的作用：

        1）便于首元结点的处理

        2）便于空表和非空表的统一处理

15、单链表是非随机存取的存储结构，要取得第i个数据元素必须从头指针出发顺链进行寻找，称为顺序存取的存储结构。

16、单链表的基本操作的实现

        1）初始化

    

 L=new LNode;//生成新结点作为头结点
     L->next=NULL;
     return OK;

        2)取值

//在带头结点的单链表L中根据序号i获取元素的值，用e返回第i个数据元素的值
  p=L->next;j=1;//p指向首元结点，计数器j为1
  while(p&&j<i)//顺链域向后扫描，直到p为空域或p指向第i个元素
  {
     p=p->next;//指向下一个结点
    ++j;
   }
    if(!p||j>i) return ERROR;
     e=p->data; //取第i个结点的数据域
     return OK;

        单链表取值平均时间复杂度为O(n)。

        3）查找

   

p=L->next; //初始化，p指向首元结点
   while(p&&p->data!=e)
   p=p->next;
   return p;

       单链表查找平均时间复杂度为O(n)。

        4）插入

   

p=L;j=0;
   while(p&&(j<i-1))
    {p=p->next;++j; }//查找第i-1个结点，p指向该结点
   if(!p||j>i-1) return ERROR;
   //重点
   s=new LNode;
   s->data=e;
   s->next=p->next;
   p->next=s;
   return OK;

        5）删除

 

 p=L;j=0;
  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;//改变删除结点前驱结点的指针域
  delete q;
  return OK:

       插入和删除算法平均时间复杂度均为O(n)。

17、实现前插法和后插法创建单链表完整代码

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

typedef int Elem;

typedef struct Node
{
    Elem data;
    struct Node *next;
}Node,*LinkList;

LinkList LinkListBegin()
{
    Node *L;
    L=(Node *)malloc(sizeof(Node));
    if(L=NULL)
        printf("Fall");
    L->next=NULL;
}

///扦插
LinkList LinkListqiancha()
{
    Node *L;
    L=(Node *)malloc(sizeof(Node));
    L->next=NULL;

    Elem x;
    while(scanf("%d",&x)!=EOF)
    {
        Node *p;
        p=(Node *)malloc(sizeof(Node));
        p->data=x;
        p->next=L->next;
        L->next=p;
    }
    return L;
}

//后插
LinkList LinkListhoucha()
{
    Node *L;
    L=(Node *)malloc(sizeof(Node));
    L->next=NULL;
    Node *r;
    r=L;

    Elem x;
    while(scanf("%d",&x)!=EOF)
    {
        Node *p;
        p=(Node *)malloc(sizeof(Node));
        p->data=x;
        r->next=p;
        r=p;
    }
    r->next=NULL;
    return L;
}

//charu
LinkList LinkListInsert(LinkList L,int i,Elem x)
{
    Node *pre;
    pre=L;
    int temp=0;
    for(temp=1;temp<i;temp++)

        pre=pre->next;
        Node *p;
        p=(Node *)malloc(sizeof(Node));
        p->data=x;
        p->next=pre->next;
        pre->next=p;

    return L;

}

//
LinkList LinkListDelete(LinkList L, Elem x)
{
    Node *p,*pre;
    p=L->next;
    while(p->data!=x)
    {
        pre=p;
        p=p->next;
    }
    pre->next=p->next;
    delete(p);
    return L;
}

int main()
{
    LinkList list,start;
    list=LinkListqiancha();
    for(start=list->next;start!=NULL;start=start->next)
        printf("%d",start->data);
    int i;
    scanf("%d",&i);
    Elem x;
    scanf("%d",&x);
    LinkListInsert(list,i,x);
    for(start=list->next;start!=NULL;start=start->next)
        printf("%d",start->data);
    scanf("%d",&x);
    LinkListDelete(list,x);
    for(start=list->next;start!=NULL;start=start->next)
        printf("%d",start->data);
}

18、循环链表、链表合并

        循环链表的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

        循环链表和单链表判断指针p是否指向表尾的终止条件不同：

        单链表：p!=NULL或p->next!=NULL

        循环链表：p!=L或p->next!=L

        链表合并仅需将第一个表的尾指针指向第二表的第一个结点，第二个表的尾指针指向第一个表的头结点，然后释放第二个表的头结点，实现代码：

   

   p=B->next->next;
   B->next=A->next;
   A->next=p;

19、存储密度=数据元素本身占用的存储量/结点结构占用的存储量

        顺序表的存储密度为1，链表存储密度小于1，若不考虑顺序表中的空闲区，顺序表存储空间利用率100%，单链表存储空间利用率50%。

20、主要操作是和元素位置紧密相关的这类取值操作，采用顺序表；对于频繁进行插入或删除的线性表，采用链表。