链表，顺序表的基本操作及其实现的栈与队列

1，顺序表

在c里面，这一部分也就是静态表和动态表的实现，插入，删除有丁点意思。

静态表靠数组和长度实现（注意长度这一点，因为它反映了当前表内容长度，十分重要）

动态表依靠申请连续空间实现（结构体内部包括首地址，当前规模以及长度）

插入：

	int *p;
	p=&(w.a[k-1]);
	int *q;
	for(q=&(w.a[w.length-1]);q>=p;--q)
	{
		*(q+1)=*q;
	}
	*q=m;
	++w.length;

删除同理

2，链表：

链表结构体很简单：

typedef struct Node{
	int data;
	struct Node *next;
}; 
typedef Node* Linkedlist;

首先是首插法和尾插法：

int Touinsert(Linkedlist &l)
{
	Lnode* r,s,m;
	l=r;
	for(int i=0;i<=length;i++)
	{
		s=(Lnode *)malloc(sizeof(Lnode));
		s->data=i;
		s->next=L;
		r=L;        //!
	}
	for(int i=0;i<=length;i++)
	{
		s=(Lnode *)malloc(sizeof(Lnode));
		s->data=i;
		L->next=s;
		s->next=m;
		m=s;
	} 
}//头插法对于存不存在头节点没有特殊需求,反而头结点会导致头插法不那么方便
/*
int Weiinsert(LInkedlist &l)
{
	Lnode *r,m;
	r=L;
		for(int i=0;i<=length;i++)
	{
		s=(Lnode *)malloc(sizeof(Lnode));
	    r->next=s;
	    r=s;
	}
}//尾插法在此处就有问题——我们不可能r=L后（此时L为NULL）通过对r的操作改变L，首结点的本质是使得初定义的指针可以和L共同指向一个有意义的节点，通过初定义的指针直接影响L
*/ 
int Weiinsert(LInkedlist *l)
{
	L=(Lnode*)malloc(sizeof(Lnode));//注意定义首节点的方法 
	Lnode *r,*s;
	r=L;
	for(int i=0;i<=length;i++)
	{
		s=(Lnode *)malloc(sizeof(Lnode));
		s->data=i;
		r->next=s;
		r=s;
	}
}

如上所述，尾插法记得加首节点，会令操作简化一些，并且逻辑不会冲突。

接下来，是循环链表，双链表，循环双链表的基本操作，并不复杂，也就是在基本的尾插法上加一些操作即可实现。

void init_CircleLinkedList(Linkedlist &l1,int t)
{
	
	Linkedlist m,a;
	m=(Linkedlist)malloc(sizeof(Node));
	m->data=t;
	l1=m;               //!!!
	m->next=NULL;
	
	for(int i=0;i<t;i++)
	{
		a=(Linkedlist)malloc(sizeof(Node));
		a->data=i;
		m->next=a;
		m=m->next;
	
		if(i==t-1)
		{
			m->next=l1->next;
			continue;
		}
	}
}
void init_DoubleLInkedlist(Linkedlist1 &l2,int t)
{
	Linkedlist1 m,a;
	m=(Linkedlist1)malloc(sizeof(Node1));
	m->data=t;
	l2=m;
	m->next1=NULL;
	m->prior=NULL;
	for(int i=0;i<t;i++)
	{
		a=(Linkedlist1)malloc(sizeof(Node1));
		a->data=i;
		m->next1=a;
		a->prior=m;
        m=a;
        if(i==t-1)
        {
        	m->next1=NULL;
        }
	}
}
void init_DoubleLCircleInkedlist(Linkedlist1 &l2,int t)
{
	Linkedlist1 m,a;
	m=(Linkedlist1)malloc(sizeof(Node1));
	m->data=t;
	l2=m;
	m->next1=NULL;
	m->prior=NULL;
	for(int i=0;i<t;i++)
	{
		a=(Linkedlist1)malloc(sizeof(Node1));
		a->data=i;
		m->next1=a;
		a->prior=m;
        m=a;
        if(i==t-1)
        {
        	m->next1=l2;
        	l2->next->prior=m;
        }
	}
}

最后，我特别粘贴一张双链表的插入操作的图：

注意：在双向链表中，得到节点只能通过priori或是next得到先序节点或是后继节点，所以我们在连好后/先节点与插入节点之前不可断链。

概括而言：顺序是s的后继连向p的后继，p的后继的前驱连上s（先把p的后继处理），s的前驱指向p，p的后继指向s。（之后把p连向s）；

3，栈与队列

栈和队列基于顺序表抑或是链表实现的，他们不过是在后者的操作的基础上加上特定的操作罢了。

typedef struct{
	char a[MAXSIZE];
	int top;
}SqStack;
typedef struct{
	int *base;
	int *top;
	int stacksize;
}SqStack1;

以上是顺序栈的结构体，静态的top初始化为-1，动态的top=base指向申请空间首位置。

注意：入栈是先升指针再入栈。（*（++S.top）=e）

           出栈是先赋值给参数再降指针（*（S.top--）=e）（反了，懒得改能看懂就ok）

链栈不很常见，头节点+首插法就ok，存取对象都是头节点的next即可。

队列：

以普通静态队列为例：

typedef struct{
	int elem[100];
	int rear,front;
	int SqSize;
}SqQueue;

以上结构体；

入队出队：

void Basic_Operate(SqQueue &S,int a,int m)
{
	if(m==1)
	{
		S.elem[S.top++]=a;
	}
	if(m==0)
	{
		a=S.elem[S.rear++];
		printf("%d",a);
	}
}

循环动态队列：

typedef struct{
	int *base;
	int top;
	int rear;
}CircleQueue;

以上结构体；

int init_CQ(CircleQueue &CQ)
{
	CQ.base=(int *)malloc(sizeof(100));
	CQ.top=0;
	CQ.rear=0;
}
int EnQueue(Circle &CQ,int a)
{
	if((CQ.rear+1+100)%100==CQ.top){
		return ERROR;
	}
	else
	{
		CQ.base[CQ.rear]=a;
		CQ.rear=(CQ.rear+1+100)%100;
		return 1;
	}
}
int DeQueue(CirCleQueue &CQ,int a)
{
	if(CQ.top==CQ.rear)
	{
		return ERROR;
	}
	else
	{
		a=CQ.base[top];
		CQ.top=(CQ.top+1+100)%100;
		return a;
	}
}

以上初始化/插入/删除操作；

注意：1，判满条件：(CQ.rear+1)%MAXSIZE==CQ.top；

           2，判空条件：CQ.rear==CQ.top；

           3，CQ.top=(top+1)%MAXSIZE；

最后，在脑海里要形成栈和队列各自指针的位置，栈只有一个头指针top，永远指向存在值的最上面的地址，队列有两个指针，首指针和尾指针，尾进头出，尾指针永远指向最后一个入队元素下一个的空位置，头指针永远指向即将出队的元素，除非队空，一定有值。