数据结构---单链表

数据结构---单链表

线性表的链式存储可以弥补顺序存储的一些缺点。链表由n个结构体（结点）组成，结构体里包含data用来存放数据元素，结构体型指针*next用来指向下一个节点，这样所有节点都被串起来形成了一个有序的链表，一般一个链表有一个头节点不存放数据，为了操作的统一和方便设立。

1.单链表线性存储结构 

typedef struct Node{
int data;
struct Node *next
}node,*list;

2.

单链表元素的创建（头插法、尾插法）

a)头插法算法思路：

①声明变量，建立一个带头结点的单链表；

②循环：

1）创建新节点；

2）赋值；

3）将新节点插入头节点与头节点的下一节点之间

 int CreatedListHead(list L,int n)
 {
    list p;
    int i;
 	
    L = (list)malloc(sizeof(node));
    L ->next = NULL;
    for(i=0;i<n;i++)
    {
       p = (list)malloc(sizeof(node));
       p->data = rand（）%100;
       p->next = L->next;
       L->next = p;
    }	
	
return ok;
 
}

b)尾插法算法思路：将新节点插入上一新节点与NULL之间

 int CreatedListTail(list L,int n)
 {
     list p,r;
     int i;
 	
     L = (list)malloc(sizeof(node));
     r = L;
     for(i=0;i<n;i++)
     {
         p = (list)malloc(sizeof(node));
         p->data = rand（）%100;
         r->next = p;
         r = p;
     }	
     r->next = NULL;
	
     return ok;
	
 }

3.获取表顶元素

int GetData(lsit L,int pos,int *e)
 {
     int i;
     list ptr;
 	
     ptr = L->next;
     i=1;
     while((p!=NULL)&&(i<pos))
     {
          p = p->next;
          i++;
      }
      if(p == NULL )
          return error;
      *e=p ->data； 
 

      return ok;
  }

4.插入算法

int Insertlist(list L,int pos,int e)
{
     list p,s;
     int i = 1;
     
     p = L->next;
     while((p != NULL)&&(i<pos))
     {
     	p = p->next;
     	i++;
     }
     if(p == NULL)
        return error;
     s = (list )malloc(sizeof(node));
     s->data = e;
     s->next = p->next;
     p->next = s;
     
     return ok;
}

5.删除算法

int Deletelist(list L,int pos,int *e)
{
	list p,q;
	int i=1;
	 
	 p = L;
	 while((p->next != NULL)&&(i<pos))
	 {
	 	p = p->next;
	 	i++;
	 }
	 q = p->next;
	 *e = q->data;
	 p->next = q->next;
	 free(q);
	 
	 return ok;
	 
}

6.整表删除

int ClearList(list L)
{
	list p,q;
	
	p = L->next;
	while(p != NULL)
	{
		q = p->next;
		free(p);
		p = q; 
	}
	L->next = NULL;
	
	return ok;
}

7.单链表和顺序存储相比的优缺点

①单链表查找的时间性能为O（n），不适合频繁查找，而顺序存储查找的时间性能为O（1）；

②单链表的插入删除时间性能为O（1），而循序存储为O（n）；

③顺序存储需要预分配空间，而单链表不受限制。