c语言提高学习笔记——03-c提高09day_数据结构

在学习c语言提高-数据结构总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

03-c提高09day_数据结构

目录：
1、单向链表
练习1：单向链表（版本二）——（+初始化、+插入、+遍历）
练习2：单向链表（版本二）——（+删除、+销毁）
 2、受限线性表——栈（Stack)
（1）栈的基本概念
（2）栈的顺序存储
练习1：栈的顺序存储
（3）栈的链式存储
练习2：栈的链式存储
（4）栈的应用（案例：就近匹配）
练习：栈的应用：就近匹配

 

1、单向链表

（推荐版本二：代码少）

练习1：单向链表（版本二）——（+初始化、+插入、+遍历）

内存模型图如下：

 单向链表(版本二).c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

//链表结点数据结构
struct LinkNode
{
    struct LinkNode* next;
};

//链表结构体
struct LList
{
    struct LinkNode header;//头结点给四个字节存地址
    int size;
};

typedef void* LinkList;

//初始化链表
LinkList Init_LinkList()
{
    struct LList* list = malloc(sizeof(struct LList));
    if(NULL = list)
    {
        return NULL;
    }
    list->header.next = NULL;
    list->size = 0;
    
    return list;
}
//插入
void Insert_LinkList(LinkList list, int position, void* data)
{
    if(NULL = list)
    {
        return;
    }
    if(NULL = data)
    {
        return;
    }
    struct LList* mylist = (struct LList*)list;
    struct LinkNode* mynode = (struct LinNode*)data;
    
    if(position < 0 || position > mylist->size)
    {
        position = mylist->size;
    }
    
    //找位置（找到position位置的前一个位置）
    struct LinkNode* pCurrent = &(mylist->header);
    for(int i = 0; i < position; ++i)
    {
        pCurrent = pCurrent->next;
    }
    //数据入链表
    mynode->next = pCurrent->next;
    pCurrent->next = mynode;
    
    mylist->size++;
}
//遍历
void Foreach_LinkList(LinkList list, void(*foreach)(void*))
{
    if(NULL = list)
    {
        return;
    }
    if(NULL = foreach)
    {
        return;
    }
    
    struct LList* mylist = (struct LList*)list;
    struct LinkNode* pCurrent = &(mylist->header.next);
    
    while(pCurrent != NULL)
    {
        myforeach(pCurrent);
        pCurrent = pCurrent->next;
    }
    
}

struct Person
{
    struct LinkNode node;//此处不能用指针，双链表会出问题，地址的位置
    char name[64];
    int age;
};

void myPrint(void* data)
{
    struct Person* person = (struct Person*)data;
    printf("Name:%s Age:%d\n", person->name, person->age);
}

void test()
{
    //初始化链表
    LinkList list = Init_LinkList();
    //创建数据
    struct Person p1 = { NULL, "aaa", 10};
    struct Person p2 = { NULL, "bbb", 20};
    struct Person p3 = { NULL, "ccc", 30};
    struct Person p4 = { NULL, "ddd", 40};
    struct Person p5 = { NULL, "eee", 50};
    struct Person p6 = { NULL, "fff", 60};
    
    //插入数据
    Insert_LinkList(list, 0, &p1);
    Insert_LinkList(list, 0, &p2);
    Insert_LinkList(list, 0, &p3;
    Insert_LinkList(list, 0, &p4);
    Insert_LinkList(list, 0, &p5);
    Insert_LinkList(list, 0, &p6);
    
    //遍历
    Foreach_LinkList(list, myPrint);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

练习2：单向链表（版本二）——（+删除、+销毁）

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

//链表结点数据结构
struct LinkNode
{
    struct LinkNode* next;
};

//链表结构体
struct LList
{
    struct LinkNode header;//头结点给四个字节存地址
    int size;
};

typedef void* LinkList;

//初始化链表
LinkList Init_LinkList()
{
    struct LList* list = malloc(sizeof(struct LList));
    if(NULL = list)
    {
        return NULL;
    }
    list->header.next = NULL;
    list->size = 0;
    
    return list;
}
//插入
void Insert_LinkList(LinkList list, int position, void* data)
{
    if(NULL = list)
    {
        return;
    }
    if(NULL = data)
    {
        return;
    }
    struct LList* mylist = (struct LList*)list;
    struct LinkNode* mynode = (struct LinNode*)data;
    
    if(position < 0 || position > mylist->size)
    {
        position = mylist->size;
    }
    
    //找位置（找到position位置的前一个位置）
    struct LinkNode* pCurrent = &(mylist->header);
    for(int i = 0; i < position; ++i)
    {
        pCurrent = pCurrent->next;
    }
    //数据入链表
    mynode->next = pCurrent->next;
    pCurrent->next = mynode;
    
    mylist->size++;
}
//遍历
void Foreach_LinkList(LinkList list, void(*foreach)(void*))
{
    if(NULL = list)
    {
        return;
    }
    if(NULL = foreach)
    {
        return;
    }
    
    struct LList* mylist = (struct LList*)list;
    struct LinkNode* pCurrent = &(mylist->header.next);
    
    while(pCurrent != NULL)
    {
        struct LinkNode* pNext = pCurrent->next;
        myforeach(pCurrent);
        pCurrent = pNext;
    }
    
}

//删除结点
void RemoveByPos_LinkList(LinkList List, int position)
{
    if(NULL == list)
    {
        return;
    }
    
    struct LList* mylist = (struct LList*)list;
    
    if(position < 0 || position > mylist->size - 1)
    {
        return;
    }
    
    //辅助指针
    struct LinkNode* pCurrent = &(mylist->header);
    for(int i = 0; i < position; ++i)
    {
        pCurrent = pCurrent->next;
    }
    
    //缓存下待删除结点
    struct LinkNode* pDel = pCurrent->next;
    
    //重新建立待删除结点的前驱和后继结点关系
    pCurrent->next = pDel->next;
    
    mylist->size--;
}
//销毁
void Destroy_LinkList(LinkList list)
{
    if(NULL == list)
    {
        return;
    }
    
    free(list);
    list = NULL;
}

struct Person
{
    struct LinkNode node;//此处不能用指针，双链表会出问题，地址的位置！
    char name[64];
    int age;
};

void myPrint(void* data)
{
    struct Person* person = (struct Person*)data;
    printf("Name:%s Age:%d\n", person->name, person->age);
}

void test()
{
    //初始化链表
    LinkList list = Init_LinkList();
    //创建数据（缺点：不能插入重复数据，会出问题！）
    struct Person p1 = { NULL, "aaa", 10};
    struct Person p2 = { NULL, "bbb", 20};
    struct Person p3 = { NULL, "ccc", 30};
    struct Person p4 = { NULL, "ddd", 40};
    struct Person p5 = { NULL, "eee", 50};
    struct Person p6 = { NULL, "fff", 60};
    
    //插入数据
    Insert_LinkList(list, 0, &p1);
    Insert_LinkList(list, 0, &p2);
    Insert_LinkList(list, 0, &p3;
    Insert_LinkList(list, 0, &p4);
    Insert_LinkList(list, 0, &p5);
    Insert_LinkList(list, 0, &p6);
    
    //遍历
    Foreach_LinkList(list, myPrint);
    
    //删除
    RemoveByPos_LinkList(list, 3);
    printf("---------------\n");
    
    //遍历
    Foreach_LinkList(list, myPrint);
    
    //销毁
    Destroy_LinkList(list);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

 

 2、受限线性表——栈（Stack)

（1）栈的基本概念
>概念：
首先它是一个线性表，也就是说，栈元素具有线性关系，即前驱后继关系。只不过它是一种特殊的线性表而已。定义中说是在线性表的表尾进行插入和删除操作，这里表尾是指栈顶，而不是栈底。

>特性
它的特殊之处在于限制了这个线性表的插入和删除的位置，它始终只在栈顶进行。这也就使得：栈应是固定的，最先进栈的只能在栈底。（不支持随机存取）

>操作
■栈的插入操作，叫做进栈，也称压栈。类似子弹入弹夹。
■栈的湖除操作，叫做出栈，也有的叫做猫栈，退栈。如同弹夹中的子弹出夹。

 

（2）栈的顺序存储
>基本概念
栈的顺序存储结构简称顺序栈，它是运算受限制的顺序表。顺序栈的存储结构是：利用一组地址连续的的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针 top只是栈顶元素在顺序表中的位置。

>设计与实现
因为栈是一种特殊的线性表，所以栈的顺序存储可以通过顺序线性表来实现。

 

练习1：栈的顺序存储

栈的顺序存储.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"SeqStack.h"


struct Person
{
    char name[64];
    int age;
};

void test()
{
    //初始化栈
    SeqStack stack = Init_SeqStack();
    
    //创建数据
    struct Person p1 = { "aaa", 10};
    struct Person p2 = { "bbb", 20};
    struct Person p3 = { "ccc", 30};
    struct Person p4 = { "ddd", 40};
    struct Person p5 = { "eee", 50};
    struct Person p6 = { "fff", 60};
    
    //数据入栈
    Push_SeqStack(stack, &p1);
    Push_SeqStack(stack, &p2);
    Push_SeqStack(stack, &p3);
    Push_SeqStack(stack, &p4);
    Push_SeqStack(stack, &p5);
    Push_SeqStack(stack, &p6);
    
    //输出栈中所有元素
    while(Size_SeqStack(stack) > 0)
    {
        //获得栈顶元素
        struct Person* person = (struct Person*)Top_SeqStack(stack);
        //打印
        printf("Name:%s Age:%d\n", person->name, person->age);
        //弹出栈顶元素
        Pop_SeqStack(stack);
    }
    
    printf("Size:%d\n", Size_SeqStack(stack));
    
    //销毁栈
    Destroy_SeqStack(stack);
    stack = NULL;
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

SeqStack.h

#pragma once

#include<stdlib.h>
#include<string.h>//memset

#ifdef __cplusplus
extern "C"{
#endif    


#define MAX 1024

    //顺序栈数据结构
    struct SStack
    {
        void* data[MAX];//存放数据的数组
        int size;//栈中元素的个数
    }
    
    //数组高下标的位置当做栈顶，因为不需要移动数组中的元素在插入和删除中
    
    //初始化
    SeqStack Init_SeqStack();
    //入栈
    void Push_SeqStack(SeqStack stack, void* data);
    //出栈
    void Pop_SeqStack(SeqStack stack);
    //获得栈顶元素
    void* Top_SeqStack(SeqStack stack);
    //获得栈的大小
    int Size_SeqStack(SeqStack stack);
    //销毁栈
    void Destroy_SeqStack(SeqStack stack);

#ifdef __cplusplus
}
#endif

SeqStack.c

#include"SeqStack.h"

//初始化
SeqStack Init_SeqStack()
{
    struct SStack* stack = malloc(sizeof(struct SStack));
    if(NULL == stack)
    {
        return NULL;
    }
    
    memset(stack, 0, sizeof(struct SStack));
    stack->size = 0;
    
    return stack;
}
//入栈
void Push_SeqStack(SeqStack stack, void* data)
{
    if(NULL == stack)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }    
    
    struct SStack* s = (struct SStack*)stack;
    
    s->data[s->size] = data;
    s->size++;
}
//出栈
void Pop_SeqStack(SeqStack stack)
{
    if(NULL == stack)
    {
        return;
    }
    struct SStack* s = (struct SStack*)stack;
    
    if(s->size == 0)
    {
        return;
    }
    
    s->data[s->size-1] = NULL;//此句可有可无，有数据会把这块内存覆盖
    s->size--;
}
//获得栈顶元素
void* Top_SeqStack(SeqStack stack)
{
    if(NULL == stack)
    {
        return NULL;
    }

    struct SStack* s = (struct SStack*)stack;
    
    if(s->size == 0)
    {
        return NULL;
    }
    
    return s->data[s->size-1];
}
//获得栈的大小
int Size_SeqStack(SeqStack stack)
{
    if(NULL == stack)
    {
        return -1;
    }

    struct SStack* s = (struct SStack*)stack;
    return s->size;
}
//销毁栈
void Destroy_SeqStack(SeqStack stack)
{
    if(NULL == stack)
    {
        return;
    }
    free(stack);
        
}

（3）栈的链式存储

>基本概念
栈的链式存储结构简称链栈，

练习2：栈的链式存储

栈的链式存储.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"LinkStack.h"

struct Person
{
    struct StackNode node;
    char name[64];
    int age;
};

void test()
{
    //初始化栈
    LinkStack stack = Init_LinkStack();
    
    //创建数据
    struct Person p1 = { NULL, "aaa", 10};
    struct Person p2 = { NULL, "bbb", 20};
    struct Person p3 = { NULL, "ccc", 30};
    struct Person p4 = { NULL, "ddd", 40};
    struct Person p5 = { NULL, "eee", 50};
    struct Person p6 = { NULL, "fff", 60};
    
    //数据入栈
    Push_LinkStack(stack, &p1);
    Push_LinkStack(stack, &p2);
    Push_LinkStack(stack, &p3);
    Push_LinkStack(stack, &p4);
    Push_LinkStack(stack, &p5);
    Push_LinkStack(stack, &p6);
    
    //输出栈中所有元素
    while(Size_LinkStack(stack) > 0)
    {
        //获得栈顶元素
        struct Person* person = (struct Person*)Top_LinkStack(stack);
        //打印
        printf("Name:%s Age:%d\n", person->name, person->age);
        //弹出栈顶元素
        Pop_LinkStack(stack);
    }
    
    printf("Size:%d\n", Size_LinkStack(stack));
    
    //销毁栈
    Destroy_LinkStack(stack);
    stack = NULL;    
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

LinkStack.h

#pragma once

#include<stdlib.h>

#ifdef __cplusplus
extern "C"{
#endif    

struct StackNode
{
    struct StackNode* next;
};

struct LStack
{
    struct StackNode header;//头结点，也可以没有
    int size;
};

typedef void* LinkStack;

    //初始化
    LinkStack Init_LinkStack();
    //入栈
    void Push_LinkStack(LinkStack stack, void* data);
    //出栈
    void Pop_LinkStack(LinkStack stack);
    //获得栈顶元素
    void* Top_LinkStack(LinkStack stack);
    //获得大小
    int Size_LinkStack(LinkStack stack);
    //销毁栈
    void Destroy_LinkStack(LinkStack stack);


#ifdef __cplusplus
}
#endif

LinkStack.c

#include"LinkStack.h"

//初始化
LinkStack Init_LinkStack()
{
    struct LStack* stack = malloc(sizeof(struct LStack));
    if(NULL == stack)
    {
        return NULL;
    }
    stack->header.next = NULL;
    stack->size = 0;
    
    return stack;
}
//入栈
void Push_LinkStack(LinkStack stack, void* data)
{
    if(NULL == stack)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }
    
    struct LStack* ls = (struct LStack*)stack;
    struct StackNode* node = (struct StackNode*)data;
    
    node->next = ls->header.next;//新结点的next指向ls的头结点的下一个结点
    ls->header.next = node;//ls头结点的下一个结点指向新结点
    
    ++(ls->size);
}
//出栈
void Pop_LinkStack(LinkStack stack)
{
    if(NULL == stack)
    {
        return;
    }
    
    struct LStack* ls = (struct LStack*)stack;
    
    if(ls->size == 0)
    {
        return;
    }
    
    //缓存第一个结点
    struct StackNode* pFirst = ls->header.next;
    
    ls->header.next = pFirst->next;
    
    ls->size--;
}
//获得栈顶元素
void* Top_LinkStack(LinkStack stack)
{
    if(NULL == stack)
    {
        return;
    }
    
    struct LStack* ls = (struct LStack*)stack;
    
    if(ls->size == 0)
    {
        return;
    }
    
    return ls->header.next;
}
//获得大小
int Size_LinkStack(LinkStack stack)
{
    if(NULL == stack)
    {
        return -1;
    }

    struct LStack* ls = (struct LStack*)stack;
    
    return ls->size;
}
//销毁栈
void Destroy_LinkStack(LinkStack stack)
{
    if(NULL == stack)
    {
        return;
    }

    free(stack);
    stack = NULL;
}

（4）栈的应用（案例：就近匹配）

几乎所有的编译器都具有检测括号是否匹配的能力，那么如何实现编译器中的符号成对检测?如下字符串：
5+5*(6)+9/3*1)-(1+3(

>算法思路
■从第一个字符开始扫描
■当遇见普通字符时忽略，
■当遇见左符号时压入栈中
■当遇见右符号时从栈中弹出栈顶符号，并进行匹配
■匹配成功：继续读入下一个字符
■匹配失败：立即停止，并报错
■结束；
■成功；所有字符扫描完毕，且栈为空

练习：栈的应用：就近匹配

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"SeqStack.h"

int IsLeft(char ch)
{
    return ch == "(";
}

int IsRight(char ch)
{
    return ch == ")";
}

void printError(const char* str, char* errMsg, char *pos)
{
    printError("错误信息：%s\n", errMsg);
    printf("%s\n", str);
    int dis = pos - str;
    for(int i = 0; i < dis; ++i)
    {
        printf(" ");
    }
    printf("A\n");
}

void test()
{
    const char* str = "5+5*(6)+9/3*1)-(1+3(";
    char* p = (char*)str;
    
    //初始化栈
    SeqStack stack = Init_SeqStack();
    
    while(*p != '\0')
    {
        //判断当前字符是否是左括号
        if(IsLeft(*p))
        {
            Push_SeqStack(stack, p);
        }
        //判断当前字符是否是右括号
        if(IsRight(*p))
        {
            if(Size_SeqStack(stack) > 0)
            {
                //弹出栈顶元素
                Pop_SeqStack(stack);
            }
            else
            {
                printError(str, "右括号没有匹配的左括号！", p);
            }
        }        
        
        p++;
    }
    while(Size_SeqStack(stack) > 0)
    {
        printError(str, "没有匹配的右括号！", Top_SeqStack(stack));
        //弹出栈顶元素
        Pop_SeqStack(stack);
    }
    
    //销毁栈
    Destroy_SeqStack(stack);
    stack = NULL;
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

 

 

在学习c语言提高-数据结构总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。