线性表-链表存储

//结构体
typedef sturct Node{
		int data;
		sturct Node * next;
}
//插入排序
void function(Node * node){
	Node * p = node->next->next;
	Node * pre;
	Node * c;
	Node * s;
	while(p!=NULL){
		q = node;//**指向头结点**
		c = node->next;**//指向头结点后的第一个结点**
		while(c!=NULL  || c->data<p->data){**//当前c结点如果为空或者结点值小于需插入的结点值则往后移**
			 pre = pre->next;
			 c = c->next;
		} 
		pre->next = p;//插入p结点
		s = p;
		p = p->next;//p指向下一个需要插入的结点
		s->next = c;
	}
}
//有序链表进行倒序（第二次循环才进行倒换）
void func2(Node * node){
	Node * p = node->next;//p指向头结点后的第一个结点
	Node * s;
	while(p){
		s = p->next;//s指向p结点后的一个结点
		p->next = node->next;//第一次循环自己指向自己第二轮正式指向头结点后的第一个结点
		node->next = p;
		p = s;
	}
}
//链表的中心对称(利用栈的先进后出队列的先进先出原则比对)
int function3(Node * node){
	Que * que;//队列
	Stack * stack;//栈
	initQueue(&que);//初始化队列
	initStack(&stack);//初始化栈
	Node * p = node->next;
	while(p){
		push(stack,p->data);//入栈
		enQueue(que,p->data);//入队
		p = p->next;
	}
	while(!isEmptyStack(stack) && !isEmptyQueue(que)){//判断是否队空 是否栈空
		if(popStock(stack) != popQue(que)){//出栈和出队比较 不相等则中心不对称
		 	return 0;
		}
	}
	return 1;
}

//将两个递增有序的单链表进行合并成递增有序，可以破坏A,B链表结构
Node * function4(Node * A,Node * B){
	Node * p = A->next;//p来跟踪A的最小值点
	Node * q = B->next;//q来跟踪B的最小值点
	Node * r;//r始终指向C的终端节点
	Node * C = A；//用A的头结点来做C的头结点
	C->next = NULL;//将C结点变成新的头结点
	free(B);//B的头结点已无用，释放掉
	r = C;//r指向C，因为此时头结点也是终端结点
	while(p!=NULL && q!=NULL){//当p，q都不为空时，选取最小者插入C的尾部
		//if  else中是尾插法思想
		if(p->data<=q->data){
			r->next = p;
			p = p->next;
			r = r->next;
		}else{
			r->next = q;
			q = q->next;
			r = r->next;
		}
	}
	r->next = NULL;//可写可不写
	//以下两个循环是将多余的结点链表连接在C的尾部
	while(p!=NULL){
		r->next = p;
	}
	while(q!=NULL){
		r->next = q;
	}
	return C；
}

//将两个递增有序的单链表进行合并成递增有序，不破坏A,B链表结构
Node * function5(Node * A, Node * B){
	Node * p = A->next;//p来跟踪A的最小值点
	Node * q = B->next;//q来跟踪B的最小值点
	Node * C = (Node *)malloc(sizeof(Node));//建立一个新的结点
	Node * pre = C;//将pre指向C的终端结点，此时头结点也是终端结点
	C->next = NULL;
	Node * r;
	while(p!=NULL && q!=NULL){
		r = (Node *)malloc(sizeof(Node);//建立一个新的结点
		if(p->data<=q->data){
			r->data = p->data;//将p结点值赋值给r的结点值，不破坏p的结构
			p = p->next;
		}else{
			r->data = q->data;//将q结点值赋值给r的结点值，不破坏q的结构
			q = q->next;
		}
		pre->next = r;//将r接连到C结点
		pre = pre->next;//将pre指向终端结点
	}
	r->next = NULL;
	while(p!=NULL){
		r = (Node *)malloc(sizeof(Node)
		r->data = p->data;
		p = p->next;
	}
	while(q!=NULL){
		r = (Node *)malloc(sizeof(Node)
		r->data = q->data;
		q = q->next;
	}
	return C;
}

//A链表中有但B链表中没有的元素；即A-B
Node * func6(Node * A, Node * B){
	Node * p = A->next;//p来指向A中的结点
	Node * q = B->next;//q来指向B中的结点
	Node * C = (Node *)malloc(sizeof(Node));
	Node * pre = C;
	C->next = NULL;
	while(p){
		q = B->next;
		while(q){
			if(p->data == q->data){
					goto L;//跳至L
			}
			q = q->next;
		}
		r = (Node *)malloc(sizeof(Node));
		r->data = p->data;
		pre->next = r;
		L:
		p=p->next;
	}
	r ->next = NULL;
	return C;
}