数据结构——线性表的链式实现

 记录一下比较完整的链式线性表的函数操作集

语言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;

}