数据结构数组构建，插入，删除，扩充，排序

数据结构概述

  定义
   我们如何把现实中大量而复杂的问题以特定的数据类型和特定的存储结构保存到主存储器（内存）中，以及在此基础上为实现某个功能（比如查找某个元素，删除某个元素等）而执行的操作，这个相应的操作也叫算法。

  衡量算法的标准
   1、时间复杂度
    大概程序要执行的次数，而非执行时间
   2、空间复杂度
    算法执行过程中大概所占用的最大内存
   3、难易程度
   4、健壮性

  数据结构 = 个体+个体的关系
  算法 = 对存储数据的操作

  数据结构的地位
   数据结构是软件中最核心的课程
   程序 = 数据的存储 + 数据的操作 + 可以被计算机执行的语言

模块一：线性结构

  连续存储【数组】
  离散存储【链表】
  线性结构的两种常见应用之一 栈
  线性结构的两种常见应用之二 队列

专题： 递归

地址是内存单元的编号

#include <stdio.h>
int main(void)
{
    int * p;
    int i = 10;
    int j;
    j = *p;
    printf("%d\n",j);
    return 0;
}

动态内存分配

#include <stdio.h>
int main(void)
{
      int a[5] = {4, 10, 2, 8, 6};//限定了只能是5个
      int len;
      printf("请输入你需要分配的数组长度：len =");
      scanf("%d", len); //如果输入20 
      int *pArr = (int *)malloc(sizeof(int)* len);
      *pArr = 4; //类似于a[0] =4;
      pArr[1] =10;//类似于a[1]=10;
      //我可以把pArr当做一个普通的数组来使用
      for(int i=0; i<len; ++i)
      scanf("%d",&[pArr[i]);
      for(i=0; i<len;++i)
      printf("%d\n",*(pArr+i));
            free(pArr); //把pArr所代表的的动态分配的20个字节内存释放
      return 0;
;}

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>//包含了exit函数
//定义了一个数据类型，该数据类型的名字的叫做struct Arr,改数据类型有三个成员，分别是pBase，len，cnt
struct Arr
{
     int *pBase; //存储数组的第一个元素的地址
     int len; //数组所能容纳的最大元素的个数
     int cnt; //当前数组有效元素的个数
     //int increment; //自动增长因子
     
}
void init_arr(struct Arr *array, int length); //分号不能省
//void init_arr(struct Arr array);
bool append_arr(struct Arr *array, int val); //追加
bool insert_arr(struct Arr * pArr, int pos, int val);//插入,pos的值从1开始
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;//结构体变量不可以加减乘除， 但能相互赋值
    int val;
  //  init_arr(arr);  //最终arr.len还是为垃圾值
    init_arr(&arr,6);  //最终arr.len还是为垃圾值
    show_arr(&arr);
    append_arr(&arr, 1); //这些追加的值可以变
    append_arr(&array, 2);
    append_arr(&array, 3);
    append_arr(&array, 4);
    if (delete_arr(&arr, 1, &val))
    {
         printf("删除成功！\n");
         printf("你删除的元素为：%d\n",val);
         
    }
    else
    {
        printf("删除失败\n");
    }
   /* append_arr(&array, 2);
    append_arr(&array, 3);
    append_arr(&array, 4);
    append_arr(&array, 5);*/
    //append_arr(&array, 6);
    //append_arr(&array, 7);
    insert_arr(&arr, 1, 99);
    if( append_arr(&arr, 8))
    {
        printf("追加成功\n");
    }
    else
    {
         printf("追加失败\n");
    }
    show_arr(&arr);
    inversion_arr(&arr);
    printf("倒后的数组");
    show_arr(&arr);
    sort_arr(&arr);
    show_art(&arr); 
    return 0;
}

void init_arr(struct Arr array)
{
    array.len =99;
}
void init_arr(struct Arr *array, int length)
{
    pArr->pBase = (int *)malloc(sizeof(int)* length);  //相当于指针变量pArr所指向结构体变量中的成员pBase
    if(NULL == pArr->pBse)
    {
        printf("动态内存分配失败\n");
        exit(-1); //终止整个程序
    }
    else
    {
        pArr->len = length;
        pArr->cnt = 0;
    }
    return;
}

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

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

bool append_arr(struct Arr *array, int val)
{
    //满时返回false 
    if(is_full(pArr))
        retuen false;
        //不满时追加
       pArr->pBase[pArr->cnt] = val;
       (pArr->cnt)++;
       return true;
}

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

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

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

void sort_arr(struct Arr * pArr)  //冒泡排序,这个是大的往后排
{
    int i, j, t;
    for(i=0; i<pArr->cnt; ++i)
    {
        for(j=i+1; j<pArr->cnt; ++j)
        {
            if(pArr->pBase[i] > pArr->pBase[j])
            {
                t = pArr->pBase[i];
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = t;
            }
        }
    }
}

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]); //int *
             printf("\n");
    }
       // 输出数组有效内容
  
}