《数据结构》 单链表常用操作代码集合

//单链表存储结构
typedef struct Node //结点类型定义
{
ElemType data;
struct Node *next; //LinkList为结构体指针类型
} Node, *LinkList;
//初始化单链表
InitList(LinkList *L)
{
*L = (LinkList)malloc(sizeof(Node)); //建立头结点
(*L)->next = NULL; //建立空的单链表L
}
//头插法
void CreateFromHead(LinkList L)
/*L是带头结点的空链表头指针，通过键盘输入表中元素值，利用头插法建立单链表L*/
{
Node *s；
char c;

while((c = getchar()) != '$') /*设$元素为输入结束字符*/
{
s = (Node*)malloc(sizeof(Node));
s->data = c;
s->next = L->next;
L->next = s;
}
}
//尾插法
void CreateFromTail()
/*L未初始化，无头结点，通过键盘输入表中元素值，利用尾插法建立单链表L*/
{
LinkList L;
Node *r, *s;
char c;

L = (Node *)malloc(sizeof(Node));
L->next = NULL; //以上包含L的初始化

r = L; //r指针动态指向当前表尾，以便于做尾插入，其初值指向头结点
while((c = getchar()) != '$')
{
s = (Node*)malloc(sizeof(Node));
s->data = c;
r->next = s;
r = s;
}
r->next = NULL;
return L;
}
//在单链表中查找第i个结点
Node * Get(LinkList L, int i)
/*在带头节点的单链表L中查找第i个结点，若找到(1<=i<=n),则返回该结点的存储位置，否则返回NULL*/
{
int j;
Node *p;
if(i <= 0)    return NULL;
p = L; j = 0; //从头结点开始扫描
while((p->next != NULL) && j < i)
{
p = p->next; //扫描下一结点
j++; //已扫描结点计数器
}
if(i==j)    return p; //找不到，i>n
else return NULL;
}
//在单链表L中查找值为key的结点
Node * Locate(LinkList, ElemType key)
/*在带头结点的单链表L中查找其结点值等于key的第一个结点，若找到则返回该结点的位置p，否则返回NULL*/
{
Node p;
p = L->next;
while(p != NULL)
if(p->data != key)    p = p->next;
else    break;

return p;
}
//求单链表的长度
int ListLength(LinkList)
{
Node *p;
p = L->next;
j = 0;
while(p != NULL)
{
p = p->next;
j++;
}
return j;
}
//单链表的插入操作
#define OK 1
#define ERROR 0
void InsList(LinkList, ElemType)
/*在带头结点的单链表L中第i个位置插入值为e的新结点*/
{
Node *pre, *s;
int k;
if(i <= 0) return ERROR;
pre = L; k = 0;
while(pre != NULL && k < i-1)
{
pre = pre->next;
k++;
}
if(pre == NULL || k > i-1)
{
printf("插入位置不合理!");
return ERROR;
}
s = (Node *)malloc(sizeof(Node));
s->data = a;
s->next = pre->next;
pre->next;
pre->next = s;

return OK;
}
//单链表删除操作
int DelList(LinkList L; int i; ElemType *e)
/*在带头结点的单链表中删除第i个元素，并将删除的元素保存在*e中*/
{
Node *pre, *r;
int k;
pre = L; k = 0;
while(pre->next != NULL && k < i-1)
/*寻找被删除的结点i的前驱结点i-1使pre指向它*/
{
pre = pre->next;
k++;
}
if(pre->next == NULL || k > i-1)
/*while循环是因为p->next=NULL或i<1而跳出的，因为pre->next为空*.没有找到合法的前驱位置，说明删除位置不合法*/
{
printf("删除结点位置的i不合理");
return ERROR;
}
r = pre->next; //pre指向i-1 r指向i
pre->next = r->next; //使i-1的next指向i+1结点
*e = r->data;
free(r);

return OK;
}
//合并两个有序的单链表
LinkList MergeLinkList(LinkList LA, LinkList LB)
/*将递增有序的单链表LA和LB合并成一个递增有序的单链表LC*/
{
Node *pa, *pb;
LinkList LC;
/*将LC初始置空表。pa和pb分别指向两个单链表LA和LB中的第一个结点，r初值为LC且r始终指向LC的表尾*/
pa = LA->next;
pb = LB->next;
LC = LA;
LC->next = NULL; r = LC;
/*当两个表中均为处理完时，比较选择将较小值存入新表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)    r->next = pa;
else    r->next = pb;
}
free(LB);

return(LC);
}
/*删除有序单链表中值重复的结点——Solo*/
int Delsame(LinkList L)
{
Node *pre,*p,*r;
pre = L->next;
p = pre->next;

while(p->next != NULL)
{
if(p->data = pre->data)
{r=p; p=p->next; pre->next = p; free(r)}
else
{pre = p; p = p->next; }
}
return OK;
}