链表基本操作实现

前言

这应该算是Mark Allen Weiss《数据结构和算法分析——C语言描述》的家庭作业。从前的学习笔记保存在OneNote，正好借着写博的机会翻出来复习。

正文

链表的定义很简单，每个节点包含数据域和指针域。

下面是单链表的实现，包含list.h和list.c两个文件。list.h是接口声明，涉及的操作也会在这里说明；list.c就是接口实现了。

/*
  规范化单链表：
  
 （1）构建带头结点的链表
 （2）规范化操作集
*/

/*接口声明*/

#include <stdbool.h>

typedef int ElementType;

#ifndef _LIST_H
#define _LIST_H

struct Node;

typedef struct Node * PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;

/*操作集*/

/*创建一个头结点，并将其设为空表*/
List MakeEmpty(List L);

/*判断链表是否为空表,若为空表返回ture，否则返回false*/
bool IsEmpty(List L);

/*判断位置P是否为尾元素，若是返回ture，否则返回false*/
bool IsLast(Position P,List L);

/*查找元素在链表中的位置，若未找到返回NULL*/
Position Find(ElementType X,List L);

/*删除元素，从链表中*/
void Delete(ElementType X,List L);

/*查找元素在链表中的位置，但返回上个元素的位置。若返回尾部说明未找到目标元素*/
Position FindPrevious(ElementType X,List L);

/*将元素插入指定位置P的后面*/
void Isert(ElementType X,List L,Position P);

/*删除链表,但依然保留头结点*/
void DeleteList(List L);

/*报告链表头结点位置*/
Position Header(List L);

/*报告链表首元素位置*/
Position First(List L);

/*报告位置P的下个位置*/
Position Advance(Position P);

/*取出位置P中元素*/
ElementType Retrieve(Position P);

/*打印链表*/
void PrintfList(List L);

/*交换两个相邻元素,BeforeP指向相邻元素前面的一个元素*/
void SwapWithNext(Position BeforeP,List L); 

/*打印链表L中由链表P所指定位置上的元素（L和P是升序链表）*/
void PrintLots(List L,List P);

/*求两个升序链表的交集*/
List Intersect(List L1,List L2);

/*求两个升序链表的并集*/
List Union(List L1,List L2);

/*将链表反转，O（N）*/
void Reverse(List L); 

#endif 

#include <stdio.h>
#include <stdlib.h>
#include "list.h"

/*声明特定的结构*/
struct Node
{
    ElementType Element;
    struct Node *  Next;
};

/*==================================================================================*/

/*接口实现*/
/*void MakeEmpty(List * L)
{
   *L = (List)malloc(sizeof(struct Node)); 
    if (*L == NULL)
    {
       printf("初始化失败，退出程序\n");
       exit(1);
    }
    
    (*L)->Next = NULL;
}*/

 List MakeEmpty(List L)
{
    if (L != NULL)
        DeleteList(L);//如果链表非空，则删除链表
    L = (List)malloc(sizeof(struct Node));
    if (L == NULL)
    {
       printf("初始化失败，退出程序\n");
       exit(1);
    }
      
    L->Next = NULL;
    return L;
}

bool IsEmpty(List L)
{
    return L->Next == NULL;
}

bool IsLast(Position P,List L)
{
    return P->Next == NULL;
}

Position Find(ElementType X,List L)
{
    Position P = L->Next;
    
    while (P != NULL && P->Element != X)
        P = P->Next;
        
    return P;
}

void Delete(ElementType X,List L)
{
    Position LastElement = FindPrevious(X,L);
    Position TheElement; 
    
    if (!IsLast(LastElement,L))    //LastElement不是尾部，说明找到X 
    {
       TheElement = LastElement->Next;
       LastElement->Next = TheElement->Next;
       free(TheElement);
    }
}

Position FindPrevious(ElementType X,List L)
{
    Position P = L;
    
    while (P->Next != NULL && P->Next->Element != X)
        P = P->Next;
    
    return P;
}

void Isert(ElementType X,List L,Position P)
{
    Position Temp;
    
    Temp = (List)malloc(sizeof(struct Node));
    if (Temp == NULL)
    {
       printf("内存分配失败，退出程序\n");
       exit(1);
    }
    
    Temp->Element = X;
    
    Temp->Next = P->Next;
    P->Next = Temp;
}

void DeleteList(List L)
{
    Position P = L->Next;
    Position Temp;
    
    L->Next = NULL;       //保留头结点 
    
    while (P != NULL)
    {
        Temp = P->Next;
        free(P);
        P = Temp;
    }
}

Position Header(List L)
{
    return L;
}

Position First(List L)
{
    return L->Next;
}

Position Advance(Position P)
{
    return P->Next;
}

ElementType Retrieve(Position P)
{
    return P->Element;
}

void PrintfList(List L)
{
    Position P;
    
    if (IsEmpty(L))
       printf("List is empty!\n");
    
    P = First(L);
    while (P != NULL)
    {
        printf("%3d",Retrieve(P));
        P = Advance(P);
    }
    printf("\n");
}

void SwapWithNext(Position BeforeP,List L)
{
    Position P;
    Position AfterP;
    
    P = Advance(BeforeP);
    if (P != NULL)
    {
       AfterP = Advance(P);
       if (AfterP != NULL)
       {
           P->Next = AfterP->Next;
           BeforeP->Next = AfterP;
           AfterP->Next = P;
       }
    }
}

void PrintLots(List L,List P)
{
    int count = 1;//链表L元素计数器，初始值指向第一个元素
    Position LTemp;
    Position PTemp;
    
    LTemp = First(L);
    PTemp = First(P);
    
    /*当链表L和P任一为空停止打印*/
    while (LTemp != NULL && PTemp != NULL)
    {
        if (count == PTemp->Element)   //判断是否打印当前元素
        {
           printf("%3d",LTemp->Element);
           PTemp = Advance(PTemp);     //指向下个要打印的目标元素 
        } 
        
        LTemp = Advance(LTemp);
        count++;
    }
    printf("\n"); 
}


List Intersect(List L1,List L2)
{
    List Result;
    Position Ptr1;
    Position Ptr2;
    Position P;
    
    Result = MakeEmpty(NULL);
    Ptr1 = First(L1);
    Ptr2 = First(L2);
    P = Header(Result);
    
    /*归并操作*/
    while (Ptr1 != NULL && Ptr2 != NULL)
    {
        if (Ptr1->Element < Ptr2->Element)
           Ptr1 = Advance(Ptr1);
        
        else if (Ptr1->Element > Ptr2->Element)
           Ptr2 = Advance(Ptr2);
           
        else
        {
           Isert(Ptr1->Element,Result,P);
           
           Ptr1 = Advance(Ptr1);
           Ptr2 = Advance(Ptr2);
           P = Advance(P);
        }
    }
    
    return Result; 
}



List Union(List L1,List L2)
{
    List Result;
    Position Ptr1;
    Position Ptr2;
    Position P;
    
    Result = MakeEmpty(NULL);
    Ptr1 = First(L1);
    Ptr2 = First(L2);
    P = Header(Result);
    
    /*归并操作*/
    while (Ptr1 != NULL&& Ptr2 != NULL)
    {
        if (Ptr1->Element < Ptr2->Element)
        {
           Isert(Ptr1->Element,Result,P);
           Ptr1 = Advance(Ptr1);
        }
        
        else if (Ptr1->Element > Ptr2->Element)
        {
           Isert(Ptr2->Element,Result,P);
           Ptr2 = Advance(Ptr2);
        }
        
        else
        {
           Isert(Ptr1->Element,Result,P);
           Ptr1 = Advance(Ptr1);
           Ptr2 = Advance(Ptr2);
        }
        
        P = Advance(P);
    }
    
    while (Ptr1 != NULL)
    {
        Isert(Ptr1->Element,Result,P);
        Ptr1 = Advance(Ptr1);
        P = Advance(P);
    }
    
    while (Ptr2 != NULL)
    {
        Isert(Ptr2->Element,Result,P);
        Ptr2 = Advance(Ptr2);
        P = Advance(P);
    }
    
    return Result;
}

void Reverse(List L)
{
    Position Temp;
    Position P;
    
    if (IsEmpty(L) || L->Next->Next == NULL)
       return;
    
    P = First(L);
    L->Next = NULL;
    
    while (P != NULL)
    {
        Temp = Advance(P);
        P->Next = First(L);
        L->Next = P;
        
        P = Temp;
    }
}