数据结构学习第三天

19:28:16 2019-08-18

今天稍微早点。

 00:51:49 2019-08-21

增加了对双链表的测试

17:30:49 2019-08-21

增加了对栈的测试

增加了对队列的测试

双链表

DList.h

#ifndef _DLIST_H
#define _DLIST_H
#define len sizeof(struct Node)
#include<malloc.h>
typedef struct Node* PtrToNode;
typedef PtrToNode DList;
typedef PtrToNode DPosition;
struct  Node
{
    int Element;
    DPosition Prior;
    DPosition Next;
};
DList MakeEmety(DList L);
int IsEmpty(DList L);
int IsLast(DPosition P, DList L);
DPosition Find(int Element, DList L);
void Delete(int Element, DList L);
DPosition FindPrevious(int Element, DList L);
void InsertBefore(int Element,DList L, DPosition P);
void InsertAfter(int Element, DList L, DPosition P);
void DeleteList(DList L);
DPosition Header(DList L);
DPosition First(DList L);
#endif // !_DLIST_H

DList.c

#include"DList.h"
extern struct  Node;
DList MakeEmety(DList L)
{
    L = (DList)malloc(len);
    L->Element = 0;
    L->Prior = NULL;
    L->Next = NULL;
    return L;
}

int IsEmpty(DList L)
{
    return L->Next == NULL;
}

int IsLast(DPosition P, DList L)
{
    return P->Next == NULL;
}

DPosition Find(int Element, DList L)
{
    DPosition P = L->Next;
    /*while (P!=NULL)
    {
        if (P->Element == Element)
            return P;
        else
            P = P->Next;
    }
    return NULL;*/
    while (P!=NULL&&P->Element!=Element)
    {
        P = P->Next;
    }
    return P;
}

void Delete(int Element, DList L)
{
    /*DPosition P1, P2;
    P1=P2= FindPrevious(Element, L);    //利用单链表的思想来删除 但要注意删除是否为最后一个元素
    P2 = P1->Next;                     //因为单链表只向后 而双链表有一个指向前面的指针 最后一个元素的后驱元指针为NULL
    if (IsLast(P1->Next,L))
    {
        P1->Next =NULL;
    }
    else
    {
        P1->Next = P1->Next->Next;
        P1->Next->Prior = P1;
    }
    free(P2);*/
    //利用双链表来删除
    DPosition P1;
    P1 = Find(Element, L);             //利用双链表的特点来删除
    P1->Prior->Next = P1->Next;
    if (!IsLast(P1, L))                
    {
        P1->Next->Prior = P1->Prior;     //同时也要注意是否是尾节点
    }
    free(P1);
}

DPosition FindPrevious(int Element, DList L)
{
    DPosition P = L;
    /*while (P->Next!=NULL)
    {
        if (P->Next->Element==Element)
            return P;
        else
            P = P->Next;
    }
    return NULL;*/
    while (P->Next!=NULL&&P->Next->Element!=Element)
    {
        P = P->Next;
    }
    return P;
}

void InsertBefore(int Element, DList L, DPosition P)
{
    DPosition P1 = (DPosition)malloc(len);
    P1->Element=Element;
    P1->Prior = P->Prior;
    P1->Next = P;
    P->Prior->Next = P1;
    P->Prior = P1;
}

void InsertAfter(int Element, DList L, DPosition P)
{
    DPosition P1 = (DPosition)malloc(len);
    P1->Element = Element;
    P1->Prior = P;
    P1->Next = P->Next;
    P->Next = P1;
    if (!IsLast(P1, L))          //做完上面的 P已经不是尾节点了
    {
        P1->Next->Prior = P1;   //如果是插在末尾 这句话要删掉 //写成这样就是为了末尾的特殊情况
    }                            //可以看出 因为双链表具有指向前的指针 导致插入和删除出现了特殊情况
}

void DeleteList(DList L)
{
    DPosition P1, P2;
    P1 = P2 = L->Next;
    while (P2 != NULL)
    {
        P2 = P1->Next;
        free(P1);
        P1 = P2;
    }
}

DPosition Header(DList L)
{
    return L;
}

DPosition First(DList L)
{
    return L->Next;
}

main.c

#include<stdio.h>
#include<malloc.h>
#include"DList.h"
int main()
{
    DList L = NULL;
    L = MakeEmety(L);
    printf("%10d %10d
", IsEmpty(L), IsLast(L, L));
    DPosition P = (DPosition)malloc(len);
    L->Next = P;
    P->Element = 20;
    P->Next = NULL;
    P->Prior = L;
    printf("%10d %10d
", P->Element, IsLast(P, L));
    InsertBefore(25, L, P);
    printf("%10d %10d
",L->Next->Element, IsLast(L->Next, L));
    printf("%10d %10d
", L->Next->Element, P->Prior->Element);
    printf("%10d
", Find(20, L)->Element);
    Delete(25, L);
    printf("%10d
", L->Next->Element);
    InsertAfter(30, L, P);
    printf("%10d %10d
",P->Next->Element,P->Next->Prior->Element);
    Delete(20, L);
    printf("%10d
", IsEmpty(L));
    DeleteList(L);
    return 0;
}

测试结果

循环单链表是将末尾元素中的指针指向第一个节点

循环双链表是将末尾元素中的next指针指向第一个节点 ，第一个节点中的prior指针指向最后一个节点

栈的链表实现

LIFO(后进先出)

Stack.h

#ifndef _STACK_H
#define _STACK_H
#define len sizeof(struct Node)
struct Node;
typedef struct Node* PtrToNode;
typedef PtrToNode Stack;
int IsEmpty(Stack S);
Stack CreatStack();
void DisposeStack(Stack S);
void MakeEmpty(Stack S);
void Push(int Element, Stack S);
int Top(Stack S);
void Pop(Stack S);
#endif // !_STACK_H

Stack.c

#include"Stack.h"
#include<stdio.h>
#include<malloc.h>
struct  Node
{
    int Element;
    PtrToNode Next;
};

int IsEmpty(Stack S)
{
    return    S->Next == NULL;
}

Stack CreatStack()
{
    Stack S = (Stack)malloc(len);
    S->Next = NULL;
    MakeEmpty(S);
    return S;
}

void DisposeStack(Stack S)
{
    while (!IsEmpty(S))
    {
        Pop(S);
    }
    free(S);
}

void MakeEmpty(Stack S)
{
    while (!IsEmpty(S))
    {
        Pop(S);
    }
}

void Push(int Element, Stack S)
{
    PtrToNode P = (PtrToNode)malloc(len);
    P->Element = Element;
    P->Next = S->Next;
    S->Next = P;
}

int Top(Stack S)
{
    if (IsEmpty(S))
    {
        printf("No Element
");
        return -1;
    }
    return S->Next->Element;
}

void Pop(Stack S)
{
    PtrToNode P=S->Next;
    if (P)
    {
        S->Next = S->Next->Next;
        free(P);
    }
    else
    {
        printf("stack is empty
");
    }
}

main.c

#include<stdio.h>
#include"Stack.h"

int main()
{
    Stack S=NULL;
    S = CreatStack();
    printf("%10d %10d
", Top(S),IsEmpty(S));
    Push(10, S);    
    printf("%10d %10d
", Top(S),IsEmpty(S));
    Push(25, S);
    printf("%10d
", Top(S));
    Pop(S);
    printf("%10d %10d
", Top(S), IsEmpty(S));
    Pop(S);
    printf("%10d %10d
",Top(S),IsEmpty(S));
    DisposeStack(S);
    return 0;
}

测试

队列的链表实现

Queue.h

#ifndef _QUEUE_H
#define _QUEUE_H
#define  len sizeof(Node)
#define length sizeof(Queue)
struct  Node;
struct  Queue;
typedef struct Node* PtrToNode;
typedef struct Queue* HQueue;
int IsEmpty(HQueue H);
HQueue CreatQueue();
void DiposeQueue(HQueue H);
void Enqueue(int Element, HQueue H);
void Dequeue(HQueue H);
#endif // !_QUEUE_H

Queue.c

#include<stdio.h>
#include"Queue.h"
#include<malloc.h>
struct  Node
{
    int Element;
    PtrToNode Next;
};
struct Queue
{
    PtrToNode front;
    PtrToNode rear;
};

int IsEmpty(HQueue H)
{
    return H->rear == NULL || H->front == NULL;
}

HQueue CreatQueue()
{
    HQueue H= (HQueue)malloc(length);
    H->front = NULL;
    H->rear = NULL;
    return H;
}

void DiposeQueue(HQueue H)
{
    PtrToNode P1, P2;
    P1 = P2 = H->front;
    while (P2)
    {
        P2 = P1->Next;
        free(P1);
        P1 = P2;
    }
    free(H);
}

void Enqueue(int Element, HQueue H)
{
    PtrToNode P = (PtrToNode)malloc(len);
    P->Element = Element;
    P->Next=NULL;
    if (IsEmpty(H))
    {
        H->front = P;
        H->rear = P;
    }
    else
    {
        H->rear->Next = P;
        H->rear = P;
    }
}

void Dequeue(HQueue H)
{
    PtrToNode P;
    if (IsEmpty(H))
    {
        printf("No Element
");
        return ;
    }
    else
    {
        P = H->front;
        /*H->front = H->front->Next;   //当队列中只有一个元素时候要特殊处理
        free(P);*/
    }    
    if (H->front== H->rear)
    {
        free(P);
        H->front = H->rear = NULL;
    }
    else
    {
        H->front = H->front->Next;
        free(P);
    }
}

main.c

#include<stdio.h>
#include"Queue.h"
int main()
{
    HQueue HQ=NULL;
    HQ = CreatQueue();
    Dequeue(HQ);
    printf("%10d
", IsEmpty(HQ));
    Enqueue(20, HQ);
    printf("%10d
", IsEmpty(HQ));
    Dequeue(HQ);
    printf("%10d
", IsEmpty(HQ));
    DiposeQueue(HQ);
    return 0;
}

测试：