2.2线性表的顺序存储和基本运算的实现

数组

增加O(n)

删除O(n)

线性查找O(n)二分查找O(log2(n))

修改O(1)

插入O(n)

数据结构：

1 狭义：

数据结构是专门研究数据存储的问题

数据的存储包含两方面：个体的存储+个体关系的存储

2 广义：

数据结构既包含数据的存储也包含数据的操作

对存储数据的操作就是算法

算法：

1 狭义的算法与数据的存储方式密切相关。

2 广义的算法与数据的存储方式无关。

泛型：

利用某种技术达到的效果就是：不同的存储方式，执行的操作是一样的。

数据的存储结构有几种

1 线性

1.1 连续存储【数组】

优点

存取速度很快

缺点

事先必须知道数组的长度

插入、删除元素很慢

空间通常是有限制

需要大块连续的内存块

1.2 离散存储【链表】

优点

空间没有限制

插入、删除元素很快

缺点

存取速度很慢

线性结构的应用-栈和队列

2 非线性

树

图

1 静态数组

2 动态数组

1 静态数组

#define _CRT_SECURE_NO_WARNINGS

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

//作为静态数组，无法变长，一旦分配内存，就固定了，不可以增加
//外部的内存可以访问，但是外部内存可能被使用，也可能没有被使用
//没有使用的情况下，越界偶尔会成功，还是可能被再次回收利用
//已经使用，必然失败
//a[n]等价于*(a+n);从数组名首地址开始，往下寻址，取出内容，数组不会检测越界
//偶尔会成功，偶然的成功比必然的失败更加可怕，数组不可以越界

main1()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };

    printf("%x
", a);

    system("pause");
}

//静态数组，不可以处理较大的数据

main2()
{
    int b[1024 * 014 * 10];//默认数组在栈上，最大只能使用1MB

    printf("%x
", b);

    system("pause");
}

main3()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int i, j;
    int length = sizeof(a) / sizeof(int);

    for (i = 0;i < length;i++)
    {
        printf("%d
", a[i]);
    }

    int num = 8;//要删除的元素

    if (num == a[9])//检测最后一个元素
    {
        length = length - 1;//删除一个元素，元素在末尾
    }
    else
    {
        for (i = 0;i < length - 1;i++)//检测最后一个之前
        {
            if (a[i] == num)
            {
                for (j = i;j < length - 1;j++)//从删除的位置开始，到最后一个全部向前移动
                {
                    a[j] = a[j + 1];//逐个向前移动赋值
                }
                length = length - 1;
                break;
            }
        }
    }

    printf("尾部删除以后
");
    for (i = 0;i < length;i++)
    {
        printf("%d
", a[i]);
    }

    system("pause");

}

//查询方便
main4()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int i;
    int flag = 0;
    int length = sizeof(a) / sizeof(int);

    for (i = 0;i < length;i++)//逐个访问数组每个元素
    {
        if (a[i] == 7)//查询
        {
            flag = 1;
            break;
        }
    }

    if (flag == 1)
    {
        printf("找到");
    }

    system("pause");
}

//修改方便
main()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int i;
    int flag = 0;
    int length = sizeof(a) / sizeof(int);

    for (i = 0;i < length;i++)//逐个访问数组每个元素
    {
        if (a[i] == 7)//查询
        {
            flag = 1;
            a[i] = 9;
            break;
        }
    }

    for (i = 0;i < length;i++)
    {
        printf("%d
", a[i]);
    }

    system("pause");
}

2 动态数组

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

struct Arr
{
    int *pBase;//存储的是数组第一个元素的地址
    int len;//数组所能容纳的最大元素的个数
    int cnt;//当前数组有效元素的个数
};

typedef struct Arr ARR;

void init_arr(ARR *pArr, int length);//初始化
bool append_arr(ARR *pArr, int val);//追加
bool insert_arr(ARR *pArr, int pos, int val);//插入，pos值从1开始
bool delete_arr(ARR *pArr, int pos, int * pVal);//删除元素
int get();//暂无实现
bool is_empty(ARR *pArr);//判断是否为空
bool is_full(ARR *pArr);//判断是否已满
void sort_arr(ARR *pArr);//排序
void show_arr(ARR *pArr);//打印
void inversion_arr(ARR *pArr);//逆序

void main()
{
    struct Arr arr;
    int val = 0;//保存删除以后的元素
    
    init_arr(&arr, 6);//初始化
    
    show_arr(&arr);//打印

    append_arr(&arr, 1);//追加
    append_arr(&arr, 2);
    append_arr(&arr, 3);
    append_arr(&arr, 4);
    append_arr(&arr, 5);

    insert_arr(&arr, 6, 99);//插入，pos值从1开始

    show_arr(&arr);//打印

    if (delete_arr(&arr, 1, &val))//删除元素
    {
        printf("删除成功
");
        printf("你所删除的元素是%d
", val);
    }
    else
    {
        printf("删除失败
");
    }
    
    show_arr(&arr);//打印

    inversion_arr(&arr);//逆序
    show_arr(&arr);//打印

    sort_arr(&arr);//排序
    show_arr(&arr);//打印

    system("pause");
}

void init_arr(ARR *pArr, int length)//初始化
{
    pArr->pBase = (int *)malloc(sizeof(int) * length);
    if (pArr->pBase == NULL)
    {
        printf("内存分配失败
");
    }
    else
    {
        pArr->len = length;
        pArr->cnt = 0;
    }
}

bool append_arr(ARR * pArr, int val)//追加
{
    if (is_full(pArr))//满了
    {
        return false;
    }
    else
    {
        pArr->pBase[pArr->cnt] = val;
        (pArr->cnt)++;
        return true;
    }
}

bool insert_arr(ARR * pArr, int pos, int val)//插入，pos值从1开始
{
    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(ARR * pArr, int pos, int * pVal)//删除元素
{
    int i = 0;
    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;
}

bool is_empty(ARR * pArr)//判断是否为空
{
    if (pArr->cnt == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool is_full(ARR * pArr)//判断是否已满
{
    if (pArr->len == pArr->cnt)
    {
        return true;
    }
    else
    {
        return false;
    }
}

void sort_arr(ARR * pArr)//排序
{
    int i = 0, j = 0;
    int t = 0;

    for (i = 0; i < pArr->cnt - 1; i++)//冒泡
    {
        for (j = 0; j < pArr->cnt - 1 - i; j++)
        {
            if (pArr->pBase[j]>pArr->pBase[j + 1])
            {
                t = pArr->pBase[j];
                pArr->pBase[j] = pArr->pBase[j + 1];
                pArr->pBase[j + 1] = t;
            }
        }
    }
}

void show_arr(ARR *pArr)//打印
{
    if (is_empty(pArr))
    {
        printf("数组为空
");
    }
    else
    {
        int i = 0;
        for (i = 0; i < pArr->cnt; i++)
        {
            printf("%d ", pArr->pBase[i]);
        }
        printf("
");
    }
}

void inversion_arr(ARR *pArr)//逆序
{
    int i = 0;
    int j = pArr->cnt - 1;
    int t = 0;
    while (i < j)
    {
        t = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;
        i++;
        j--;
    }
}

C++实现vector

#include "myvector.h"

template <class T>
myvector<T>::myvector()
{
    p = nullptr;
    n = realn = 0;
}

template <class T>
myvector<T>::~myvector()
{
    if (p != nullptr)
    {
        delete[]p;
        p = nullptr;
    }
}

template <class T>
void myvector<T>::push_pack(T t)//最后面插入
{
    if (p == nullptr)//如果原来为空表
    {
        p = new T;
        *p = t;
        realn = n = 1;
    }
    else
    {
        T *ptemp = new T[n + 1];
        for (int i = 0; i < n; i++)
        {
            *(ptemp + i) = *(p + i);
        }
        *(ptemp + n) = t;
        delete[]p;
        p = ptemp;

        n += 1;
        realn += 1;
    }
}

template <class T>
T *myvector<T>::find(T t)//查找
{
    for (int i = 0; i < realn; i++)
    {
        if (t == p[i])
        {
            return p + i;
        }
    };
    return nullptr;
}

template <class T>
void myvector<T>::change(T *pos, T t)//修改
{
    if (pos == nullptr)
    {
        return;
    }
    else
    {
        *pos = t;
    }
}

template <class T>
void myvector<T>::del(T t)//删除
{
    int pos = -1;
    for (int i = 0; i < realn; i++)
    {
        if (t == *(p + i))
        {
            pos = i;
            break;
        }
    }
    if (pos != -1)
    {
        if (pos == realn - 1)
        {
            realn -= 1;
        }
        else
        {
            for (int i = pos; i < realn - 1; i++)
            {
                p[i] = p[i + 1];
            }
            realn -= 1;
        }
    }
}

template <class T>
void myvector<T>::insert(T findt, T t)//在某个元素前插入,前插
{
    if (n == realn)//如果标记内存长度==实际长度
    {
        int pos = -1;
        for (int i = 0; i < realn; i++)
        {
            if (findt == *(p + i))
            {
                pos = i;
                break;
            }
        }
        if (pos != -1)//如果查找的元素存在
        {
            T *ptemp = new T[n + 1];
            for (int i = 0; i < n; i++)
            {
                *(ptemp + i) = *(p + i);
            }
            *(ptemp + n) = t;
            delete[]p;
            p = ptemp;

            n += 1;
            realn += 1;
        }

        for (int i = realn - 2; i >= pos; i--)
        {
            p[i + 1] = p[i];
        }
        p[pos] = t;
    }
    else
    {
        int pos = -1;
        for (int i = 0; i < realn; i++)
        {
            if (findt == *(p + i))
            {
                pos = i;
                break;
            }
        }

        if (pos != -1)
        {
            for (int i = realn - 2; i >= pos; i--)
            {
                p[i + 1] = p[i];
            }
            p[pos] = t;

            realn += 1;
        }
    }
}

template <class T>
void myvector<T>::show()//打印
{
    if (p == nullptr)
    {
        return;
    }
    else
    {
        for (int i = 0; i < realn; i++)
        {
            std::cout << p[i] << " ";
        }
        std::cout << "
";
    }
}