单链表操作

/*单链表的类型定义*/
typedef int DataType;
typedef struct node
{
	DataType data;
	struct node * next;
}LinkNode, *LinkList;

/*单链表的定位运算*/
LinkNode *Locate(LinkNode *L, int k)//????为什么此处是LinkNode *Locate()类型，表示什么意思
{
	LinkNode *p; int i;
	i= 1; p = L->next;							//初始时p指向第一个元素结点，i为计数器											
	while(p != NULL && i < k )					//通过链接指针逐个向后查找第k个结点
	{
		p = p->next;
		i++;
	}
	if(p != NULL && i == k)						//存在第k个元素且指针p指向该元素结点
		return p;
	return NULL;								//第k个元素不存在
};

/*单链表的插入运算*/
int Insert(LinkNode *L, int k, int elem)
{
	LinkNode *p, *q;
	if(k==1)
		p=L;									//元素elem插入在第1个元素位置
	else p = Locate(L, k-1);					//查找表中的第k-1个元素
	if(p==NULL)
		return 0;								//表中不存在第k-1个元素，插入失败
	q = new LinkNode;							//创建插入结点
	if(q == NULL)
	{
		printf("存储分配失败！\n");
		return 0;
	}
	q->data = http://www.mamicode.com/elem;								//元素elem插入第k-1个元素之后>

//指向结点的指针是结构体指针类型，链表是结构体指针类型？？？？
#include<stdio.h>								//带头结点的链表操作
#include<stdlib.h>
#define ERROR 0
#define OK 1
#define OVERFLOW -1
typedef int ElemType;
typedef struct LNode
{	
    ElemType data;
    struct LNode *next;							//next指向了一个和它本身数据类型一样的下一个结点						
}LNode,*LinkList;								//LNode等价于struct LNode;	LinkList等价于struct LNode *						

void GetElem(LinkList L,int i,ElemType *e)		//查找第i个元素并返回，函数是无返回值类型
{    
    LNode *p;									//ElemType *e用于存储返回的值，LNode *p等价于LinkList p
    int j=1;
    p=L->next;									//p=L->next,此时p指向首结点
    while(p&&j<i)								//如果结点为空就停止循环
    {
        p=p->next;++j;							
    }
    if(!p||j>i)printf("不存在,查找错误\n");
    else
    *e=p->data;    
}
void ListInsert_L(LinkList *L,int i,ElemType e)//插入元素。
{
    LinkList p=*L,s=NULL;														//LinkList *L?????LinkList p=*L
    int j=0;
    while(p&&j<i-1){p=p->next;++j;}
    if(!p||j>i-1)printf("插入位置错误\n");    
    s=(LinkList)malloc(sizeof(LNode));
    s->data=http://www.mamicode.com/e;"删除位置错误");
    q=p->next;p->next=q->next;
    *e=q->data;
    free(q);    
}
void CreatList(LinkList *L,int n)//建立链表 输入n个ElemType类型的数
{
    LinkList p=NULL,q=NULL;
    int i;
    ElemType m;
    (*L)=(LinkList)malloc(sizeof(LNode));
    (*L)->next=NULL;
    p=(LinkList)malloc(sizeof(LNode));
    p->next=NULL;
    q=p;
    scanf("%d",&m);
    p->data=http://www.mamicode.com/m;"%d",&m);
        p->data=http://www.mamicode.com/m;"%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
int main()
{
    LinkList L=NULL;
    int i,p=1,m;
    ElemType e;
    printf("请输入10个元素:\n");
    CreatList(&L,10);
    printf("原来的10个元素为:");
    DisList(L);
    while(p)
    {
        printf("1)插入2)删除3)查找4)显示操作结果0)退出\n");
        scanf("%d",&m);
        switch(m)
        {
        case 1:printf("请分别输入要插入元素的位置及与元素值: ");
            scanf("%d%d",&i,&e);ListInsert_L(&L,i,e);break;
        case 2:printf("请分别输入要删除元素的位置: ");
            scanf("%d",&i);ListDelet_L(&L,i,&e);printf("删除的元素值为:%d\n",e);break;
        case 3:printf("请分别输入要查找的元素的位置: ");
            scanf("%d",&i);GetElem(L,i,&e);printf("该位置的元素为:%d\n",e);break;
        case 4:DisList(L);break;
        case 0:p=0;break;
        }
    }

    return 0;
}

#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"

/*尾插法建立链表，链表元素顺序和数组一致*/
LinkList  CreatList2(LinkList &L)
{
    //从表头到表尾正向建立单链表L,每次均在表尾插入元素
    int x;  // 设元素类型为整型
    L=(LinkList)malloc(sizeof(LNode));
    LNode *s, *r=L;  //r 为表尾指针
    scanf ("%d", &x);  //输入结点的值

    while (x!=9999) 
	{  //输入 9999 表示结束
        s=(LNode *)malloc(sizeof(LNode));
        s->data=http://www.mamicode.com/x;"%d", &x);
    }

    r->next = NULL;  //尾结点指针置空
    return L;
}

/*头插法建立链表，链表元素顺序和数组相反*/
LinkList  CreatList1(LinkList &L)
{
    //从表尾到表头逆向建立单链表L，每次均在头结点之后插入元素
    LNode *s;int x;
    L=(LinkList)malloc(sizeof(LNode));  //创建头结点
    L->next=NULL;  //初始为空链表
    scanf("%d", &x);  //输入结点的值

    while(x!=9999)
	{  //输入 9999 表示结束
        s=(LNode*)malloc(sizeof(LNode) );  //创建新结点
        s->data=http://www.mamicode.com/x;"%d", &x);
    }  //while 结束

    return L;
}  
int main (void)
{
	return 0;
}

/*The Data Structure of Link List*/  
typedef int DataType;  
typedef struct LinkNode   
{  
    DataType         data;  
    struct LinkNode *next;  
}*LinkList; 
 
/*尾插法建立链表，链表元素顺序和数组一致*/  
void CreateList(LinkList &L,DataType A[],int n)  
{  
    LinkNode *rear;  
    L = rear = new LinkNode;  
    for(int i=0; i<n; ++i)  
    {  
        rear->next =  new LinkNode;  
        rear       =  rear->next;  
        rear->data = http://www.mamicode.com/A[i];  " ";    }  
    cout<<endl;  
}  

*链表的排序算法*/  
void InsertSortList(LinkList &L)  
{  
    LinkNode *p     = L->next;        /*指向 待插入  结点 */  
    LinkNode *nextp = NULL;           /*指向 p的后继 结点 */  
  
    LinkNode *q     = L;              /*指向有序链表的头部*/  
    q->next         = NULL;              
  
    while( p != NULL )  
    {  
        q = L;  
        while(q->next!=NULL && p->data >= q->next->data) /*寻找插入位置，循环停止时，p应插入到q的后面*/  
        {   q = q->next;     }  
  
        nextp = p->next;    
        p->next = q->next;    /* p 的后继应是 q */  
        q->next = p;  
        p = nextp;    
    }  
}  

/*链表查找算法*/  
LinkNode *SearchList(LinkList &L,DataType x)  
{  
    LinkNode *p = L->next;  
    while( p!=NULL && p->data!=x )  
    {   p = p->next; }  
    return p;     
}  


/*链表销毁算法*/  
void DestroyList(LinkList &L)  
{  
    if(L->next==NULL)  
    {     
        cout<<"delete"<<L->data<<endl;  
        delete L;   }  
    else  
    {     
        DestroyList(L->next);  
        cout<<"delete"<<L->data<<endl;  
        delete L;     
    }  
}