线性表

//顺序表类型定义
  #define ListSize 100 //表空间的大小可根据实际需要而定，这里假设为100
  typedef int DataType; //DataType的类型可根据实际情况而定，这里假设为int
  typedef struct {
      DataType data[ListSize]；//向量data用于存放表结点
      int length；//当前的表长度
     }SeqList；
//顺序表上实现的基本运算
//1.表的初始化
   void InitList（SeqList *L）
     {\顺序表的初始化即将表的长度置为0
            L-＞length=0；
    }

//2.求表长
    int ListLength（SeqList *L）
       { \求表长只需返回L-＞length
          return L-＞length;
      }

//3.取表中第i个结点
  DataType GetNode（L，i）
      {\取表中第i个结点只需返回和L-＞data[i-1]即可
          if (i<1||i> L-＞length-1)
                  Error("position error")；
          return L-＞data[i-1]；
       }
//5. 插入
void InsertList(SeqList *L，DataType x，int i)
     {//将新结点 x插入L所指的顺序表的第i个结点ai的位置上
       int j;
       if (i<1||i>L->length+1)
           Error("position error");//非法位置，退出运行
       if (L->length>=ListSize)
           Error("overflow");     //表空间溢出，退出运行
       for(j=L->length-1;j>=i-1;j--)
            L->data[j+1]=L->data[j];//结点后移
       L->data[i-1]=x;      //插入x
       L->Length++;        //表长加1
     }
//6． 删除
 void DeleteList(SeqList *L,int i)
      {//从L所指的顺序表中删除第i个结点ai
         int j;
        if(i<1||i>L->length)
           Error("position error"); //非法位置
        for(j=i;j<=L->length-1;j++)
           L->data[j-1]=L->data[j]; //结点前移
        L->length--;                //表长减小
       }

//单链表的运算
// 1、建立单链表
 //（1） 头插法建表
 // 具体算法实现
    LinkList CreatListF(void)
      {//返回单链表的头指针
          char ch;
          LinkList head;//头指针
          ListNode *s;  //工作指针
          head=NULL;    //链表开始为空
          ch=getchar(); //读入第1个字符
          while(ch!='
'){
              s=(ListNode *)malloc(sizeof(ListNode));//生成新结点
              s->data=ch;   //将读入的数据放入新结点的数据域中
              s->next=head;
              head=s;
              ch=getchar();  //读入下一字符
            }
          return head;
       } 
//（2） 尾插法建表 
// 具体算法实现 
    LinkList CreatListR(void)
      {//返回单链表的头指针
          char ch;
          LinkList head;//头指针
          ListNode *s,*r;  //工作指针
          head=NULL;    //链表开始为空
          r=NULL;//尾指针初值为空
          ch=getchar(); //读入第1个字符
          while(ch!='
'){
              s=(ListNode *)malloc(sizeof(ListNode));//生成新结点
              s->data=ch;   //将读入的数据放入新结点的数据域中
           if (head!=NULL)
               head=s;//新结点插入空表
           else
               r->next=s;//将新结点插到*r之后
              r=s;//尾指针指向新表尾
           ch=getchar();  //读入下一字符
         }//endwhile
        if (r!=NULL)
             r->next=NULL;//对于非空表，将尾结点指针域置空head=s;
         return head;
    } 
//（3） 尾插法建带头结点的单链表 
      ③尾插法建带头结点链表算法 
  LinkList CreatListR1(void)
      {//用尾插法建立带头结点的单链表
          char ch;
          LinkList head=(ListNode *)malloc(sizeof(ListNode));//生成头结点
          ListNode *s,*r;  //工作指针
          r=head;    // 尾指针初值也指向头结点
          while((ch=getchar())!='
'){
              s=(ListNode *)malloc(sizeof(ListNode));//生成新结点
              s->data=ch;   //将读入的数据放入新结点的数据域中
              r->next=s;
              r=s;
            }
          r->next=NULL;//终端结点的指针域置空，或空表的头结点指针域置空
          return head;
       } 
//单链表的查找运算 
（1）按序号查找
   ListNode* GetNode(LinkList head,int i)
     {//在带头结点的单链表head中查找第i个结点，若找到（0≤i≤n），
      //则返回该结点的存储位置，否则返回NULL。
      int j;
      ListNode *p;
      p=head;j=0;//从头结点开始扫描
      while(p->next&&j<i){//顺指针向后扫描，直到p->next为NULL或i=j为止
          p=p->next;
          j++;
        }
      if(i==j)
         return p;//找到了第i个结点
      else return NULL;//当i<0或i>0时，找不到第i个结点
     } 
//（2） 按值查找
 ListNode* LocateNode (LinkList head,DataType key)
      {//在带头结点的单链表head中查找其值为key的结点
        ListNode *p=head->next;//从开始结点比较。表非空，p初始值指向开始结点
        while(p&&p->data!=key)//直到p为NULL或p->data为key为止
             p=p->next;//扫描下一结点
         return p;//若p=NULL，则查找失败，否则p指向值为key的结点
       }
//3.插入运算 
void InsertList(LinkList head,DataType x,int i)
      {//将值为x的新结点插入到带头结点的单链表head的第i个结点的位置上
        ListNode *p;
        p=GetNode(head,i-1);//寻找第i-1个结点
        if (p==NULL)//i<1或i>n+1时插入位置i有错
           Error("position error")；
        s=(ListNode *)malloc(sizeof(ListNode));
        s->data=x;s->next=p->next;p->next=s;
      }  
//4.删除运算
  void DeleteList(LinkList head,int i)
      {//删除带头结点的单链表head上的第i个结点
         ListNode *p,*r;
         p=GetNode(head,i-1);//找到第i-1个结点
         if (p==NULL||p->next==NULL)//i<1或i>n时，删除位置错
              Error("position error");//退出程序运行
         r=p->next;//使r指向被删除的结点ai
         p->next=r->next;//将ai从链上摘下
         free(r);//释放结点ai的空间给存储池
       } 
//1、循环链表
 LinkList Connect(LinkList A,LinkList B)
       {//假设A，B为非空循环链表的尾指针
          LinkList p=A->next;//①保存A表的头结点位置
          A->next=B->next->next;//②B表的开始结点链接到A表尾
          free(B->next);//③释放B表的头结点
          B->next=p;//④
          return B;//返回新循环链表的尾指针
    }
//1、双向链表（Double Linked List）
//2、双向链表的结点结构和形式描述
//①结点结构(见上图a)
      
//②形式描述 
    typedef struct dlistnode{
         DataType data;
         struct dlistnode *prior,*next;
      }DListNode;
    typedef DListNode *DLinkList;
    DLinkList head;
//①双链表的前插操作
 void DInsertBefore(DListNode *p,DataType x)
      {//在带头结点的双链表中，将值为x的新结点插入*p之前，设p≠NULL
        DListNode *s=malloc(sizeof(DListNode));//①
        s->data=x;//②
        s->prior=p->prior;//③
        s->next=p;//④
        p->prior->next=s;//⑤
        p->prior=s;//⑥
       }
//②双链表上删除结点*p自身的操作
 void DDeleteNode(DListNode *p)
      {//在带头结点的双链表中，删除结点*p，设*p为非终端结点
          p->prior->next=p->next;//①
          p->next->prior=p->prior;//②
          free(p);//③
      }