数据结构

c语言版本

DynamicArray.h

#ifndef DYNAMIC_ARRAY_H
#define DYNAMIC_ARRAY_H


//#ifdef __cplusplus             //告诉编译器，这部分代码按C语言的格式进行编译，而不是C++的
//extern "C"{
//#endif

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

// 动态增长内存，将存放的数据的内存放在哪？ 堆上

// 申请内存 拷贝数据 释放内存 - > 效率太低；
// capacity ：内存空间一共可以存放多少个元素
// size ： 记录元素个数

// 动态数组结构体
typedef struct DYNAMICARRAY
{
    int* pAddr;//存放数据地址
    int size; // 当前元素个数, 类似 vector.size();
    int capacity;// 类似 vector.capacity();
}Dynamic_Array;
//写出一系列相关堆DYNAMICARRAY结构体操作的函数
//初始化
Dynamic_Array* Init_Array();
//插入
void PushBack_Array(Dynamic_Array* arr, int value);
//根据位置删除
void RemoveByPos_Array(Dynamic_Array* arr, int pos);
//根据值删除
void RemoveByValue_Array(Dynamic_Array* arr, int value);
//查找
int Find_Array(Dynamic_Array* arr, int value);
//打印
void Print_Array(Dynamic_Array* arr);
//释放动态数组内存
void FreeSpace_Array(Dynamic_Array* arr);
//清空数组
void Clear_Array(Dynamic_Array* arr);
//获得Capacity
int Capacity_Array(Dynamic_Array* arr);
//获取size
int Size_Array(Dynamic_Array* arr);
//根据位置获取元素
int At_Array(Dynamic_Array* arr, int pos);

//#ifdef __cplusplus
//}
//#endif



#endif // !DYNAMIC_ARRAY_H

DynamicArray.c

#include"DynamicArray.h"

//初始化
Dynamic_Array* Init_Array()
{
    // 申请内存
    Dynamic_Array* myArray = (Dynamic_Array*)malloc(sizeof(Dynamic_Array));//强制转换 将void* 转换成 Dynamic_Array*
    //初始化
    myArray->size = 0;
    myArray->capacity = 20;
    myArray->pAddr = (int*)malloc(sizeof(int)*myArray->capacity);
    return myArray;//返回指针
}
//插入
void PushBack_Array(Dynamic_Array* arr, int value)
{
    if (arr == NULL)
        return;

    // 判断空间是否足够
    if (arr->size == arr->capacity)
    {
        // <1>申请更大的内存空间， 新空间是旧空间的两倍
        int* newSpace = (int*)(malloc(sizeof(int)*arr->capacity*2));
        // <2>拷贝数据到新的空间
        memcpy(newSpace,arr->pAddr, arr->capacity*sizeof(int));
        // <3>释放旧空间
        free(arr->pAddr);
        // <4>更新容量和地址
        arr->capacity *= 2;
        arr->pAddr = newSpace;
    }
    // 插入新元素
    arr->pAddr[arr->size] = value;
    arr->size++;
}
//根据位置删除
void RemoveByPos_Array(Dynamic_Array* arr, int pos)
{
    if (arr->pAddr == NULL)
        return;

    if (pos < 0 || pos >= arr->size) // pos 越界
        return;

    //删除元素
    // 1 2 3 4 5 6 7 8
    // 比如删除 6，我们就直接将6后面的元素向前挪一个位置，覆盖6
    for (int i = pos; i < (arr->size - 1); i++)
    {
        arr->pAddr[i] = arr->pAddr[i + 1];
    }
    arr->size--;//最初数组最后一个元素的位置没了
}
//根据值删除
void RemoveByValue_Array(Dynamic_Array* arr, int value)
{
    if (arr == NULL)
        return;

    //找到值得位置
    int pos = Find_Array(arr,value);
    if (pos == -1)
    {
        return;
    }
    // 根据位置删除
    RemoveByPos_Array(arr, pos);
}


//查找
int Find_Array(Dynamic_Array* arr, int value)
{
    if (arr == NULL)
        return -1;
    //找到值得位置
    int pos = -1;
    for (int i = 0; i < arr->size; i++)
    {
        if (arr->pAddr[i] == value)
        {
            pos = i;
            break;
        }
    }
    return pos;
}
//打印
void Print_Array(Dynamic_Array* arr)
{
    if (arr == NULL)
        return;

    for (int i = 0; i < arr->size; i++)
    {
        printf("%d ", arr->pAddr[i]);
    }
    printf("
");
}
//释放动态数组内存
void FreeSpace_Array(Dynamic_Array* arr)
{
    if (arr == NULL)
        return;

    if (arr->pAddr != NULL)
    {
        free(arr->pAddr);// 释放指针
    }
    free(arr);// 释放结构体
}
//清空数组
void Clear_Array(Dynamic_Array* arr)
{
    if (arr == NULL)
        return;

    arr->size = 0;
}
//获得Capacity
int Capacity_Array(Dynamic_Array* arr)
{
    if (arr == NULL)
        return -1;

    return arr->capacity;
}
//获取size
int Size_Array(Dynamic_Array* arr)
{
    if (arr == NULL)
        return -1;

    return arr->size;
}
//根据位置获取元素
int At_Array(Dynamic_Array* arr, int pos)
{
    return arr->pAddr[pos];
}

01动态数组.c

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

#include"DynamicArray.h"

void test01() 
{
    //初始化动态数组
    Dynamic_Array* myArray = Init_Array();
    //打印容量
    printf("数组容量:%d
", Capacity_Array(myArray));
    printf("数组大小:%d
", Size_Array(myArray));
    //插入元素
    for (int i = 0; i < 30; i++)
    {
        PushBack_Array(myArray, i);
    }
    //打印容量
    printf("数组容量:%d
", Capacity_Array(myArray));
    printf("数组大小:%d
", Size_Array(myArray));
    // 打印
    Print_Array(myArray);
    //删除
    RemoveByPos_Array(myArray, 1);
    RemoveByValue_Array(myArray, 27);
    Print_Array(myArray);
    //查找第5个位置
    int pos = Find_Array(myArray, 5);
    printf("第%d个元素 = %d",pos, At_Array(myArray, pos));
    //销毁
    FreeSpace_Array(myArray);
}

int main()
{
    test01();
    return 1;
}

c++版本

dynamic_array_1_dim.cpp

#include<iostream>

using namespace std;

namespace MY
{
    class Vector
    {
    public:
        Vector();
        ~Vector();
        void push_back(int value);
        void removeByPose(int pos);
        void removeByValue(int value);
        int find(int value);
        int& operator[](int index)// 必须是返回引用
        {
            return array_[index];
        }
        void show() const;
        void clear()
        {
            size_ = 0;
        }
        bool empty()
        {
            if (array_ == nullptr)
                return true;
            else
                return false;
        }
    public:
        int* array_;
        int size_;
        int capacity_;
    };

    Vector::Vector()
    {
        size_ = 0;
        capacity_ = 10;
        array_ = new int[capacity_];
    }
    Vector::~Vector()
    {
        delete[] array_;
        cout << "free " << array_ << endl;
    }
    void MY::Vector::push_back(int value)
    {
        if (empty()) return;
        //判断空间是否足够
        if (size_ == capacity_)
        {
            int* newspace = new int[capacity_ * 2]; // 扩容
            memcpy(newspace, array_, capacity_ * sizeof(int));// 备份 - > newsapce
            delete[] array_;// 删除旧空间
            capacity_ *= 2;//扩容
            array_ = newspace;//转移旧空间的值 - > 新空间
        }
        //在末尾插入元素
        array_[size_] = value;
        size_++;
    }
    void MY::Vector::show() const
    {
        cout << "size_ = " << size_ << " ||";
        for (int i = 0; i < size_; i++)
        {
            cout << array_[i] << " ";
        }
        cout << endl;
    }
    void MY::Vector::removeByPose(int pos)
    {
        if (empty()) return;
        if (pos < 0 || pos >= size_)//越界
        {
            cout << "out of range!" << endl;
            return;
        }
        for (int i = pos; i < (size_ - 1); i++) //0 1 2 3 4 5 6 7 8 9
        {
            array_[i] = array_[i + 1];
        }
        size_--;
    }
    int MY::Vector::find(int value)
    {
        if (empty()) return -1;
        int pos = -1;
        for (int i = 0; i < size_; i++)
        {
            if (array_[i] == value)
            {
                pos = i;
                break;
            }
        }
        return pos;
    }
    void MY::Vector::removeByValue(int value)
    {
        if (empty()) return;
        int pos = find(value);
        if (pos == -1)
        {
            cout << "没有元素：" << value << endl;
            return;
        }
        removeByPose(pos);
    }
}

int main()
{
    // 参考别人博客：https://blog.csdn.net/qq_26816591/article/details/52214313
    //// 我的博客： https://www.cnblogs.com/winslam/articles/9146832.html
    //int *p1 = new int; //在自由存储区开辟一个int变量 
    //int *p2 = new int[10];//在自由存储区开辟一个int数组，有10个元素
    //for (int i = 0; i < 10; i++)
    //{
    //    p2[i] = i;
    //    cout << "p2 = " << p2[i] << endl;
    //}
    //p2[2] = p2[1];
    //int *p3 = new int(10);//在自由存储区开辟一个int变量,并初始化为10
    //cout << "*p3 = " << *p3 << endl;

    MY::Vector vec;
    for (int i = 0; i < 12; i++)
    {
        vec.push_back(i*i);
    }
    vec.push_back(88);
    vec.show();
    vec.removeByPose(1);
    vec.show();
    vec.removeByPose(2);
    vec.show();
    vec.removeByValue(49);
    vec.show();
    int position = vec.find(25);
    //测试重载
    cout << "test for overload " << endl;
    for (int i = 0; i < vec.size_; i++)
    {
        cout << vec[i] << " ";
    }
    cout << endl;

    vec.clear();
    vec.show();
    return 1;
}

二维动态数组初始化与释放的两种方式：

方式一：

//【不推荐，因为使用的时候，cols 和 rows 必须指定大小为常数，所以rows cols在函数中不能用作形参】
//申请
int cols = 200;
int rows = 100;
uchar (*matrix)[cols];
matrix = new uchar[rows][cols];//450行 800列
//释放
delete [] matrix;

方式二：

//【推荐这种方式：】
//申请
int **matrix = new int*[rows];
for (int i = 0; i < rows; i++)
{
    matrix[i] = new int[cols];
}
//释放
for (int i = 0; i < rows; i++)
{
    delete[] matrix[i];
}
delete matrix;

方式二Demo:

#include<iostream>
#include<vector>
using namespace std;

//参考：https://www.cnblogs.com/Sylla-Zhang/archive/2012/10/08/2715300.html

void printMat(int rows, int cols)// 3 4
{
    //申请空间
    int **matrix = new int*[rows];
    for (int i = 0; i < rows; i++)
    {
        matrix[i] = new int[cols];
    }
    //赋值
    for (int j = 0; j < rows; j++)
    {
        for (int i = 0; i < cols; i++)
        {
            matrix[j][i] = i + j;
            cout.width(2);
            cout << matrix[j][i] << " ";
        }
        cout << endl;
    }
    //释放
    for (int i = 0; i < rows; i++)
    {
        delete[] matrix[i];
    }
    delete matrix;
    
}
int main()
{
    printMat(3, 8);
    return 1;
}

二维动态矩阵应用举例：

#include<iostream>
#include<ctime>
using namespace std;

namespace MY
{
    class Mat
    {
    public:
        Mat(int rows, int cols);
        ~Mat(); 
        void printf() const;
        void resize(int rows, int cols);
    public:
        int rows_;
        int cols_;
        int **matrix;
    };
    Mat::Mat(int rows, int cols):rows_(rows),cols_(cols)
    {
        // 申请并分配空间
        matrix = new int*[rows_]; // 行
        for (int i = 0; i < rows_; i++)
        {
            matrix[i] = new int[cols_]; // 列
        }
        // 初始化赋值
        srand(time(nullptr));
        for (int j = 0; j < rows_; j++)
        {
            for (int i = 0; i < cols_; i++)
            {
                matrix[j][i] = rand()%11;
            }
        }
    }
    void Mat::resize(int rows, int cols)
    {
        //尺寸放大
        if (rows > rows_ || cols > cols_)
        {
            //<1>申请更大空间
            int **newspace = new int*[rows];
            for (int i = 0; i < rows; i++)
            {
                newspace[i] = new int[cols];
            }
            //<2>拷贝数据到新的空间// 这里可以用双重遍历，遍历小的旧空间，newspace[j][i] = matrix[j][i];
            for (int j = 0; j < rows_; j++)//遍历旧的小空间
            {
                memcpy(newspace[j], matrix[j], sizeof(int)*cols);
            }
            //<3>释放旧空间
            for (int i = 0; i < rows_; i++)
            {
                delete[] matrix[i];
            }
            delete matrix;
            cout << "destory the older！" << endl;
            //<4>填充新的拓展的边缘
            for (int j = 0; j < rows; j++)//遍历新的大空间
            {
                // 新增列的初始化为0
                if (j < rows_)
                {
                    for (int i = cols_; i < cols; i++)
                    {
                        newspace[j][i] = 0;
                    }
                }
                else// 新增行初始化为0
                {
                    for (int i = 0; i < cols; i++)
                    {
                        newspace[j][i] = 0;
                    }
                }
            }
            //<5>更新矩阵和行、列
            matrix = newspace;
            rows_ = rows;
            cols_ = cols;
        }
        else
        {
            cout << "缩小尺寸一个道理，懒得写" << endl;
            return;
        }
    }
    void Mat::printf() const
    {
        for (int j = 0; j < rows_; j++)
        {
            for (int i = 0; i < cols_; i++)
            {
                cout.width(2);
                cout << matrix[j][i] << " ";
            }
            cout << endl;
        }
        cout << endl;
    }
    Mat::~Mat()
    {
        for (int i = 0; i < rows_; i++)// 注意析构顺序
        {
            delete[] matrix[i];
        }
        delete matrix;
        cout << "destory the Mat()!" << endl;
    }
}

int main()
{
    MY::Mat mat(6,8);//创建一个6行8列的矩阵
    mat.printf();
    mat.resize(8,10);//拓展边缘，你看下面结果多出来的0全是拓展的行和列
    mat.printf();
    return 1;
}