再回首，数据结构——线性表、链表上的常见算法

       最近在复习数据结构，顺便看看大一的时候写的代码，看完之后比当初有了更加深刻的体会。
 
      希望这些能提供给初学者一些参考。

//1.编写算法实现线性表就地逆置的操作
void InverseList (SeqList l)
{
for (i = 0; i <= (l.length-1)/2; i++)
{
l.elem[i] <-> l.elem[l.length-1-i];
}
}
//2.从顺序表中删除自第i个元素开始的k个元素
void DeleteList(SeqList l, int i, int k)
{
if (i < 0 || i > l.length-1 || k < 0)
{
printf ("Error!");
return;
}
if (i+k <= l.length)
{
for (j = i+k; j < l.length; j++)
l.elem[j-k] = l.elem[j];
l.length -= k;
}
else
l.length = i;
}

//3若已建立一个带头结点的单链表，h为指向头结点的指针
//且链表中存放的数据按从小到大的顺序排列。
//编写函数实现算法，把x的值插入链表中，插入后链表保持有序
void InsertList(LinkList h, ElementType x)
{
if (NULL == h->next)
{
p = (LinkList)malloc(sizeof(LinkNode));
p->data = x;
p->next = NULL;
h->next = p;
}
pre = h->next;
p = h;
while (pre->next != NULL && pre->data < x)
{
p = pre;
pre = pre->next;
}
if (NULL == pre->next && pre->data < x)
{
q = (LinkList)malloc(sizeof(LinkNode));
q->data = x;
q->next = NULL;
pre->next = q;
}
else //NULL != pre->next && pre->data > x || NULL == pre->next && pre->data >= x
{
q = (LinkList)malloc(sizeof(LinkNode));
q->data = x;
q->next = pre;
p->next = q;
}
}

//4.假设在长度大于1的单循环链表中，既无头结点，也无头指针,
//P为指向该链表中某个节点的指针，
//编写算法，实现删除该节点的前驱节点
void DeleteLinkList(LinkList p)
{
pre = p->next;
while (pre->next != p)
pre = pre->next;
pp = pre->next;
pre->next = pre->next->next;
free(pp);
}

//5.设h为指向单链表头结点的指针，该链表中的值乱序
//设计算法，实现删除链表中值相同的节点，使之只保留一个
void DeleteSelectLinkList(LinkList h)
{
p = h->next;
if (!p)
return;
x = p->data;
while (p->next)
if (x != p->next->data)
{
x = p->next->data;
p = p->next;
}
else
{
q = p->next;
p->next = p->next->next;
free(q);
}
}

/*6.删除带头结点的单链表h（指向头结点）中值为x的结点的前驱结点*/
void DeleteLinkList(LinkList h, ElementType x)
{
if (!(h->next))
return;
if (!(h->next->next))
return;
pre = h->next->next;
p = h;
while (pre->next && pre->data != x)
{
pre = pre->next;
p = p->next;
}
if (x == pre->data)
{
q = p->next;
p->next = pre;
free(q);
}
}

//注意理解
/*7.la,lb分别为表示集合A,B的带头结点的单链表的头指针，A-B(两个集合的差)由la链表返回*/
LinkList Subtraction (LinkList la, LinkList lb)
{
LinkList pre = la->next;
while (pre)
{
while (lb->next)
{
if (pre->data == lb->next->data)
{
p = pre;
pre = pre->next;
free(p);
}
lb = lb->next;
}
pre = pre->next;
}
return la;
}

/*8_1.集合A,B,C对应的顺序递增表为la,lb,lc，C=A∩B由lc表示*/
SeqList Intersection (SeqList la, SeqList lb)
{
lc.length = 0;
for (i = 0; i < la.length; i++)
{
for (j = 0; j < lb.length && la.elem[i] != lb.elem[j]; j++)
;
if (j < lb.length)
{
lc.elem[length++] = la.elem[i];
}
}
return lc;
}

/*8_2.la,lb,lc分别为表示集合A,B,C的带头结点的递增有序的单链表的头指针，
C=A∩B由lc链表返回*/
//改为有修改后的lc链表返回

LinkList Intersection (LinkList la, LinkList lb)
{
pre = la->next;
while (pre)
{
while (lb->next && pre->data != lb->data)
lb = lb->next;
if (lb->next)
{
la->next = pre;
}
pre = pre->next;
}
return la;
}
/*9删除带头结点的无序表中，元素值大于min且小于max的节点*/
void Delete (LinkList h, ElementType min, ElementType max)
{
h = h->next;
while (h)
{
if (h->data > min && h->data < max)
{
q = h;
h = h->next;
free(q);
}
h = h->next;
}
}

/*10.h为带头结点的单链表的头指针，该表中含有两类字符数据元素：字母与数字，
拆分h为两条带头结点的单项循环链表*ph1、*ph2，其中*ph1链中存放字母，
*ph2链中存放数字*/
void Separation (LinkList h, LinkList h1, LinkList h2)
{
if (!(h->next))
return;
p = h;
h = h->next;
free(p);

h1 = (LinkList)malloc(sizeof(LinkNode));

h2 = (LinkList)malloc(sizeof(LinkNode));
}