链表-调通-qazwsx$

初学者："完全"已经调好了。
运行结果：

qazwsx$
全部元素为:qazwsx
一共有:6个元素
查找节点的内容,元素序号为:3
3:z
查找节点的位置，内容为:z
z:3
删除节点，节点的位置:3
删除内容为：z
剩余元素为:qawsx
在i插入e:3z
全部元素为:qazwsx
排序后元素为:aqswxz
新链表q:edc$
q合并p后:全部元素为:aqswxzedc
Press any key to continue

#include "stdio.h"
#include "malloc.h"
#include "string.h"

typedef struct Node
{ 
	char data;
	struct Node * next;
}Node, *LinkList;/* LinkList为结构指针类型*/

//创建一个链表
LinkList CreateFromHead();//头插
LinkList CreateFromTail(); //尾插/*将新增的字符追加到链表的末尾*/

int ListLength(LinkList L); //L为带头结点的链表求长度
//查找
Node * Get2(LinkList L, int i);//按元素序号查找
Node *Locate2(LinkList L,char key);//按元素值查找
void Get1(LinkList L, int i);//按元素序号查找
void Locate1(LinkList L,char key);//按元素值查找
//更改

//删除
void DelList(LinkList L,int i,char *e);//删除结点 序号
//插入
void InsList(LinkList L,int i,char e);//插入结点
//合并
LinkList Merge(LinkList LA, LinkList LB);
//排序
void sore(LinkList head);
//打印
void printList(LinkList L);

//合并 有序
LinkList MergeLinkList(LinkList LA, LinkList LB);//两个从小到大有序链表合并成为有序链表 LC

int main()
{   /* LinkList为结构指针类型*/
	Node *p, *q;
	char c, e;
	int i;

	p = (Node*)malloc(sizeof(Node));
	p = CreateFromTail();
/*
	printf("全部元素为:");
	printList(p);
	printf("\n一共有:%d个元素\n", ListLength(p));

//查找
	printf("查找节点的内容,元素序号为:");
	scanf("%d", &i);
    Get1(p, i);
	printf("查找节点的位置，内容为:");
	scanf(" %c", &c);
	Locate1(p,c);
//删除
	printf("删除节点，节点的位置:");
	scanf("%d", &i);
	DelList(p,i,&e);
	printf("删除内容为：%c\n", e);
	printf("剩余元素为:");
	printList(p);
	printf("\n");
//插入
	printf("在i插入e:");
	scanf("%d%c", &i, &e);
    InsList(p,i,e);
	printf("全部元素为:");
	printList(p);
	printf("\n");

//排序
	sore(p);
	printf("排序后元素为:");
	printList(p);
	printf("\n");
*/
	printf("新链表q:");
	q = (Node*)malloc(sizeof(Node));
	q = CreateFromTail();
/*
//合并
	printf("q合并p后:");
	//q 为NULL  !!
	p = Merge(p, q);

	printf("全部元素为:");
	printList(p);
	printf("\n");

//有序合并
	p = MergeLinkList(q, p);
	printf("合并后全部元素为:");//(原来的两个链表本来就有序,p长度短)
	printList(p);
	printf("\n");
*/

	return 0;
}





//头插
LinkList CreateFromHead()
{
	int flag=1; 
	LinkList L;
	Node *s;
	char c;
	L=(LinkList)malloc(sizeof(Node));
	L->next=NULL;

	while(flag) //因为flag是1，所以进入循环体执行
	{
		scanf("%c", &c); 
		//c = getchar(); //假设用户输入ab$,首先读入‘a’
		if(c !='$') //‘a’不等于‘$’,因此判断成立
		{	
			s=(Node*)malloc(sizeof(Node)); 
			s->data=c;
			s->next=L->next; 
			L->next=s;  
		}
	}
	return L;
}	
//尾插
LinkList CreateFromTail() /*将新增的字符追加到链表的末尾*/
{ 
	char c;
	LinkList L;
	Node *r, *s;
	L=(LinkList)malloc(sizeof(Node));
	L->next=NULL;
	r=L; /*r指针始终动态指向链表的当前表尾*/
	fflush(stdin);
	c=getchar();
	while(c!='$')/*输入“$”时flag为0，建表结束*/
	{ 	
		
		s=(LinkList)malloc(sizeof(Node)); 
		s->data=c;
		r->next=s; 
		r=s;
		c=getchar();
	}
	r->next=NULL; 
	return L;
}
//按元素序号查找
void Get1(LinkList L, int i)
{ //假设开始的情况是：
	Node *p;
	int j=0;
	p=L;
	while((p->next!=NULL)&&(j<i))		
	{ 
		p=p->next;
		j++; 							
	}
	// p->next是NULL
	if(i==j)	
	{
		printf("%d:%c\n", i,p->data);
	}
	else //不满足判断条件，因此执行else部分
		printf("未找到");
}

//按元素值查找
void Locate1(LinkList L,char key)
{ 
	int i = 1;
	Node *p;
	p=L->next;
	while(p !=NULL)
	{
		if(p->data != key)	
		{
			i++;
			p=p->next;  
		}
		else 
		{
			printf("%c:%d\n", key, i);
			break;
		}
	}
}


//按元素序号查找
Node *Get2(LinkList L, int i)
{ //假设开始的情况是：
	Node *p;
	int j=0;
	p=L;
	while((p->next!=NULL)&&(j<i))		
	{ //满足条件，因此进入循环体执行
		p=p->next;
		j++; 							
	}
	// p->next是NULL，不满足条件，因此不再执行循环体
	if(i==j)	
	{
		printf("%d:%c\n", i,p->data);
		return p;
	}
	else //不满足判断条件，因此执行else部分
		return NULL;
}

//按元素值查找
Node *Locate2(LinkList L,char key)
{ 
	int i = 1;
	Node *p;
	p=L->next;
	while(p !=NULL)
	{
		if(p->data != key)	
		{
			i++;
			p=p->next;  
		}
		else 
		{
			printf("%c:%d\n", key, i);
			break;
		}
	}
	return p;
}

//删除结点
void DelList(LinkList L,int i,char *e)
{ 
	Node *p,*r; 
	int k =0;
	p=L; 
	while(p->next != NULL &&  k < i-1) 
	{ 
		p=p->next; 
		k=k+1; 
	}
	if(k!=i-1)  
	{
		printf("无此节点");
	}
	else
	{
		r=p->next; 
		p->next=p->next->next;			
		*e=r->data;//通过变量e返回删掉的元素值
		free(r);		//r这个变量及值都没有变动，但是不能再使用r指向的那个空间（因为已经释放）。
	}
}
//插入结点
void InsList(LinkList L,int i,char e)
{ 
	Node *pre,*s;
	int k=0;
	pre=L; 
	while(pre!=NULL&&k<i-1) /*先找到第i-1个数据元素的存储位置,使指针pre指向它*/ 
	{ 
		pre=pre->next;	
		k=k+1;  
	}
	if(k!=i-1)   
	{ 
		printf("插入位置不合理！"); 
		return; 
	}
	s=(Node*)malloc(sizeof(Node));/*为e申请一个新的结点*/
	s->data=e;     /*将待插入结点的值e赋给s的数据域*/
	s->next=pre->next; 
	pre->next=s;
} 



//求长度
int ListLength(LinkList L) /*L为带头结点的链表*/
{  
	Node *p; 
 	int j=0; /*用来存放链表的长度*/
	p=L->next;	
 	while(p!=NULL)
 	{	
		p=p->next; 
		j++; 
	}
 	return j;
}


//合并
LinkList Merge(LinkList LA, LinkList LB)
{
	LinkList p;
	p = LA->next;
	while(p->next)
		p = p->next;
	p->next = LB->next;
	free(LB);
	return LA;
}
//两个从小到大有序链表合并成为有序链表 LC
LinkList MergeLinkList(LinkList LA, LinkList LB)
{   
	Node *pa,*pb;
	LinkList LC;
	LinkList r;

	pa=LA->next;
	pb=LB->next;
	LC=LA;
	LC->next=NULL;
	r=LC;
	
	while(pa!=NULL && pb!=NULL) 
	{
		if(pa->data <= pb->data)
		{
			r->next=pa;
			r=pa;
			pa=pa->next;
		}
		else
		{
			r->next=pb;
			r=pb;
			pb=pb->next;
		}
	}
	if(pa != NULL) 
		r->next=pa;
		//return NULL;
	else//
		r->next=pb;
	free(LB);
	return (LC);
}
/*
bcd$
新链表q:aef$
合并后全部元素为:abcdef
bc$
新链表q:adef$
合并后全部元素为:abcdef
acdg$
新链表q:be$
合并后全部元素为:abcdeg
  */
//排序
void sore(LinkList head)
{
	LinkList pre,cur,next,end, temp;
	end = NULL;
	while(head->next != end)
	{
		//初始化三个指针 ; 判断是否到达结束位置 ; 三个指针集体后移
		for(pre=head,cur=pre->next,next=cur->next;  next!=end;  pre=pre->next,cur=cur->next,next=next->next)
		{
			if(cur->data > next->data) //从小到大
			{
				pre->next=next;
				cur->next=next->next;
				next->next=cur;
				//此时next变前一项，cur变后一项  交换next cur
				temp=cur; 
				cur=next; 
				next=temp;
			}
		}
		//一轮循环结束 最后一项已经排好 end提前一项 (冒泡原理)
		end = cur;
	}
}

void printList(LinkList L)
{
	Node *p = L;
	while(p->next)
	{
		p = p->next;
		if(p->data >= 'a' || p->data <='z')
			printf("%c", p->data);
		//printf(" ", p->data);
	}
}