（1.2.1）链表的基本结构和常用操作

一、数据结构

（1） 顺序存储结构

           int a[10]

（2）链式存储结构

1. typedef struct node  
2. {  
3.    elemType element;
4.   Node *next;
5. }Node;  

二、链表的常见操作

（1）插入

1. //在第pos个位置前插入元素e  
2. int ListInsert(LNode *L,int pos,elemType e)  
3. {  
4.     LNode *p;  
5.     LNode *s=(LNode *)malloc(sizeof(LNode));  
6.     int j=0;  
7.     p=L;  
8.     //printf("在第%d个位置前插入元素%d\n",pos,e);  
9.     while(p&&j<pos-1)  
10.     {  
11.         p=p->Next;  
12.         ++j;  
13.     }  
14.     if(!p||j>pos-1) return ERROR;  
15.     s->data=e;  
16.     s->Next=p->Next;  
17.     p->Next=s;  
18.     return OK;  
19. }  

（2）删除

1. //删除第pos个位置上的元素，并返回其值  
2. int ListDelete(LNode *L,int pos)  
3. {  
4.     LNode *p=L;  
5.     LNode *q;  
6.     int j=0;  
7.     while(p->Next&&j<pos-1)  
8.     {  
9.         p=p->Next;  
10.         ++j;  
11.     }  
12.     if(j>pos-1||!p->Next)  
13.         return ERROR;  
14.     q=p->Next;  
15.     p->Next=q->Next;  
16.     //printf("删除的元素是:%d\n",q->data);  
17.     free(q);  
18.     return OK;  
19. }  

（3）查找

1. //查找函数  
2. int ListSearch(LNode *L,elemType e)  
3. {  
4.     LNode *p=L->Next;  //头指针指向第一个元素
5.     int cursor=1;  
6.     while(p->Next!=NULL)  
7.     {  
8.         if(p->data==e)  
9.         {  
10.             printf("找到，%d在第%d个位置\n",e,cursor);  
11.             return cursor;  
12.         }  
13.         p=p->Next;cursor++;  
14.     }//while  
15.     printf("没找到\n");  
16. }  

（4）创建

1. //头插建立链表  
2. void CreatList2(LNode *L,elemType e)  
3. {  
4.     LNode *s=(LNode*)malloc(sizeof(LNode));  
5.     s->data=e;  
6.     s->Next=L->Next;  
7.     L->Next=s;  
8. } 

1. //尾插建立链表  
2. void CreatList2(LNode *L,elemType e)  
3. {  
4.     LNode *s=(LNode*)malloc(sizeof(LNode));  
5.     s->data=e;  
6.     s->Next=NULL;  
7.     LNode *p=L;  
8.     while(p->Next!=NULL)  
9.     {  
10.         p=p->Next;  
11.     }  
12.     p->Next=s;  
13. } 

（5）验空

/* 6.检查单链表是否为空，若为空则返回１，否则返回０ */

int  isEmptyList(Node *pHead)

{

     if (pHead == NULL)

     {

         printf ( "isEmptyList函数执行，链表为空\n" );

         return  1;

     }

     printf ( "isEmptyList函数执行，链表非空\n" );

 

     return  0;

}

（6）长度计算

/* 5.返回单链表的长度 */

int  sizeList(Node *pHead)

{

     int  size = 0;

     while (pHead != NULL)

     {

         size++;         //遍历链表size大小比链表的实际长度小1

         pHead = pHead->next;

     }

     printf ( "sizeList函数执行，链表长度 %d \n" ,size);

     return  size;    //链表的实际长度

}

（7）反向逆置

1. //逆置单向链表  
2. //通过三个指针遍历  O（n）
3. LNode *ListInverse(LNode *L)  
4. {  
5.     if(L==NULL)  
6.     return NULL;  
7.     if(L->Next==NULL) return L;  
8.     LNode *pre=L->Next;  
9.     LNode *cur=pre->Next;  
10.     LNode *next=cur->Next;  
11.     pre->Next=NULL;  
12.     cur->Next=pre;  
13.     pre=cur;  
14.     cur=next;  
15.     while(cur!=NULL)  
16.     {  
17.         next=cur->Next;  
18.         cur->Next=pre;  
19.         pre=cur;  
20.         cur=next;  
21.     }  
22.     L->Next=pre;  
23.     return L;  
24. }  

//头插法遍历

public void ReversLinkList(LinkList<int> H)
{
Node<int> p = H.Next;
Node<int> q = new Node<int>();
H.Next = null;
while (p != null)
{
q = p;
p = p.Next;
q.Next = H.Next;
H.Next = q;
}
}

（7）正向与反向遍历

1. //正向遍历单链表  
2. void TraverseList(LNode *L)  
3. {  
4.     LNode *p;  
5.     p=L->Next;  
6.     //printf("线性表La=");  
7.     while(p)  
8.     {  
9.         printf("%d ",p->data);  
10.         p=p->Next;  
11.     }  
12.     printf("\n");  
13. }  
14. //逆向遍历单链表
15. void f(LNode *L){  
16. if(L->Next==Null){
17. cout<<L->data;
18. }
19. else{
20. f(L->next);
21. cout<<L->data;
22. }
23. }
24.