数据结构的学习之线性表

顺序存储结构借助高级程序语言中的数组来表示，一维数组的下标（从0开始）与元素在线性表中的序号（从1开始）一一对应。类型描述如下：

#define MaxSize 线性表可能达到的最大长度

typedef struct{

ElementType  elem[MaxSize];/*线性表占用的数组空间*/

int  listlength ;/*线性表的实际长度*/

}Seqlist;

线性表定义为 SeqList  a;第i个元素对应为a.elem[i-1]表示，a的长度由a.listlength表示。

目录

顺序表的基本运算（重点）

单链表及其基本运算

---

顺序表的基本运算（重点）

1.查找运算

int Locate（SeqList,ElemType e）

/*在顺序表中查找元素e,ifL.elem[i]==e,则返回元素位置，找不到返回-1*/

{  int   i=0;

while((i<=l.listlength-1)&&(l.listlength!=e))

  i++;

if(i<=l.listlenth-1)

return (i);

else return (-1);

}

2.插入运算

顺序表是以“存储位置相邻”表示元素之间的前驱和后继关系，插入第i个元素，要将后面的元素进行后移。

void InsList（Seqlist *l,int i,ElemType e）

{

if((i<0)||(i>l->listlength))

{

printf("Error");

return 0;

}

if(l->listlength>=MaxSize-1)

{

printf("Overflow");

return 0;

}

for(k=l->listlength-1;k>=i;k--)

l->elem[k+1]=l->elem[k];

l->elem[i]=e;

l->listlength++;

}

3.删除运算

数据元素前移，链表长度减一即可

void Dellist(Seqlist *l,int i)

{
  if((i<0)||(i>l->listlength-i))

{

printf("Error");

return 0;

}

for(k=i+1;i<=l->listlength-1;k++)

  l->elem[k-1]=l->elem[k];

l->listlength--;

}

ps:写一个算法使得两个递增有序顺序表合并成一个新的递增有序顺序表。

void Merge (seqlist la,seqlist lb,SeqList *lc)

{

   int i=j=k=0;

while((i<=la.listlength-1)&&(j<=lb.listlength-1))

{

    if(la.elem[i]<=lb.elem[j])

{

     lc->elem[k]=la.elem[i];

   ++k;++i;

}

else 

{

lc-elem[k]=lb.elem[j];

++k;++j;

}

}

while(i<=la.listlength-1)

{

  lc->elem[k]=la.elem[i];

++k;++i;

}/*从前往后遍历进行比较把较小的数赋给新的顺序表中*/

while(j<=lb.listlength-1)

{

lc->elem[k]=lb.elem[j];

++k;++j;

}

lc->listlength=la.listlength+lb.listlength;

}

单链表及其基本运算

由n个节点一次相连构成的链表，称为线性表的链式存储表示，又因为每个节点中只包含一个指针域，所以又称为单链表或线性链表。

typedef   struct Lnode{

 elementtype data;

strct Lnode *next;

}ListNode;

typedef ListNode *LinkList ;/*Linklist 为指向ListNode的指针类型*/

Linklist head;//头指针的声明

单链表基本运算的实现（重要）

（1）查找运算
LinkList Locate(LinkList head ,ElemType x)

{

  p=head->next;

  while(p!=NULL&&p->data!=x)

   p=p->next;

  return p;

}

(2)单链表的插入操作

申请新节点，数据域的值为x,指针指向这个新节点，并且该节点的指针域指向下一个节点。

void InsList(Linklist head,int i,ElemType x)

{

pre = head;k=0;

while(Pre!=NULL&&k<i-1)

{
pre=pre->next;

k=k+1;

}

if((k!=i-1)||(pre==NULL))

printf("Error");

else

{

  p=(LinkList)malloc(sizeof(ListNode));

  p->data=x;

  p->next=pre->next;

 pre->next=p;

}

}

（3）删除节点

void DelList (Linklist head,int i)

{

  pre=head;k=0;

while(pre->next!=NULL&&k<i-1)

{
pre=pre-next;

k=k+1;

}

if(!(pre->next)&&k<=i-1)

printf("Error");

else

{

  p=pre->next;

  pre->next=pre->next-next;

free(p);

}

}

以上三种基本运算均是在头结点的单链表上实现的。下面仅以删除操作为例，给出其在不带头节点的单链表上的实现。

Linklist DelList(Linklist head,int i)

{
  if(head==NULL)

{

printf("Empty link")；

retrun (NULL);

}

if(i==1)

{

p=head;

head=head->next;

free(p);

return (head);

}

pre = head；k=0;

while(pre->next!=NULL&&K<i-1)

{

pre=pre->next;

k=k+1;

}

if(!(p->next)&&k<=i-1)

   printf("Inexistent node");

else {

p=pre->next;

pre->next=pre->next->next;

free(p);

}

return (head);

}

ps:写一算法建立带头节点的单链表

Linklist Create（）

{    p=q=NULL；

    scanf(&x)；

    while(x!=FLAG)

{

p=(LinkLIst)malloc(sizeof(ListNode));

p->data=x;

p->next=q;

q=p;

scanf(&x);

}

head=(Linklist)malloc(sizeof(ListNode))

head->next=p;

return (head);

}