二.学习数据结构之数组

线性结构（数组）
1.1 定义：元素类型相同，大小相等（数组传参，只要传进去首地址和长度就行）
1.2数组的优缺点：
优点：
存取速度快
缺点：
事先必须知道数组的长度
插入删除元素很慢
空间通常是有限制的
需要大块连续的内存块
插入删除元素的效率很低
1.3对数组的操作

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>//使用exit要用的

struct Arr
{
    int * pBase;//存储第一个元素的地址 
    int len;
    int cnt;//当前数组的有效元素
};

void init_arr(struct Arr * pArr, int length);
bool append_arr(struct Arr * pArr, int val);
bool insert_arr(struct Arr * pArr,int pos,int val);
bool delete_arr(struct Arr * pArr, int pos, int * pVal);
int get();
bool is_empty(struct Arr * pArr);
bool is_full(struct Arr * pArr);
void sort_arr(struct Arr * pArr);
void show_arr(struct Arr * pArr);
void inversion_arr(struct Arr * pArr);
int main(void)
{
    struct Arr arr;//分配了内存空间，但是是垃圾数字，pBase是随机的一个地址
    init_arr(&arr,10);//这就让内存的数字赋值了
    int delVal;//删除的元素
    //arr.pBase[0] = 1;
    //arr.pBase[1] = 1;
    //arr.pBase[2] = 1;
    append_arr(&arr,8);
    append_arr(&arr, 9);
    append_arr(&arr, 4);
    append_arr(&arr, 6);
    //insert_arr(&arr, 2, 20);
    //delete_arr(&arr, 3, &delVal); 
    show_arr(&arr);
    /*printf("要删除的元素的值为：%d\n", delVal);*/
    //inversion_arr(&arr);
    sort_arr(&arr);
    show_arr(&arr);
    system("pause");
    return 0;
}
void init_arr(struct Arr * pArr,int length)
{
    pArr->pBase = (int *)malloc(sizeof(int)*length);
    if (NULL == pArr->pBase)
    {
        printf("动态分配内存失败！\n");
        exit(-1);
    }
    else
    {
        pArr->cnt = 0;
        pArr->len = length;
    }
    return;
}

void show_arr(struct Arr * pArr)
{
    if (is_empty(pArr))
    {
        printf("数组为空！\n");
    }
    else
    {
        for (int i = 0; i < pArr->cnt; i++)
            printf("%d,", pArr->pBase[i]);
        printf("\n");
    }
}

bool is_empty(struct Arr * pArr)
{
    if ( 0== pArr->cnt)
        return true;
    else
        return false;
}

bool append_arr(struct Arr * pArr,int val)
{
    if (is_full(pArr))
        return false;
    else
    {
        pArr->pBase[pArr->cnt] = val;
        (pArr->cnt)++;
        return true;
    }
}

bool is_full(struct Arr * pArr)
{
    if (pArr->cnt == pArr->len)
        return true;
    else
        return false;
}

bool insert_arr(struct Arr* pArr, int pos, int val)
{
    if (is_full(pArr))
        return false;
    if (pos<0||pos >pArr->cnt - 1)
    {
        return false;
    }
    else
    {
        for (int i = pos; i <pArr->cnt; i++)
        {
            pArr->pBase[i + 1] = pArr->pBase[i];            
        }
        pArr->pBase[pos] = val;
        (pArr->cnt)++;
        return true;
    }
}

bool delete_arr(struct Arr * pArr, int pos, int * pVal)
{
    if (is_empty(pArr))
        return false;
    else if (pos<1 || pos>pArr->cnt - 1)
        return false;
    else
    {
        *pVal = (pArr->pBase[pos - 1]);//*pVal等价于val
        for (int i = pos-1; i < pArr->cnt; i++)
        {
            pArr->pBase[i] = pArr->pBase[i+1];
        }
        (pArr->cnt)--;
        return true;
    }
}

void inversion_arr(struct Arr * pArr)
{
    int i = 0;
    int j = pArr->cnt-1;
    int temp;
    while (i<j)
    {
        temp = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = temp;
        i++;
        j--;
    }
}

void sort_arr(struct Arr * pArr)
{
    int i, j,temp;
    //----------冒泡------------
    /*for ( i = 0; i < pArr->cnt; i++)

        for (j = 0;j < pArr->cnt - 1 - i;j++)
        {
            if (pArr->pBase[j]>pArr->pBase[j + 1])
            {
                temp = pArr->pBase[j];
                pArr->pBase[j] = pArr->pBase[j+1];
                pArr->pBase[j+1] = temp;
            }
        }*/
    //--------选择排序----------
    for (i = 0;i < pArr->cnt;i++)
        for (j = i + 1;j < pArr->cnt;j++)
        {
            if (pArr->pBase[i]>pArr->pBase[j])
            {
                temp = pArr->pBase[i];
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = temp;
            }
        }
}

1.4总结

1.5补充（关于malloc函数）

跨函数使用内存代码如下：

#include<stdio.h>
#include<malloc.h>
struct Student
{
    int sid;
    int age;
};
struct Student * CreateStruct(void);
void ShowStudent(struct Student *);
int main(void)
{
    struct Student * pst;
    pst = CreateStruct();
    ShowStudent(pst);
}
struct Student * CreateStruct(void)
{
    struct Student * p = (struct Student *)malloc(sizeof(struct Student));
    p->sid = 88;
    p->age = 44;
    return p;
}
void ShowStudent(struct Student * p)
{
    printf("%d %d\n", p->age, p->sid);
}

升级：

#include<stdio.h>
#include<stdlib.h>//system要用这个函数

void fun1(int * q);
void fun2(int ** q);
void fun3(int ** q);
int main()
{
    int s = 5;
    int * p=&s;
    printf("p的值：%p\n", p);
    //fun1(p);//通过这个函数改变p的值
    //fun2(&p);
    fun3(&p);//总结：跨函数使用内存必须动态分配内存才行；
    printf("p的值：%p\n", p);
    system("pause");
    return 0;
}
void fun1(int * q)//1.这样改变不了必须是取p的地址（&p）才能改变
{
    int s=6;
    q = &s;
}

void fun2(int ** q)//2.这样*q = &s;的确是p指向了另一个地址，但是退出}就没有了指向了
{
    int s = 6;
    *q = &s;
}
void fun3(int ** q)//3.malloc函数动态分配内存，必须手动释放free（），操作系统才会回收内存，不然会内存丢失
{
    *q =(int*) malloc(sizeof(int));//相当于int aa=new int();
}

注意：多维数组本质就是一维数组，具体见二维数组内存中保存