数据结构

线性表

顺序表

typedef struct
{
    int a;
}test;
typedef struct test
{
    test *st;
    int length;
}sqList;
sqList sq;
void creat(int n)
{
    test *p;
    int i;
    p=sq.st=(test *)malloc(sizeof(test)*n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&p->a);
        p++;
    }
    sq.length=n;
}

静态链表

#include<stdio.h>
#define max 10000
typedef struct test
{
    int data;
    int cur;
}list;
void creat(list *a,int n);
int main()
{
    list a[max];
    int n;
    scanf("%d",&n);
    creat(a,n);
    for(int i=1;i<=n;i++)
    {
        printf("%d ",a[i].data);
    }
}
void creat(list *a,int n)
{
    int i;
    for(i=0;i<max-1;i++)
    {
        a[i].cur=i+1;
    }
    for(i=1;i<=n;i++)
    {
        scanf("%d",&a[i].data);
    }
    a[0].cur=a[n].cur;//备注的下一个可用空间。
    a[max-1].cur=1;//可以用来得出第一个节点。
}

对于静态链表的删除和插入我们需要每次考虑到备用节点（空闲的节点）的位置，借助最后一个节点我们可以得到第一个节点的位置。
删除节点

k=max-1;//得到最后一个节点，以便得到第一个节点。
for(j=1;j<i-1;j++)//得到要处理位置的前面一个，特殊位置就是第一节点要被处理时也已经计算进去了。
{	
	k=a[j].cur;//移动位置；	
}
j=a[k].cur;
a[k].cur=a[j].cur;
free(a,j);//释放节点函数，自己写；

链式链表

单向链表

#include<stdio.h>
#include<stdlib.h>
typedef struct list
{
    int data;
    struct list *next;
}List;
List *creat(int n);
int main()
{
    List *head,*p;
    int n;
    scanf("%d",&n);
    head=creat(n);
    p=head;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
}
List *creat(int n)
{
    int i;
    List *p,*q,*head;
    q=(List *)malloc(sizeof(List));
    head=NULL;
    for(i=0;i<n;i++)
    {
        scanf("%d",&q->data);
        if(head==0)
        {
            p=head=q;
        }
        else
        {
            p->next=q;
            p=q;
        }
        q=(List *)malloc(sizeof(List));
    }
    p->next=0;//给最后一个节点赋值NULL代表结束。
    return head;
}

删除和插入节点，只需要找到处理节点之前的位置；
删除节点

q=p->nest;//q用来存储要删除的节点，p是删除节点的前面的节点。
p->next=p->next->next;
free(q);

插入节点

q->next=p->next;//q是要插入的节点，p是前面节点。
p->next=q;

循环链表
顾名思义就是一个环，与单链表不同的是判断结束是p!=head,我们也可以将头节点变为尾节点。

#include<stdio.h>
#include<stdlib.h>
typedef struct list
{
    int data;
    struct list *next;
}List;
List *creat(int n);
int main()
{
    List *last,*p;
    int n;
    scanf("%d",&n);
    last=creat(n);
    p=last->next;
    do
    {
        printf("%d ",p->next->data);
        p=p->next;
    }while(p!=last);
}
List *creat(int n)
{
    int i;
    List *p,*q,*head;
    head=(List *)malloc(sizeof(List));
    head->next=NULL;
    for(i=0;i<n;i++)
    {
        q=(List *)malloc(sizeof(List));
        scanf("%d",&q->data);
        if(head->next==0)
        {
            q->next=head->next;
            head->next=q;
            p=q;
        }
        else
        {
            q->next=p->next;
            p->next=q;
            p=q;
        }

    }
    p->next=head;//给最后一个节点赋值head代表尾节点。
    return p;//返回尾节点
}

双链表
有两指针，一个指向前面节点Prior，一个指向后面节点next。
插入节点

q->prior=p;//q为插入的节点，p为前面节点。
q->next=p->next;
p->next->prior=q;
p->next=q;

删除节点

q=p->next;//p为前面节点
p->next=q->next;
q->next->prior=p;