数据结构和算法（C语言）

sleep22

已于 2022-03-31 19:37:59 修改

阅读量8.8k

点赞数 16

分类专栏： java学习笔记文章标签：数据结构算法 c++ c语言

于 2022-03-21 21:14:26 首次发布

本文链接：https://blog.csdn.net/weixin_60096751/article/details/123643490

版权

java学习笔记专栏收录该内容

9 篇文章 2 订阅

订阅专栏

数据结构是计算机存储、组织数据的方式，是相互之间存在一种或多种特定关系的数据元素集合

算法

算法是特定问题求解步骤的描述，在计算机中表示为指令的有限序列，算法是独立存在的一种解决问题的方法和思想。

对于算法而言，语言不重要，重要的是思想。

算法具有五个基本的特性：输入、输出、有穷性、确定性和可行性

算法和数据结构的区别

算法是为了解决实际问题而设计的
数据结构是算法需要处理的问题载体
数据结构与算法相辅相成

数据结构分类

数据结构分为逻辑结构（集合结构，线性结构，树形结构，图形结构）和物理结构/存储结构（顺序存储，链式存储）

线性 1：1关系除了第一个元素没有前驱，最后一个元素没有后继，其他元素都有唯一的前驱和唯一的后继。

树形 1：n关系

图形 n：n关系

线性表

动态数组

初始化，插入数据，遍历数据，

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

//动态数组的结构体
struct dynamicArray
{
    void ** pAddr;//维护在堆区真实数组指针
    int m_capacity;//数组容量
    int m_size;//数组大小
};
//初始化数组
struct dynamicArray * init_DynamicArray(int capacity)
{
    if (capacity <= 0)
    {
        return NULL;
    }
    struct dynamicArray * array = (dynamicArray*)malloc(sizeof(struct dynamicArray));
    //判断内存是否申请成功
    if (array == NULL)
    {
        return NULL;
    }
    //设置容量
    array->m_capacity = capacity;
    //设置大小
    array->m_size = 0;
    //维护在堆区数组的指针
    array->pAddr =(void**)  malloc(sizeof(void*) * array->m_capacity);
    return array;
}
//插入功能
void insert_dynamicArray(struct dynamicArray* array, int pos, void* data)
{
    if (array == NULL)
    {
        return;
    }
    if (data == NULL)
    {
        return;
    }
    if (pos < 0 || pos>array->m_size)
    {//无效的位置  进行尾插
        pos = array->m_size;
    }
    //先判断是否已经满载，满了就动态开辟
    if (array->m_size >= array->m_capacity)
    {
        //申请一个更大的空间
        int newCapacity = array->m_capacity * 2;
        //创建新空间
        void** newSpace = (void**) malloc(sizeof(void*) * newCapacity);
        //将原来的数据拷到新空间
        memcpy(newSpace, array->pAddr, sizeof(void*) * array->m_capacity);
        //释放原有的空间
        free(array->pAddr);
        //更改指针指向
        array->pAddr = newSpace;
        //更新容量大小
        array->m_capacity = newCapacity;
    }
    //插入新数据,从最后一个数据 依次后移
    for (int i = array->m_size - 1; i >= pos; i--)
    {
        array->pAddr[i + 1] = array->pAddr[i];
    }
    //将新元素插入指定位置
    array->pAddr[pos] = data;
    //更新size大小
    array->m_size++;

}
//遍历数组
void foreach_DynamicArray(struct dynamicArray* array,void (*myForeach)(void*))
{
    if (array == NULL) {
        return;
    }
    if (myForeach == NULL) {
        return;
    }
    for (int i = 0; i < array->m_size; i++) {
        myForeach(array->pAddr[i]);
    }
}
//删除数组中元素 按照指定位置
void removebyPos_DynamicArray(struct dynamicArray * arr,int pos)
{
    if (arr == NULL) {
        return;
    }
    if (pos<0 || pos>arr->m_size - 1) {//无效位置
        return;
    }
    for (int i = pos; i < arr->m_size - 1; i++)//从pos位置开始到数组尾  数据前移
    {
        arr->pAddr[i] = arr->pAddr[i + 1];
    }
    arr->m_size--;
}
//删除数组中元素 按照值
void removebyvalue_DynamicArray(struct dynamicArray * arr,void*  data,int (*myCompare)(void*,void*)) {
    if (arr == NULL||data==NULL) { return; }
    for (int i = 0; i < arr->m_size; i++) {
        if (myCompare(arr->pAddr[i], data)) {
            removebyPos_DynamicArray(arr, 1);
            break;
        }
 }
}
//销毁
void destroy_DynamicArray(struct dynamicArray * arr) {
    if (arr == NULL) { return; }
    if (arr ->pAddr != NULL) {
        free(arr->pAddr);
        arr->pAddr = NULL;
    }
    free(arr);
    arr = NULL;
}





struct Person {
    char name[64];
    int age;
};
void myPrintPerson (void * data) {
    struct Person * p =(Person*) data;
    printf("姓名,%s 年龄%d\n", p->name, p->age);

}
int myComparePerson(void* data1,void*data2) {
    struct Person* p1 =(Person*) data1;
    struct Person* p2 = (Person*)data2;
    return strcmp(p1->name, p2->name) == 0 && p1->age == p2->age;
}
void test01() {
    //创建动态数组
    struct  dynamicArray* arr = init_DynamicArray(5);
    struct Person p1 = { "a",18 };
    struct Person p2 = { "b",15 };
    struct Person p3 = { "c",28 };
    struct Person p4 = { "d",13 };
    struct Person p5 = { "e",16 };
    struct Person p6 = { "f",19 };
    //将数据插入动态数组中
    printf("当前的容量为:%d\n", arr->m_capacity);
    insert_dynamicArray(arr, 0, &p1);
    insert_dynamicArray(arr, 0, &p2);
    insert_dynamicArray(arr, 0, &p3);
    insert_dynamicArray(arr, 0, &p4);
    insert_dynamicArray(arr, 0, &p5);
    insert_dynamicArray(arr, 0, &p6);
    // f e d c b a
    //遍历
    foreach_DynamicArray(arr, myPrintPerson);
    printf("插入数据后的容量为：%d\n", arr->m_capacity);
    //删除
    removebyPos_DynamicArray(arr, 1);
    printf("删除第一个位置的元素");
        foreach_DynamicArray(arr, myPrintPerson);
        struct Person p = { "f",19 };
        removebyvalue_DynamicArray(arr, &p, myComparePerson);
        printf("------------------------------");
        foreach_DynamicArray(arr, myPrintPerson);
        //销毁
        destroy_DynamicArray(arr);
        arr = NULL;
}
; int main() {
    test01();
    system("pause");
    return EXIT_SUCCESS;
}

单向链表

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

//链表结点
struct LinkNode {
    void* data;//数据域
    struct LinkNode* next;//指针域
};
//链表结构体
struct LList {
    struct LinkNode pHeader;//头节点
    int m_size;//链表长度
};

typedef void* LinkList;
//初始化链表
LinkList init_LinkList() {
    struct LList* myList = (LList* )malloc(sizeof(struct LList));
    if (myList == NULL) {
        return NULL;
    }
    myList->pHeader.data = NULL;
    myList->pHeader.next = NULL;
    myList->m_size =0;
    return myList;
}
//插入结点
void insert_LinkList(LinkList list, int pos, void* data) {
    if (list == NULL || data == NULL) { return; }
    struct LList* myList =(LList *) list;
    if (pos < 0||pos> myList->m_size) {
        //无效位置  尾插
        pos = myList->m_size;
    }
    //创建临时节点
    struct LinkNode* pCurrent = &myList->pHeader;
  //通过循环找到插入位置的前驱结点 
    for (int i = 0; i < pos; i++) {
        pCurrent = pCurrent->next;
    }


    //创建新结点
    struct LinkNode*newNode = (LinkNode*)malloc(sizeof(struct LinkNode));
    newNode->data = data;
    newNode->next= NULL;
    //新结点插入链表中
    newNode->next = pCurrent->next;
    pCurrent->next = newNode;
    myList->m_size++;//更新链表长度

}
//遍历链表
void foreach_LinkList(LinkList list ,void (*myPrint)(void*) ) {
    if(list == NULL) { return; }
    struct LList* myList = (LList*)list;
    struct LinkNode* pCurrent = myList->pHeader.next;//找到第一个有数据的结点
    for (int i = 0; i < myList->m_size; i++) {
        myPrint(pCurrent->data);
        pCurrent = pCurrent->next;
    }
}
//删除结点
void removeby_LinkList(LinkList list, int pos) {
    if (list == NULL) { return; }
    struct LList* myList =(LList*) list;
    if (pos<0||pos>myList->m_size-1) {
        return;
    }
//找到删除结点前驱
    struct LinkNode* pCurrent = &myList->pHeader;
    for (int i = 0; i < pos; i++) {
        pCurrent = pCurrent->next;
    }
   //缓存中  待删除
    struct LinkNode* pDel = pCurrent->next;
    //建立关系
    pCurrent->next = pDel->next;
    //释放
    free(pDel);
    pDel = NULL;
    //更新长度
    myList->m_size--;
}
//删除 值
void removebyValue_LinkList(LinkList list,void* data,int (*myCompare)(void*,void*) ) {
    if (list == NULL||data==NULL) { return; }
    struct LList* myList =(LList*) list;
    //创建两个辅助指针变量
    struct LinkNode* pPrev =  &myList->pHeader;
    struct LinkNode* pCurrent = pPrev->next;
    for (int i = 0; i < myList->m_size; i++) {//给用户来对比
        if (myCompare(pCurrent->data, data)) {
            //更改指针指向
            pPrev->next = pCurrent->next;
            //释放
            free(pCurrent);
            pCurrent = NULL;
            myList->m_size--;
            break;
        }
        //后移
        pPrev = pCurrent;
        pCurrent=pCurrent->next;
    }
}
//清空
void clear_LinkList(LinkList list) {
    if (list == NULL) { return; }
    struct LList* myList =(LList*) list;
    struct LinkNode* pCurrent= myList->pHeader.next;
    for (int i = 0; i < myList->m_size;i++) {
        //记录后继结点
        struct LinkNode* pNext =(LinkNode*) pCurrent->next;
        free(pCurrent);
        pCurrent = pNext;
    }
    myList->pHeader.next = NULL;
    myList->m_size = 0;
}
//返回长度
int size_LinkList(LinkList list) {
    if (list == NULL) { return -1; }
    struct LList* myList =(LList*) list;
    return myList->m_size;
}
//销毁
void destroy_LinkList(LinkList list) {
    if (list == NULL) { return; }
    clear_LinkList(list);
    free(list);
    list = NULL;
}




struct Person {
    char name[64];
    int age;
};
void myPPerson(void* data) {
    struct Person* p = (Person*)data;
    printf("字母: %s 数字: %d\n", p->name, p->age);
}
int myCompare(void* data1, void * data2) {
    struct Person* p1 = (Person*) data1;
    struct Person* p2 = (Person*) data2;
    return strcmp(p1->name, p2->name) == 0 && p1->age == p2->age;
}
//调试
void test01() {
    //初始化
    LinkList list = init_LinkList();
    //插入数据
    struct Person p1 = { "a",18 };
    struct Person p2 = { "b",15 };
    struct Person p3 = { "c",28 };
    struct Person p4 = { "d",13 };
    struct Person p5 = { "e",16 };
    struct Person p6 = { "f",19 };
    //插入数据
    insert_LinkList(list, 0, &p1);
    insert_LinkList(list, 0, &p2);
    insert_LinkList(list, 1, &p3);
    insert_LinkList(list, 0, &p4);
    insert_LinkList(list, 1, &p5);
    insert_LinkList(list, 100, &p6);
    // d e b c a f 
    printf("长度为： %d\n", size_LinkList(list));
    foreach_LinkList(list, myPPerson);
    //删除c
    removeby_LinkList(list, 3);
        printf("------------------\n");
        foreach_LinkList(list, myPPerson);
        printf("长度为： %d\n", size_LinkList(list));
        //删除e
        struct Person p = { "e", 16 };
        removebyValue_LinkList(list, &p, myCompare);
        printf("------------------\n");
        foreach_LinkList(list, myPPerson);
        printf("长度为： %d\n", size_LinkList(list));
        //清空
        clear_LinkList(list);
        printf("------------------\n");
        foreach_LinkList(list, myPPerson);
        //销毁
        destroy_LinkList(list);
}


 int main() {
     test01();

    system("pause");
    return EXIT_SUCCESS;
}

栈

属于 先进后出的数据结构。一种特殊的线性表，始终在栈顶进行。

不能遍历(只有栈顶元素被外界访问到)

栈的顺序存储（数组）和栈的链式存储（链表）。

顺序结构

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

#define MAX 1024
//栈的结构体
struct SStack {
    void* data[MAX];//数组
    //元素个数
    int m_size;
};
typedef void* seqStack;
//初始化
seqStack init_SeqStack() {
    struct SStack* stack = (SStack*)malloc(sizeof(struct SStack));
    if (stack == NULL) { return NULL; }
    //清空数组
    memset(stack->data, 0, sizeof(void*) * MAX);
    stack->m_size = 0;
    return stack;
}
//入栈
void push_SeqStack(seqStack stack, void* data) {
    if (stack == NULL||data==NULL) { return; }
    //判断是否栈满
    struct SStack* myStack = (SStack*) stack;
    if (myStack->m_size == MAX) {
        return;
    }
    myStack->data[myStack->m_size] = data;//尾插 
    myStack->m_size++;//更新大小
}
//出栈
void pop_SeqStack(seqStack stack ) {
    if (stack == NULL  ) { return; }
    struct SStack* myStack = (SStack*)stack;
    if (myStack->m_size <= 0) { return; }
    myStack->data[myStack->m_size - 1] = NULL;//执行出栈
    myStack->m_size--;//更新大小
}
//获取栈顶元素
void* top_SeqStack(seqStack stack) {
    if (stack == NULL) { return NULL; }
    struct SStack* myStack = (SStack*)stack;
    if (myStack->m_size == 0) { return NULL; }
    return myStack->data[myStack->m_size-1];
}
//栈的大小
int size_SeqStack(seqStack stack) {
    if (stack == NULL) { return -1; }
    struct SStack* myStack = (SStack*)stack;
    return myStack->m_size;
}
//判空
int isEmpty_SeqStack(seqStack stack) {
    if (stack == NULL) { return -1; }//真
    struct SStack* myStack = (SStack*)stack;
    if (myStack->m_size <= 0) {
        return 1;//真
    }
    return 0;//假，不为空
}
//销毁
void destroy_SeqStack(seqStack stack){
    if (stack == NULL) { return ; }
    free(stack);
    stack = NULL;
}
//测试
struct Person {
    char name[64];
    int age;
};
void test() {
    //数据
    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 };
    //初始化栈
    seqStack init_SeqStack();
    //入栈

    //出栈
    //。。。

}
; int main() {
    void test();
    system("pause");
    return EXIT_SUCCESS;
}