线性表

 1. 定义

  （1）顺序存储

typedef struct
{
	ElemType data[MAXSIZE];
	int length;
}SqList;

 （2）链式存储

typedef struct  NODE
{
	int data;
	struct NODE *next;
}node;

 一个结构内部包含一个类型为该结构本身的成员是非法的，但是包含一个指向该结构的指针是合法的。 注意：这里必须要用结构的标签来声明指针。

2. 实现

（1）顺序存储结构的获取元素，插入，删除操作。

 

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAXSIZE 10
#define TRUE 1
#define FALSE 0
typedef struct
{
    int data[MAXSIZE];
    int length;
}SqList;
void SetElem(SqList *L);
int GetElem(SqList *L,int i,int *e);
int InsertElem(SqList *L,int i,int e); 
int DeleteElem(SqList *L,int i);
void PrintList(SqList *L);
int main()
{
    SqList list;
    int m;
    SetElem(&list);
    printf("原线性表： ");
    PrintList(&list);
    GetElem(&list,1,&m);
    printf("第1个元素：%d\n",m);
    InsertElem(&list,1,10);
    printf("在第1个位置插入10：");
    PrintList(&list);
    DeleteElem(&list,1);
    printf("删除第1个位置的元素：");
    PrintList(&list);
    return 0;
}

void SetElem(SqList *L)
{
    srand((unsigned)time(NULL));
    for(int i=0;i<MAXSIZE-1;++i)
        L->data[i]=rand()%100;
    L->length=MAXSIZE-1;
}
int GetElem(SqList *L,int i,int *e)
{
    if(L->length==0 || i<1 ||i>L->length)
        return FALSE;
    *e=L->data[i-1];
    return TRUE;
}
int InsertElem(SqList *L,int i,int e)  //在第i个位置之前插入数据元素e
{
    if(L->length==MAXSIZE || i<1 || i>L->length+1)
        return FALSE;
    if(i<L->length+1)
    {
        for(int k=L->length-1;k>=i-1;--k)
        {
            L->data[k+1]=L->data[k];
        }
    }
    L->data[i-1]=e;
    L->length++;
    return TRUE;
}
int DeleteElem(SqList *L,int i)  //删除第i个位置的数据元素
{
    if(i<1 || i>L->length)
        return FALSE;
    if(i<L->length)
    {
        for(int k=i-1;k<L->length-1;++k)
            L->data[k]=L->data[k+1];
    }
    L->length--;
    return TRUE;
}
void PrintList(SqList *L)
{
    for(int i=0;i<L->length;++i)
    {
        printf("%d ",L->data[i]);
    }
    printf("\n");
}

    （2）单链表结构

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
typedef struct NODE
{
    int data;
    NODE *next;
}Node;
typedef Node *LinkList;
void CreateList(LinkList *L,int n);
void PrintList(LinkList *L);
int InsertElem(LinkList *L,int i,int m);
int DeleteElem(LinkList *L,int i);
void ClearList(LinkList *L);
int main()
{
    LinkList list;
    CreateList(&list,10);
    printf("原单链表：");
    PrintList(&list);

    InsertElem(&list,1,100);
    printf("在第1个元素前插入100: ");
    PrintList(&list);
    
    DeleteElem(&list,11);
    printf("删除第11个位置的结点：");
    PrintList(&list);
    
    ClearList(&list);
    printf("删除整表：");
    PrintList(&list);
    return 0;
}

/*
void CreateList(LinkList *L,int n)   //头插法
{
    LinkList p;
    int i;
    *L=(Node*)malloc(sizeof(Node));
    (*L)->next=NULL;
    for(i=0;i<n;++i)
    {
        p=(LinkList)malloc(sizeof(Node));
        p->data=rand()%100;
        p->next=(*L)->next;
        (*L)->next=p;
    }
}
*/
void CreateList(LinkList *L,int n)  //尾插法
{
    LinkList p,r;
    int i;
    *L=(Node*)malloc(sizeof(Node));
    r=*L;
    for(i=0;i<n;++i)
    {
        p=(Node*)malloc(sizeof(Node));
        p->data=rand()%100;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}

void PrintList(LinkList *L)
{
    Node *p;
    p=(*L)->next;
    while(p)
    {
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int InsertElem(LinkList *L,int i,int m)   //在第i个位置前插入一个新结点
{
    Node *p,*s;
    p=*L;
    int j=1;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!(p->next) || j>i)
    {
        return FALSE;
    }
    s=(Node*)malloc(sizeof(Node));
    s->data=m;
    s->next=p->next;
    p->next=s;
    return TRUE;
}
int DeleteElem(LinkList *L,int i)   //删除第i个结点
{
    Node *p,*q;
    p=*L;
    int j=1;
    while(p->next&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!(p->next) || j>i)
        return FALSE;
    q=p->next;
    p->next=q->next;
    free(q);
    return TRUE;
}
void ClearList(LinkList *L)
{
    Node *p,*q;
    p=(*L)->next;
    while(p)
    {
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next=NULL;
}

  （3）双向循环链表

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define TRUE 1
#define FALSE 0
typedef struct DulNODE
{
    DulNODE *prior;
    DulNODE *next;
    int data;
}DulNode;
typedef DulNode *DulLinkList;
void CreateLinkList(DulLinkList *L,int n);
void PrintList(DulLinkList *L);
int InsertElem(DulLinkList *L,int i,int m);
void DeleteElem(DulLinkList *L,int i);
int main()
{
    DulLinkList list;
    CreateLinkList(&list,10);
    printf("原双向循环链表：");
    PrintList(&list);

    InsertElem(&list,3,100);
    printf("在第3个位置后插入100：");
    PrintList(&list);

    DeleteElem(&list,3);
    printf("删除第3个位置的结点：");
    PrintList(&list);
    
    return 0;
}
void CreateLinkList(DulLinkList *L,int n)
{

    DulNode *p,*r;
    *L=(DulNode*)malloc(sizeof(DulNode));
    (*L)->next=*L;
    (*L)->prior=*L;
    r=*L;
    for(int i=0;i<n;++i)
    {
        p=(DulNode*)malloc(sizeof(DulNode));
        p->data=rand()%100;
        r->next=p;
        p->prior=r;
        r=p;
    }
    p->next=*L;
    (*L)->prior=p;
}
void PrintList(DulLinkList *L)
{
    DulNode *p;
    p=(*L)->next;
    while(p!=(*L))
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
int InsertElem(DulLinkList *L,int i,int m) //在第i个位置之后插入新元素m
{
    DulNode *p,*s;
    p=*L;
    int j=0;
    while((p->next!=(*L))&&j<i)
    {
        p=p->next;
        ++j;
    }
    s=(DulNode*)malloc(sizeof(DulNode));
    s->data=m;
    s->next=p->next;
    p->next->prior=s;
    s->prior=p;
    p->next=s;
    return TRUE;
}
void DeleteElem(DulLinkList *L,int i) //删除第i个位置的结点
{
    DulNode *p;
    p=(*L)->next;
    int j=1;
    while(p!=(*L)&&j<i)
    {
        p=p->next;
        ++j;
    }
    p->prior->next=p->next;
    p->next->prior=p->prior;
    free(p);
}