数据结构笔记#单链表

开始学习数据结构这个大坑了啊。。。赶紧记一记各种数据结构的写法。

我的数据结构代码

以下是单链表的C语言实现，只有一些最基本的功能。

我这个链表有一个表头（头节点），储存了该链表的长度。但是这个不是必须的，数据结构没有一个确定的答案，只要合适自己就行。

头节点储存链表的长度，指针指向第一个节点。

 

LinkedList.h

 该文件定义了链表，并声明了一些操作链表的函数

#ifndef _LINKEDLIST_H_
#define _LINKEDLIST_H_

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

typedef int DataType;

struct node
{
    DataType data;
    struct node *next;
};
typedef struct node NODE;
typedef NODE *HEAD;

//初始化链表，创建一个头节点，值为该链表长度
void InitList(NODE **L);

//头插法创建整表
void CreateListHead(NODE **L);

//尾插法创建整表
void CreateListTail(NODE **L);

//销毁链表
void DestroyList(NODE **L);
//销毁节点及以后的节点
void DestroyNode(NODE *N);

//获取位置i的数据
void GetElem(NODE L,DataType i, DataType *num);

//获取数据num的位置
int LocateElem(NODE L, DataType num);

//获取数据cur之前的一个数据
int PriorElem(NODE L, DataType cur_e, DataType *pre_e);

//获取数据cur之后的一个数据
int NextElem(NODE L, DataType cur_e, DataType *next_e);

//在位置i插入元素num
void ListInsert(NODE *L, DataType i, DataType num);

//在位置i删除元素，并将其值给num
void ListDelete(NODE *L, DataType i, DataType *num);

//打印整表
void ListTraverse(NODE L);

#endif

LinkedList.c

在该文件中我们具体的定义每个函数的功能。

首先我们将头文件包含进来

#include"LinkedList.h"
然后从上往下依次定义函数。
第一个是初始化链表的函数，作用是新建一个头节点，并将传入的指针指向该头节点。

void InitList(NODE **L)
{
    *L = (NODE*)malloc(sizeof(NODE));
    (*L)->data = 0;
    (*L)->next = NULL;
}

注意该函数的形参有两个**，需要传入的实参为指向指针的指针。

比如我们在main函数中，

HEAD head;

这个head是指向NODE的指针（因为我在头文件中typedef NODE *HEAD），那么传入它的时候就要写成

InitList(&head);

函数接收的值即指向该指针的指针。

为什么这么做呢？

因为我们要创建链表，而一开始head指针是空的，我们需要修改它的值让他指向新创建的头节点。

我们都知道要修改某个数据的值，只能向函数传入指向该数据的指针；而我们要修改这个head指针的值，那就要传入指向他的指针。

对于这个链表来说，如果我们想修改头指针的值（通常发生在创建链表和销毁链表的时候），那么相应的函数就要接受指向头指针的指针。

比如下面的头插法和尾插法创建链表，以及链表的销毁。

 头插法创建链表

特性是输入的数据与最后生成的链表顺序相反

void CreateListHead(NODE **L)
{
    InitList(L);
    int num;
    NODE *temp;
    while (scanf("%d", &num) && num != 999)
    {
        temp = (NODE*)malloc(sizeof(NODE));
        temp->data = num;
        //新建的节点指向头节点后的一个节点
        temp->next = (*L)->next;
        //头节点指向新建的节点，插队成功
        (*L)->next = temp;
        (*L)->data++;
    }
}

尾插法创建链表

特性与头插法相反，输入的数据与生成的链表顺序相同，但代价是使用的时候需要多维护一个不断指向尾部的指针。

void CreateListTail(NODE **L)
{
    InitList(L);
    int num;
    NODE *temp;
    //指向尾部
    NODE *tail_pointer;
    //刚开始头节点为链表的尾部
    tail_pointer = *L;
    while (scanf("%d", &num) && num != 999)
    {
        temp = (NODE*)malloc(sizeof(NODE));
        //尾部的下一个指向新建的节点
        tail_pointer->next = temp;
        temp->data = num;
        temp->next = NULL;

        //新建的节点变成尾部
        tail_pointer = temp;
        (*L)->data++;
    }
}

链表的销毁

注意只需在main函数中调用DestroyList即可，DestroyNode函数不需要人为调用。

void DestroyNode(NODE *N)
{
    NODE *temp = NULL;
    if (N != NULL)
    {
        temp = N;
        N = N->next;
        free(temp);
        temp = NULL;

        DestroyNode(N);
    }
}

void DestroyList(NODE **L)
{
    DestroyNode(*L);
    *L = NULL;
}

使用了递归？（又是你？） 

说实话我不知道这个DeleteList能不能正常工作，dubug半天也看不出过了这个函数之后到底起没起作用。。。。但是按照代码分析似乎好像也许是可以工作的。

按照递归从头开始删除每一个节点。递归真是个神奇的东西。

剩下的函数定义都直接贴出来了，都是比较简单的东西，对照头文件看看就可以了。

void GetElem(NODE L, DataType i, DataType *num)
{
    HEAD temp;
    int lop;

    temp = &L;
    temp = temp->next;
    for (lop = 0; lop < i; lop++)
    {
        temp = temp->next;
    }

    *num = temp->data;
    temp = NULL;
}

int LocateElem(NODE L, DataType num)
{
    HEAD temp;
    int lop;

    temp = &L; 
 24     temp = temp->next;

    for (lop = 0; lop < L.data; lop++)
    {
        if (num == temp->data)
        {
            return lop + 1;
        }
        else
        {
            temp = temp->next;
        }
    }

    return 0;
}

int PriorElem(NODE L, DataType cur_e, DataType * pre_e)
{
    int lop;
    NODE *target,*cursor;
    target = &L;
    cursor = &L;
    cursor = cursor->next;
    for (lop = 0; lop < L.data ; lop++)
    {
        if (cursor->data == cur_e)
        {
            if (lop == 0)
            {
                return 0;
            }
            *pre_e = target->data;
            return 1;
        }
        else
        {
            cursor = cursor->next;
            target = target->next;
        }
    }
    return -1;
}

int NextElem(NODE L, DataType cur_e, DataType * next_e)
{
    int lop;
    NODE *cursor;
    cursor = &L;
    cursor = cursor->next;

    for (lop = 0; lop < L.data ; lop++)
    {
        if (cursor->data == cur_e)
        {
            if (lop == L.data - 1)
            {
                return 0;
            }
                *next_e = cursor->next->data;
                return 1;
        }
        cursor = cursor->next;
    }
    return -1;
}

void ListInsert(NODE *L, DataType i, DataType num)
{
    HEAD temp;
    NODE *temp_node;
    int lop;

    temp = L;

    for (lop = 0; lop < i; lop++)
    {
        temp = temp->next;
    }
    temp_node = (NODE*)malloc(sizeof(NODE));
    temp_node->data = num;
    temp_node->next = NULL;

    if (lop != L->data)
    {
        temp_node->next = temp->next;
    }
    else
    {
        temp_node->next = NULL;
    }
    temp->next = temp_node;

    temp = L;
    temp->data++;
    temp = NULL;
    temp_node = NULL;
}

void ListDelete(NODE *L, DataType i, DataType *num)
{
    HEAD temp;
    NODE *temp_delete;
    int lop;

    temp = L;

    for (lop = 0; lop < i; lop++)
    {
        temp = temp->next;
    }
    temp_delete = temp->next;
    *num = temp_delete->data;
    temp->next = temp->next->next;

    free(temp_delete);

    temp = L;
    temp->data--;
    temp = NULL;
    temp_delete = NULL;
}

void ListTraverse(NODE L)
{
    HEAD temp;
    temp = &L;
    int timer= 0;
    printf("The Length Of This List Is: %d

", temp->data);
    printf("The Member(s) Are:
");
    while (temp->next!= NULL)
    {
        temp = temp->next;
        printf("%d) %d
", timer++, temp->data);
    }
    printf("
============================
");
}

最后可以写一个main函数测试一下该链表。所有的函数都可以试试。我只调用了几个函数。

#include"LinkedList.h"

int main()
{
    HEAD  head = NULL;
    int a = -1;

    //输入999终止创建,以下方法任选一个

    //CreateListHead(&head);
    CreateListTail(&head);

    ListTraverse(*head);

    if (PriorElem(*head, 1, &a) == 1)
    {
        printf("前驱元素 %d
", a);
    }

    if (NextElem(*head, 4, &a) == 1)
    {
        printf("后继元素 %d
", a);
    }
    DestroyList(&head);
    return 0;
}

前驱后继元素那里的值可以自己更换，我用的是1和4