单链表的创建及操作

1、单链表的结构体算法：

typedef char elemtype;
typedef struct node
{
elemtype data;           //数据域
struct node *next;       //指针域
}Lnode,*linklist;            //Lnode为结点类型，linklist为指向结点的指针类型

2、建立单链表

      （1）头插法（从表尾到表头逆向建立）

                    算法思路：

                     （1）首先建立一个头结点h，并使头结点的指针域为空

                     （2）读入值

                     （3）建立一个新结点p

                     （4）将ch赋给p的数据域

                     （5）分别改变   新结点p的指针域   和  头结点h的指针域，使p成为h的直接后继

                     （6）重复（2）到（5），知道不满足循环条件为止

Lnode *creat()

{

elemtype ch;

Lnode *h, *p;

h = (Lnode *)malloc(sizeof(Lnode));   //建立头结点h

h->next = NULL;                       //使头结点的指针域为空

while ((ch=getchar())!='\n')

{

p = (Lnode *)malloc(sizeof(Lnode)); //建立新结点p

p->data = ch;                       //对p的数据域进行赋值 ch

p->next = h->next;                  //改变指针的状况

h->next = p;                        //h的直接后继是p

}

return h;

}

      （2）尾插法（从表头到表尾建立）

Lnode *creat()

{

elemtype ch;

Lnode *h, *p, *t;

h = (Lnode *)malloc((sizeof(Lnode)));

h->next = NULL;

t = h;

while ((ch=getchar())!='\n')

{

p = (Lnode *)malloc(sizeof(Lnode));

p->data = ch;

p->next = NULL;

t->next = p;

t = p;                                      //t始终指向最后一个元素

}

return h;

}

3、求表长（结点个数）

           算法思路：

             （1）设置  一个指针变量p  和 一个整型变量i（做计数器）

             （2）让     p指向第一个结点，并i=0

             （3）指针p在单链表中后移，且i增加1

             （4）当   p=NULL时，单链表结束，计数完毕，i即表长

int lenth(Lnode *h)       //头指针
{
Lnode *p;
int i = 0;
p = h->next;          //p指向第一个结点

while (p)             //循环访问
{
i++;
p = p->next;      //p指针后移
}

return i;
}

4、插入

           p结点之后插入值为x的新结点s

           插入前后指针变化图解：

           算法思路：

            （1）生成一个新结点s

            （2）将x赋给新结点s的数据域

            （3）将新结点插入单链表中

           关键语句：

               s->next=p->next;

               p->next=s;

void insert(Lnode *p, elemtype x)            //将值为x的结点插入p之后
{
Lnode *s;
s = (Lnode *)malloc(sizeof(Lnode));

s->data = x;

s->next = p->next;                      //将新结点插入单链表中
p->next = s;
}

            拓展：在单链表中第i个元素之前插入一个元素的算法

int insert(Lnode *h, int i, elemtype x)

{

Lnode *p, *s;

int j = 0;

p = h;

while (p&&j<i-1)                //寻找第i-1号结点

{

p = p->next;

j++;

}

if (p)

{

p = (Lnode *)malloc(sizeof(Lnode));

s->data = x;

s->next = p->next;          //将s插入

p->next = s;

return 1;

}

else

{

return 0;

}

}

5、删除（删除p的后继结点q）

           

                算法思路：

                  （1）将q指向p结点的直接后继

                  （2）改变指针链接，把   q结点的直接后继作为p结点的直接后继

                  （3）删除q结点

                  （4）释放q结点空间

               关键语句：

                   q=p->next;

                   p->nextt=p->next;

void dele(Lnode *p)
{
Lnode *q;
if (p->next != NULL)
{
q = p->next;            //q为p的直接后继
p->next = q->next;      //删除q


free(q);                //释放q
}
}

6、查找

           算法思路：

             （1）从第一个结点开始遍历，将数据域与x比较

             （2）找到并返回该结点指针

Lnode *search(Lnode *h, elemtype x)
{
Lnode * p;

p = h->next;                 //从第一个结点开始


while (p&&p->data!=x)
{
p = p->next;             //没找到，指针向后移
}


return p;
}

7、取元素

          算法思路：

            （1）p从第一个结点出发，定义j=1

            （2）移动指针p，累积j 

            （3）查找j=i的结点

            （4）重复（2）到（3）直到p为空或指向第i个元素

Lnode *get(Lnode *h,int i)
{
Lnode *p;
int j=1;

p = h->next;

while (p&&j<i)
{
p = p->next;                 //移动指针p
j++;
}

if (i == j)
return p;                  //返回第i个元素的存储地址
else
{
return NULL;
}
}