数据结构学习笔记-链表

线性表的链式存储结构

以下为用到的头文件

#pragma warning(disable : 4996)
#pragma warning(disable : 6031)
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<stdbool.h>

链式存储结构

typedef struct LNobe
{
    int data;//数据域
    struct LNobe* pNext;//指针域
}LNobe,*PNobe;//LNobe等价于struct LNobe ，PNobe等价于struct LNobe *

链表的初始化

我们这里在初始化时创建了一个带有头结点空表

void InitList(PNobe& pL)//链表初始化
{
    pL = (PNobe)malloc(sizeof(LNobe));//生成新的结点，用头指针指向它
    if (NULL == pL)
    {
        printf("内存分配失败\n");
        exit(-1);
    }
    pL->pNext = NULL;//头结点指向空
    return;
}

创建一个单链表（头插法）

（此方法创建的单链表遍历输出时与输入的顺序是反着的）

void CreateList_H(PNobe& pL, int n)
{
    int i = 0, temp = 0;
    PNobe H = NULL;
    for (i = 0; i < n; i++)
    {
        printf("请输入第%d个数据:", i + 1);
        scanf("%d", &temp);
        H = (PNobe)malloc(sizeof(LNobe));//生成新结点
        if (NULL == H)
        {
            printf("内存分配失败\n");
            exit(-1);
        }
        H->data = temp;
        H->pNext = pL->pNext;//让新结点的下一个指向头结点的下一个
        pL->pNext = H;//再将头结点的下一个指向新结点
    }
}

创建一个单链表（尾插法）

void CreateList_R(PNobe& pL, int n)//用后插法创建单链表，n表示要创建的有效结点个数
{
    PNobe R = pL;//创建一个尾指针，使它与头指针一同指向头结点
    PNobe P = NULL;//用于生成新的结点
    int i = 0, temp = 0;//temp用来存放输入数据；
    for (i = 0; i < n; i++)
    {
        P = (PNobe)malloc(sizeof(LNobe));//生成新结点
        if (NULL == P)
        {
            printf("内存分配失败\n");
            exit(-1);
        }
        printf("请输入第%d个数据:", i + 1);
        scanf("%d", &temp);
        P->data = temp;
        P->pNext = NULL;//新节点指针域指向空；
        R->pNext = P;//让头结点指针域指向新节点；
        R = P;//让尾指针指向新结点
    }
}

单链表的遍历

void TraverseList(PNobe pL)//遍历函数访问每一个节点
{
    PNobe P = pL->pNext;
    printf("结果:\n");
    while (NULL != P)
    {
        printf("%d ", P->data);
        P = P->pNext;
    }
    printf("\n");
}

查找函数

PNobe LocateElem(PNobe& pL, int e)//查找与e值相等的元素
{
    PNobe P = pL->pNext;
    while (P && P->data != e)
    {
        P = P->pNext;
    }
    return P;//查找失败返回NULL
}

取值函数

bool GetElem(PNobe pL, int n, int& e)//取值函数n为所取元素的序号，e用于接收元素
{
    PNobe P = pL->pNext;//让P指向首元结点也就是第一个有效数据
    int i = 1;//用于计数
    while (P && i < n)
    {
        P = P->pNext;
        i++;
    }
    if (P == NULL || i > n)
        return false;
    e = P->data;
    return true;
}

插入函数

bool InsertList(PNobe& pL, int n, int elem)//插入函数，n为插入位置，elem为插入的数据
{
    PNobe P = pL;
    int i = 0;
    while (P && i <n-1)//找到插入元素的前一个结点
    {
        P = P->pNext;
        i++;
    }
    if (P == NULL || i > n - 1)
    {
        printf("InsertList false\n");
        exit(-1);
    }
    PNobe T = (PNobe)malloc(sizeof(LNobe));
    if (NULL == T)
    {
        return false;
    }
    T->data = elem;
    T->pNext = P->pNext;
    P->pNext = T;
    return true;
}

删除函数

int DeleteElem(PNobe& pL, int n)
{
    PNobe P = pL, R;
    int i = 0;
    while (P  && i < n - 1)
    {
        P = P->pNext;
        i++;
    }
    if (P == NULL || i > n - 1)
        exit(-1);
    R = P->pNext;
    P->pNext = R->pNext;
    i = R->data;
    free(R);
    return i;
}

计算单链表有效长度

int Length_list(PNobe pL)
{
    int len = 0;
    PNobe P = pL;
    while (P->pNext != NULL)
    {
        P = P->pNext;
        len++;
    }
    return len;
}

对单链表进行排序

与冒泡排序类似

void Sort_List(PNobe pL)//排序函数，将链表中元素按递增顺序排列，len表示链表中有效结点个数
{
    int i, j, t = 0;
    PNobe P, R;
    for (i = 0, P = pL->pNext; i < Length_list(pL)-1 /* && P->pNext != NULL*/; i++, P = P->pNext)//与数组排序相似
    {
        for (j = i+1, R = P->pNext; j < Length_list(pL)  /* && R->pNext != NULL*/; j++, R = R->pNext)
        {
            if (P->data > R->data)
            {
                t = P->data;
                P->data = R->data;
                R->data = t;
            }
        }
    }
}