记录一下比较完整的链式线性表的函数操作集
语言C++ 环境codeblocks17.01
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#define Status int
#define ElemType int
using namespace std;
typedef struct LNode //struct link = Link
{
ElemType data;
struct LNode *next;
} LNode,*LinkList;
Status InitList (LinkList &L)
{/*初始化*/
L = new LNode;
L->next = NULL;
return 1;
}
Status ListInsert(LinkList &L, int i,ElemType e)
{/*链表插入元素e*/
LNode *p = L;
int j=0;
while(p && (j<i-1))
{
p = p->next;
j++;
}
if(!p||j>i-1)
return -1;
LNode *s;
s = new LNode;
s->data = e;
s->next = p->next; // s->next = NULL; or s->next = p->next
p->next = s;
return 1;
}
Status ListTraverse(LinkList &L)
{/*链表遍历输出*/
LNode *p = L;
p = p->next;
while(p)
{
printf("%d ",p->data);
p = p->next;
}
return 1;
}
Status ListReverse(LinkList &L)
{/*链表逆序*/
if(L==NULL||L->next==NULL)
return -1;
LNode* pNext = L->next->next;
LNode* pNode = L->next;
LNode* pTemp = L->next->next->next;
LNode* pFirst = L->next; // 记录原链表的第一个节点,即逆转后的tail node
// 每次处理两个节点
while(pNode->next && pNext)
{
pNext->next = pNode; // 迭代逆转的两个节点是 pnext pnode
pNode = pNext;
pNext = pTemp;
if(pTemp!=NULL)
pTemp = pTemp->next;
else
;
}
L->next = pNode; // 头节点指向新的第一个元素节点
pFirst->next = NULL; // tail node = NULL
return 1;
}
Status ListSort_1(LinkList &L)
{/*使用sort函数时间复杂为(O(nlogn))*/
int i=0;
LNode* h = L;
if(h->next==NULL||h==NULL)
return -1;
ElemType* temp = new ElemType[100]; //变量链表存放在数组中
for(i=0, h=h->next; h; h=h->next,i++)
{
temp[i] = h->data;
}
sort(temp, temp+i);
h = L;
// 数据复制回到list
for(i=0, h=h->next; h; h=h->next,i++)
{
h->data = temp[i];
}
return 1;
}
Status ListSort_2(LinkList &L)
{/*线性表的排序,采用冒泡排序,直接遍历链表*/
LNode* h = L;
//作为一个临时量
LNode* p;
LNode* p1;
//如果链表为空直接返回
if (h->next==NULL||h==NULL)
return-1;
for (p = L; p->next!=NULL ; p = p->next)
{
for (p1 = p; p1->next!=NULL ; p1 = p1->next)
{
//如果前面的那个比后面的那个大,就交换它们之间的是数据域
if (p1->data > p1->next->data)
{
ElemType temp = p->data;
p->data = p1->next->data;
p1->next->data = temp;
}
}
}
return 1;
}
Status ListDeleteEvenNum(LinkList &L)
{/*删除所有偶数元素节点*/
if (L->next==NULL||L==NULL)
return-1;
LNode* p = L;
LNode* pre; // 前驱结点
pre = p;
p = p->next;
while(p)
{
if(p->data%2 == 0)
{
pre->next = p->next;
free(p);
p = pre->next;
continue;
}
p = p->next;
pre = pre->next;
}
return 1;
}
Status MergeList(LinkList &L1,LinkList &L2)
{/*链接两个链表*/
if((L1->next==NULL||L1==NULL)&&(L2->next==NULL||L2==NULL)) //两个都是空链表
return -1;
LNode* p1;
p1 = L1->next;
while(p1->next)
{
p1 = p1->next;
}
p1->next = L2->next; // 链接L1和L2
return 1;
}
Status ListSplitEvenOdd(LinkList &L1, LinkList &L2)
{/*按照奇偶拆分L1 结果是L1存放奇数 L2存放偶数*/
if (L1->next==NULL||L1==NULL)
return-1;
InitList(L2);
int i=1;
LNode* p = L1;
LNode *pre;
pre = p;
p = L1->next;
while(p)
{
if(p->data%2 == 0)
{ // 将L1中的偶数节点插入到L2中
pre->next = p->next;
ListInsert(L2,i,p->data);
i++;
free(p);
p = pre->next;
continue;
}
p = p->next;
pre = pre->next;
}
return 1;
}
Status DestroyList(LinkList &L)
{/*销毁链表*/
if(L==NULL)
return -1;
LNode* p;
// 从L的头节点开始删除
while(L)
{
p = L;
L = L->next;
free(p);
}
return 1;
// L的头节点已经不在了
}
Status ClearList(LinkList &L)
{/*清空链表*/
if(L==NULL)
return -1;
LNode* p,* l;
// 从L的首元节开始删除
l = L->next;
while(l)
{
p = l;
l = l->next;
delete p;
}
L->next = NULL; //??????????????????????????????????????
return 1;
// L的头节点还在
}
Status ListEmpty(LinkList &L)
{/*判断链表为空返回1 否则返回0*/
if(L==NULL)
return -1;
else
{
if(L->next==NULL) // 判断链表是否为空
return 1;
else
return 0;
}
}
Status GetElem(LinkList &L,int i ,ElemType &e)
{/*取得L中第i个元素*/
LNode *p = L->next;
int j=1;
while(p && j<i)
{
p = p->next;
j++;
}
if(!p || j<i || i<1) // 如果p为空或者目标元素不在范围内,返回错误-1
return -1;
e = p->data;
return 1;
}
Status GetElemNode(LinkList &L , ElemType e, LNode* &pe)
{/*取得L中第1个等于e的元素的指针 , 取得返回 1,未找到返回 0*/
if(L==NULL)
return -1;
LNode* p = L->next;
while(p)
{
if(p->data == e)
{
pe = p;
return 1;
}
p = p->next;
}
return 0;
}
int ListLenght(LinkList &L)
{/*返回链表长度*/
if(L==NULL)
return -1;
LNode* p = L;
int len = 0;
p = p->next;
while (p)
{
p = p->next;
len++;
}
return len;
}
int compare(ElemType a , ElemType b)
{/*判断ab的关系,返回一个int来表示ab关系*/
/* -1 a<b 1 a>b 0 a=b */
if(a==b)
return 0;
else if (a>b)
return 1;
else
return -1;
}
int LocateElem(LinkList &L ,ElemType e,int compare(ElemType , ElemType), int mod)
{/*通过compare()函数 判定e和L中第一个符合mod(compare中ab的关系判定返回值0,1,-1)的元素的位置*/
if(L==NULL)
return -1;
LNode* p = L->next;
int location=1;
while(p)
{
if(compare(e,p->data)==mod) // 当e与L中的元素符合mod关系时返回其位置
return location;
p = p->next;
location++;
}
return 0;
}
Status NextElem(LinkList &L, ElemType cur_e, LinkList & next_e)
{ /*用next_e返回cur_e的前驱结点 ,cur_e的位置不能在尾元 否则返回0*/
if(L==NULL)
return -1;
int j = 1;
LNode* p = L->next;
while(p)
{
if(p->data == cur_e)
{p = p->next; break;}
p = p->next;
j++;
}
if(p==NULL) // 在尾元
return 0;
next_e = p;
return 1;
}
Status PriorElem(LinkList &L, ElemType cur_e, LinkList & pre_e)
{/*用pre_e返回L中第一个值为cur_e的元素的前驱结点 ,cur_e的位置不能在首元*/
if(L == NULL)
return -1;
int j = 1;
LNode* P = L->next;
while(p)
{
if(p->data == cur_e)
break;
p = p->next;
j++;
}
if(j<2) // 在首元 返回-1
return -1;
else if(p==NULL) // 未找到 返回0
return 0;
else
{
pre_e = p; // 找到
return 1;
}
}
Status DeleteElem_value(LinkList &L,ElemType e)
{/*删除L中值为e的所有节点,成功返回1 失败返回0*/
if(L==NULL)
return 0;
LNode* p = L->next;
LNode* pre = L;
while(p)
{
if(p->data==e)
{
pre->next = p->next; // 链接要删除的节点的前后节点
free(p); // 释放节点
break;
}
pre = p;
p = p->next;
}
if(p==NULL)
return 0;
else
return 1;
}
Status DeleteAllElem_value(LinkList &L,ElemType e)
{/*删除L中值为e的所有节点,成功返回1 失败返回0*/
if(L==NULL)
return 0;
LNode* p = L->next;
LNode* pre = L;
while(p)
{
if(p->data==e)
{
pre->next = p->next; // 链接要删除的节点的前后节点
free(p); // 释放节点
p = pre->next;
continue;
}
pre = p;
p = p->next;
}
return 1;
}
Status DeleteElem_location(LinkList &L,int location)
{/*删除L中第location位置的节点,成功返回1 失败返回0*/
if(L==NULL)
return 0;
LNode* p = L->next;
LNode* pre = L;
int j = 1;
while(p)
{
if(j==location)
{
pre->next = p->next; // 链接要删除的节点的前后节点
free(p); // 释放节点
break;
}
j++;
pre = p;
p = p->next;
}
if(p==NULL)
return 0;
else
return 1;
}
int main()
{ /*main 测试函数*/
LNode *L;
int temp;
int i = 1;
InitList(L);
while(1)
{
scanf("%d",&temp);
if(temp==0)
break;
ListInsert(L,i,temp);
i++;
}
ListTraverse(L);
return 0;
}