【c】线性表

数据对象集：线性表是N（>=0）个元素构成的有序序列,a1,a2,a3.....a(N-1),aN,a(N+1)

线性表上的基本操作有：

⑴ 线性表初始化：Init_List(L)
初始条件：表L不存在操作结果：构造一个空的线性表

⑵ 求线性表的长度：Length_List(L)
初始条件：表L存在
操作结果：返回线性表中的所含元素的个数

⑶ 取表元：Get_List(L,i)
初始条件：表L存在且1<=i<=Length_List(L)
操作结果：返回线性表L中的第ｉ个元素的值或地址

⑷ 按值查找：Locate_List(L,x)，ｘ是给定的一个数据元素。
初始条件：线性表L存在
操作结果：在表L中查找值为ｘ的数据元素，其结果返回在L中首次出现的值为ｘ的那个元素的序号或地址，称为查找成功; 否则，在L中未找到值为ｘ的数据元素，返回一特殊值表示查找失败。

⑸ 插入操作：Insert_List(L,i,x)
初始条件：线性表L存在，插入位置正确(1<=i<=n+1,ｎ为插入前的表长)。
操作结果：在线性表L的第i 个位置上插入一个值为x 的新元素，这样使原序号为i , i+1, ... , n 的数据元素的序号变为i+1,i+2, ... , n+1，插入后表长=原表长+1。

⑹ 删除操作：Delete_List(L,i)
初始条件：线性表L存在，1<=i<=n。
操作结果：在线性表L中删除序号为i的数据元素，删除后使序号为i+1, i+2,..., n的元素变为序号为i, i+1,...,n-1，新表长＝原表长－１。

线性表的存储：顺序存储

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

 #define max 10
 typedef struct{
     int data[max];  //数组
     int last;        //最后一个数据在数组中的位置
 }LIST;

 //初始化
 LIST * makeEmpty();
 //查找，返回数据在数组中的位置，不存在返回-1
 int find(int,LIST *);
 //插入，成功1，失败-1
 int insert(int site,int num,LIST * Ptrl);
 //打印数据结构
 void dump(LIST *);
 //删除
 int del(int site,LIST * Ptrl); 

 void main(void)
 {
     int num;
     LIST * demo;
     demo = makeEmpty();

 }

 //初始化
 LIST * makeEmpty()
 {
     LIST * Ptrl;
     Ptrl = (LIST*)malloc(sizeof(LIST));
     Ptrl->last = -;    //为空时last为1
     return Ptrl;
 }
 //查找，返回数据在数组中的位置，不存在返回-1
 int find(int num,LIST * Ptrl)
 {
     int i=;
     while(i<=Ptrl->last && Ptrl->data[i]!=num)
     {
         i++;
     }
     //如果i大于数据的长度，则就是没有找到
     if(i > Ptrl->last)
         return -;
     //返回数据的位置
     return i;
 }
 //插入，成功1，失败-1
 int insert(int site,int num,LIST * Ptrl)
 {
     //1、判断是否已经满了，最后的位置=长度-1
     if(Ptrl->last == max-){
         return -;
     }
     //2、判断要插入的位置是否大于等于长度 site >= max
     if(site< || Ptrl->last >= max){
         return -;
     }
     //3、从最后一个数据开始移动，下一位填充上一位的数据 ,data[n+1] = data[n],data[n]=data[n-1],直到n>=site
     int i;
     for(i=Ptrl->last;i>=site;i--)
     {
         Ptrl->data[i+] = Ptrl->data[i];
     }
     Ptrl->data[site] = num;
     Ptrl->last += ;
     return ;
 } 

 //打印数据结构
 void dump(LIST * Ptrl){
     int i=;
     while(i<=Ptrl->last)
     {
         printf("%d=>%d---%d\n",i,Ptrl->data[i],Ptrl->last);
         i++;
     }
 }
 //删除
 int del(int site,LIST * Ptrl)
 {
     //检测删除的位置是否存在
     if(site > Ptrl->last || site<){
         return -;
     } 

     int i;
     for(i=site;i<=Ptrl->last;i++)
     {
         Ptrl->data[i] = Ptrl->data[i+];
     }
     Ptrl->last--;
     return ;
 } 

线性表的存储：链式存储

　　存放数据元素信息的称为数据域，存放其后继地址的称为指针域。因此n个元素的线性表通过每个结点的指针域拉成了一个“链子”，称之为链表。因为每个结点中只有一个指向后继的指针，所以称其为单链表。

　　链表是由一个个结点构成的，结点定义如下：
　　typedef struct node{

　　　　datatype data;
　　　　struct node *next;
　　} LNode，*LinkList；

　　定义头指针变量：
　　LinkList H；

　　

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

 #define max 10
 typedef struct list{
     int data;
     struct list * next;
 }LIST; 

 //初始化
 LIST * initialize();
 //按key查找
 LIST * findByKey(int key,LIST * Ptrl);
 //按value查找
 LIST * findByVal(int value,LIST * Ptrl);
 //插入
 int insert(int key,int val,LIST * Ptrl);
 //删除
 int delete(int key,LIST * Ptrl);
 //表长
 int length(LIST * Ptrl);
 //打印
 void dump(LIST * Ptrl);

  void main(void)
  {
      LIST * demo;
      demo = initialize();
      insert(,,demo);
      insert(,,demo);
      LIST * find = findByVal(,demo);
     //demo = initialize();
     dump(demo);
      //printf("%d",length(demo));
  }

 //初始化
 LIST * initialize()
 {
     LIST * Ptrl;
     Ptrl = (LIST *)malloc(sizeof(LIST));
     if(Ptrl==NULL){
         puts("molloc fail in line 38\n");
         exit;
     }
     Ptrl->next = NULL;
     Ptrl->data = ;
     return Ptrl;
 }
 //按key查找
 LIST * findByKey(int key,LIST * Ptrl)
 {
     if(key==)
     {
         return Ptrl;
     }

     LIST * p;
     p = Ptrl;
     int i=;

     while(p!=NULL && i<key)
     {
         p = p->next;
         i++;
     }
     if(i==key){
         return p;
     }
     return NULL;
 }
 //按value查找
 LIST * findByVal(int value,LIST * Ptrl)
 {
     LIST * p;
     p = Ptrl;
     while(p!=NULL && p->data!=value)
     {
         p=p->next;
     }
     if(p != NULL){
         return p;
     }else{
         return NULL;
     }
 }

  //插入
 int insert(int key,int val,LIST * Ptrl)
 {
     LIST * p,* find;

     p = (LIST *)malloc(sizeof(LIST));
     if(Ptrl==NULL){
         puts("molloc fail in line 86\n");
         exit;
     }

     find = findByKey(key-,Ptrl);

     p->data = val;
     p->next = find->next;
     find->next = p;

     return ;
 }
 //删除
 int delete(int key,LIST * Ptrl)
 {
     //检查长度的合法性

     //删除
     LIST * p,* find;
     p = findByKey(key,Ptrl);
     find = findByKey(key-,Ptrl);
     find->next = p->next;
     free(p);
 }
 //表长
 int length(LIST * Ptrl)
 {
     int i=;
     LIST * p = Ptrl;
     while(p!=NULL)
     {
         p = p->next;
         i++;
     }
     return i;
 }
 //打印
 void dump(LIST * Ptrl)
 {
     LIST * p = Ptrl;
     while(p!=NULL)
     {
         printf("%d\n",p->data);
         p = p->next;
     }
 }

栈的存储

    顺序存储

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #define max 10

 typedef struct list{
     int data[max];
     int top;
 }LIST;

 //初始化
 LIST * initialize();
 //判断是否为空
 int isEmpty(LIST *);
 //判断是否满了
 int isFull(LIST *);
 //出栈
 int pop(LIST *);
 //入栈
 int push(int value,LIST * Ptrl);
 //打印
 void dump(LIST *); 

 void main(void)
 {
     LIST * demo = initialize();
     push(,demo);
     push(,demo);
     push(,demo);
     pop(demo);
     dump(demo);
 }

 //初始化
 LIST * initialize()
 {
     LIST * Ptrl;
     Ptrl = (LIST *)malloc(sizeof(LIST));
     if(Ptrl == NULL)
     {
         puts("malloc error!!!\n");
         exit;
     }
     Ptrl->top=-;
     return Ptrl;
 }
 //判断是否为空
 int isEmpty(LIST * Ptrl)
 {
     if(Ptrl->top == -)
     {
         return ;
     }
     return ;
 }

 //判断是否满了
 int isFull(LIST * Ptrl)
 {
     if(Ptrl->top >= max-)
     {
         return ;
     }
     return ;
 }
 //出栈
 int pop(LIST * Ptrl)
 {
     if(isEmpty(Ptrl) == )
     {
         puts("is empty");
         exit;
     }

     int temp =  Ptrl->data[Ptrl->top];
     Ptrl->top--;
     return temp;
 }
 //入栈
 int push(int value,LIST * Ptrl)
 {
     if(isFull(Ptrl) == )
     {
         puts("is full");
         exit;
     }
     Ptrl->top++;
     Ptrl->data[Ptrl->top] = value;
     return ;
 }
 //打印
 void dump(LIST * Ptrl)
 {
     if(isEmpty(Ptrl) == )
     {
         puts("is empty");
         exit;
     }

     int i;
     for(i=Ptrl->top;i>=;i--)
     {
         printf("%d\n",Ptrl->data[i]);
     }
 }

 链式村粗

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #define max 10

 typedef struct list{
     int data;
     struct list * next;
 }LIST;

 //初始化
 LIST * initialize();
 //判断是否为空
 int isEmpty(LIST *);
 //判断是否满了
 int isFull(LIST *);
 //出栈
 int pop(LIST *);
 //入栈
 int push(int value,LIST * Ptrl);
 //打印
 void dump(LIST *); 

 void main(void)
 {
     LIST * demo = initialize();
     push(,demo);
     push(,demo);
     push(,demo);
     push(,demo);
     pop(demo);
     dump(demo);
 }

 //初始化
 LIST * initialize()
 {
     LIST * Ptrl;
     Ptrl = (LIST *)malloc(sizeof(LIST));
     Ptrl->next = NULL;
     //Ptrl->data = -1;
     return Ptrl;
 }
 //判断是否为空
 int isEmpty(LIST * Ptrl)
 {
     if(Ptrl->next == NULL)
     {
         return ;
     }
     return ;
 }

 //判断是否满了
 int isFull(LIST * Ptrl)
 {

 }
 //出栈
 int pop(LIST * Ptrl)
 {
     if(isEmpty(Ptrl)==){
         puts("is empty");
         exit;
     }
     LIST * temp = Ptrl->next;
     int data = temp->data;
     Ptrl->next = temp->next;
     free(temp);
     return data;
 }
 //入栈
 int push(int value,LIST * Ptrl)
 {
     LIST * temp = (LIST *)malloc(sizeof(LIST));
     temp->next = Ptrl->next;
     temp->data = value;
     Ptrl->next = temp;
     return ;
 }
 //打印
 void dump(LIST * Ptrl)
 {
     if(isEmpty(Ptrl)==){
         puts("is empty");
         exit;
     }
     LIST * p = Ptrl->next;
     while(p != NULL)
     {
         printf("%d\n",p->data);
         p = p->next;
     }

 }