순환 단일 체인 테이블 의 구조 와 정의

#include  "stdafx.h"
#include
using namespace std;
#include


enum Status{OK,ERROR};

typedef int ElemType;

typedef struct Lnode 
{
    ElemType num;    ///       int
    Lnode *next;    ///         
}LNode,*LinkList;

///  n       
Status CreatLink(LinkList &L,int n)
{
     LinkList p;
     LinkList head;
     L = (LinkList)malloc(sizeof(LNode));///       
     if (L == NULL)
     {
        return ERROR;
     }
     L->next = L; //        
     head = L;      // head  L，               head   ，    head   。

     for (int i = 0; i < n; ++i)
     {
          p = (LinkList)malloc(sizeof(LNode));///     
          if (p == NULL)
          {
                return ERROR;
          }
          p->num = i+1;
          p->next = L;

          head->next = p;///        
          head = p;
     }
    return OK;
}

///    
Status PrintLink(LinkList L)
{
     LinkList p = L->next;
     LinkList q;
     while (p != L)
     {
          q = p->next;
          cout<<"    "<num;
          p = q;
     }
     cout<<endl;
    return OK;
}
//       i      
void insert(LinkList &L,int i,ElemType &e)
{
    LNode *p;
    int j=1;
    LinkList node;
    p=L;
    while(p->next!=L  && j//   i-1   
    {
        p=p->next;
        ++j;
    }
    if(p->next==L && j//    while   ，      ，    p            
    {
        cout<<"           "<<endl;
        return;
    }
    node = (LinkList) malloc(sizeof(LNode));//  LNode   
    node->num=e;
    node->next = p->next;
    p->next = node;
}

///         
Status DelLink(LinkList &L,int n)
{
    int i = 1;
    LinkList p,q;
    p=L;
    while(p->next!=L && i//     n,     n-1，            n-1
    {
        p=p->next;
        ++i;
    }
    if(p->next==L)
    {
        cout<<"               ："<<endl;
        return ERROR;
    }
    q = p->next;
    p->next = q->next;
    free(q);
    return OK;
}

//    
Status DestroyLink(LinkList &L)
{
     LinkList p = L->next;
     LinkList q;
     while (p != L)
     {
          q = p->next;
          free(p);
          p = q;
     }
    free(L);
    return OK;
}



int main(int argc,char* argv[])
{
    int n;
    ElemType data;
    LinkList L;
    cin>>n;
    CreatLink(L,n);
    PrintLink(L);
    cout<<"        ：";
    cin>>n;
    DelLink(L,n);
    cout<<"              ：";
    cin>>n;
    cin>>data;
    insert(L,n,data);
    PrintLink(L);
    cin>>n;
    DestroyLink(L);

     return 0;
}

단일 체인 표 와 순환 단일 체인 표 에 있어 가장 큰 차 이 는 순환 단일 체인 표 의 마지막 노드 가 머리 결점 을 가리 키 고 단일 체인 표 의 마지막 노드 는 NULL 이다.
실현 시의 방법 은 기본적으로 같 지만 유일 하 게 다른 것 은 판단 조건 이다.
단일 링크: 빈 판단 은 마지막 노드 포인터 필드 가 NULL 입 니 다.
순환 단일 체인 표: 빈 판단 은 노드 의 다음 노드 가 그 자 체 를 가리 키 는 것 이다. 즉, 하나의 머리 결점 만 있다.