第2章 顺序表及其顺序存储

时间  2020-10-04
标签 c++ 算法 数组 post spa 设计 指针 code 队列 内存 栏目 C&C++ 繁體版
原文   原文链接

第2章 顺序表及其顺序存储

目录

1、线性表

  1. 线性表：属于线性结构。有且仅有一个开始结点，有且仅有一个终端结点，其余结点为内部结点。
  2. 线性表的存储：顺序存储 or 链式存储

2、顺序表

2.1 顺序表的基本概念及描述

  1. 顺序表：线性表采用顺序存储的方式
  2. 注：每一个结点占用\(len\)个内存单元，\(location(k_i)\)为顺序表中第\(i\)个结点\(k_i\)所占内存空间的第\(1\)个单元的地址
    1. \(location(k_i) = location(k_i) + len\)
    2. \(location(k_i) = location(k_1) + (i-1)len\)

2.2 顺序表的实现

  1. 注：数组中下标为\(i\)的元素对应的是顺序表中第\(i+1\)个结点
  2. 顺序表的经常使用操做（简单且大几率不考，所以无代码展现，后不提醒）
    1. 顺序表的初始化
    2. 顺序表后部进行插入操做
    3. 打印顺序表的各结点值
    4. 判断顺序表是否为空
    5. 查找顺序表中值为x的结点位置
    6. 取得顺序表中第i个结点的值

2.2.1 顺序表的存储结构

#define MAXSIZE 100
typedef int datatype;
typedef struct {
    datatype a[MAZXSIZE];
    int size;
} sequence_list;

2.2.2 顺序表的插入操做（算法）

  1. 将值为\(x\)的结点插入到第\(i\)个位置的步骤：
    1. 判断顺序表是不是满的
    2. 判断指定的位置是否不存在
    3. 将\(k_i,\cdots,k_{n-1}\)这些结点对应的数组元素依次后移一个位置，空出\(k_i\)原先的位置存放新插入的结点。（从后往前移）
    4. 将值为\(x\)的结点插入到第\(i\)个位置
    5. 顺序表的长度加\(1\)
#define MAXSIZE 100
typedef int datatype;
typedef struct {
    datatype a[MAZXSIZE];
    int size;
} sequence_list;

void insert(sequence_list *slt, datatype x, int position) {
    int i;
    if (slt->size == MAXSIZE) {
        printf("\n顺序表是满的！无法插入！");
        exit(1);
    }
    if (position < 0 || position > slt->size) // 如size为10，slt->a[i-1=9]存在，既能够不用>=
    {
        printf("\n指定的插入位置不存在！");
        exit(1);
    }
    for (i = slt->size; i > position; i--) {
        slt->a[i] = slt->a[i - 1];
    }
    slt->a[position] = x;
    slt->size++;
}

时间复杂度：\(O(n)\)c++

2.2.3 顺序表的删除操做（算法）

  1. 删除顺序表中第\(i\)个结点的步骤：
    1. 判断顺序表是否为空
    2. 判断删除位置是否存在
    3. 将顺序表中的\(k_{i+1},\cdots,k_{n-1}\)元素依次前移一个位置。（从前日后移）
    4. 顺序表的长度减\(1\)
#define MAXSIZE 100
typedef int datatype;
typedef struct {
    datatype a[MAZXSIZE];
    int size;
} sequence_list;

void dele(sequence_list *slt, int position) {
    int i;
    if (slt->size == 0) {
        pringf("\n顺序表是空的！");
        exit(1);
    }
    if (position < 0 || position >= slt->size) // 如size为10，postion为10，slt->a[i+1=11]不存在，即不能够>
    {
        printf("\n指定的删除位置不存在！");
        exit(1);
    }
    for (i = position; i < slt->size - 1; i++) // 循环到倒数第二个元素便可，由于后面是a[i+1]
    {
        slt->a[i] = slt->a[i + 1];
    }
    slt->size--;
}

时间复杂度：\(O(n)\)算法

3、栈

3.1 栈的基本概念及描述

  1. 栈：特殊的线性表。插入运算和删除运算均在线性表的同一端进行
  2. 栈顶：进行插入（进栈）和删除（出栈）的一端
  3. 栈底：不进行操做的一端
  4. 栈的性质：后进先出（先进后出）
  5. 出栈元素不一样排列个数：\(\frac{1}{n+1}C_{2n}^{n}\)

3.2 顺序栈及其实现

  1. 栈（顺序存储）的经常使用操做：
    1. 栈的存储结构
    2. 栈初始化
    3. 判断栈是否为空
    4. 取得栈顶结点值
    5. 栈的插入操做
    6. 栈的删除操做

3.2.1 顺序栈的存储结构

#define MAXSIZE 100
typedef int datatype;
typedef struct {
    datatype a[MAXSIZE];
    int top;
} sequence_stack;

3.3 栈的应用之一（括号匹配）

  1. 括号匹配解决步骤：
    1. 从左向右扫描表达式
    2. 遇到开括号则将遇到的开括号存放于栈中
    3. 遇到闭括号则查看是否与栈顶结点匹配。匹配删除栈顶结点，不匹配说明表达式中的括号是不匹配的（结束）
    4. 扫描整个表达式后，栈是空的，说明表达式中的括号是匹配的；不然是不匹配的（结束）

3.4 栈的应用之二（算术表达式求值）

  1. 中缀表达式：操做符处于两个操做数之间
  2. 前缀表达式：操做符处于两个操做数以前
  3. 后缀表达式：操做符处于两个操做数以后
  4. 后缀表达式求值：每遇到一个操做符，则将前面的两个操做数执行相应的操做
  5. 后缀表达式求解步骤：
    1. 把遇到的操做数暂存于一个栈中
    2. 遇到操做符，则从栈中取出两个操做数执行相应的操做，并将结果压入栈中
    3. 直到对后缀表达式中最后一个操做符处理完
    4. 最后压入栈中的树就是后缀表达式的计算结果

3.4.1 中缀表达式转换为后缀表达式步骤

  1. 从左到右扫描中缀表达式，若是是数字字符和圆点“.”，直接写入后缀表达式数组

  2. 遇到开括号，将开括号压入栈中，遇到匹配的闭括号，将栈中元素弹出并放入后缀表达式，直到栈顶元素为匹配的开括号时，弹出该开括号post

  3. 遇到的是操做符：spa

    1. 遇到的操做符优先级<=栈顶元素，弹出栈顶元素放入后缀表达式（循环判断）
    2. 遇到的操做符优先级>栈顶元素，将遇到的操做符压入栈中

  4. 重复上述步骤，直到遇到结束标记“#”，弹出栈中的全部元素并放入后缀表达式数组中设计

  5. 操做符优先级：\(\#,(,+-,*/\)指针

-1 0 1 2
# ( +- */

4、队列

4.1 队列的基本概念及描述

  1. 队列：一种特殊的线性表。插入（进队）和删除（出队）操做分别在表的两端进行
  2. 队尾：插入的一端
  3. 对首：删除的一端
  4. 队列的性质：先进先出

4.2 顺序队列及其实现

  1. 队列（顺序存储）的经常使用操做：
    2. 队列初始化
    3. 判断队列是否为空
    4. 打印队列的结点值
    5. 取得队列的队首结点值
    6. 队列的插入操做
    7. 队列的删除操做

4.2.1 顺序队列的存储结构

#define MAXSIZE 100
typedef int datatype;
typedef struct {
    datatype a[MAXSIZE];
    int front;
    int rear;
} sequence_queue;

4.3 顺序循环队列及其实现

  1. 普通队列的列满状态指标：\(rear = MAXSIZE\)
  2. 循环队列的做用：在普通队列处于列满状态时，利用数组前部的空闲位置
  3. 循环队列的列满状态指标：
    1. 设置一个标志：因为\(rear\)增\(1\)使\(rear = front\)，为队满；因为\(front\)增\(1\)使\(rear = front\)，队空
    2. 牺牲一个数组元素空间：\((rear + 1) \% MAXSIZE = front\)，队满；\(rear = front\)，队空
  4. 循环队列（顺序存储）的经常使用操做（相比较普通队列在指针增\(1\)中增长一个取模操做）：
    1. 循环队列的插入操做
    2. 循环队列的删除操做

4.3.1 顺序循环队列的存储结构

#define MAXSIZE 100
typedef int datatype;
typedef struct {
    datatype a[MAXSIZE];
    int front;
    int rear;
} sequence_queue;

5、算法设计题

5.1 顺序表值为x的结点的个数（算法）

设计一个算法，求顺序表中值为x的结点的个数code

算法步骤：队列

  1. 设定初始值\(c\)计数
  2. 每找到一个值为\(x\)的结点，计数加\(1\)
  3. 返回\(c\)
// 顺序表的存储结构定义以下（文件名seqlist.h）
#include <stdio.h>

#define N 100 // 预约义最大的数据域空间
typedef int datatype; // 假设数据类型为整型
typedef struct {
    datatype data[N]; // 此处假设数据元素只包含一个整型的关键字域
    int length; // 线性表长度
} seqlist; // 预约义的顺序表类型

// 算法countx(L, x)用于求顺序表L中值为x的结点的个数
int countx(seqlist *L, datatype x) {
    int c = 0;
    int i;
    for (i = 0; i < L->length; i++) {
        if (L->data[i] == x) c++;
    }
    return c;
}

5.2 顺序表倒置（算法）

设计一个算法，将一个顺序表倒置。即，若是顺序表各个结点值存储在一维数组\(a\)中，倒置的结果是使得数组\(a\)中的\(a[o]\)等于原来的最后一个元素，\(a[1]\)等于原来的倒数第\(2\)个元素，\(\cdots\)，\(a\)的最后一个元素等于原来的第一个元素内存

算法步骤：

  1. 定位最后一个元素
  2. 用\(t\)保留第个一元素的值，而且第一个元素和最后一个元素的值交换
  3. 循环到最后一个元素
// 顺序表的存储结构定义以下（文件名seqlist.h）
#include <stdio.h>

#define N 100 // 预约义最大的数据域空间
typedef int datatype; // 假设数据类型为整型
typedef struct {
    datatype data[N]; // 此处假设数据元素只包含一个整型的关键字域
    int length; // 线性表长度
} seqlist; // 预约义的顺序表类型

// 算法verge(L)用于顺序表倒置
void verge(seqlist *L) {
    int t, i, j;
    i = 0;
    j = L->length - 1;
    while (i < j) {
        t = L->data[i];
        L->data[i++] = L->data[j];
        L->data[j--] = t;
    }
}

5.3 有序顺序表插入结点并仍然有序（真题）（算法）

已知一个顺序表中的各结点值是从小到大有序的，设计一个算法，插入一个值为\(x\)的结点，使顺序表中的结点仍然是从小到大有序

算法步骤：

  1. 从最后一个元素开始与\(x\)比较大小，元素值大于该\(x\)值，则日后挪一个位置
  2. 找到比\(x\)小的元素中止
  3. 在该元素的位置上插入\(x\)值
// 顺序表的存储结构定义以下（文件名seqlist.h）
#include <stdio.h>

#define N 100 // 预约义最大的数据域空间
typedef int datatype; // 假设数据类型为整型
typedef struct {
    datatype data[N]; // 此处假设数据元素只包含一个整型的关键字域
    int length; // 线性表长度
} seqlist; // 预约义的顺序表类型

// 算法insertx(L, x)用于有序顺序表插入结点并仍然有序
void insertx(seqlist *L, datatype x) {
    int j;
    if (L->length < N) {
        j = L->length - 1;
        while (j >= 0 && L->data[j] > x) {
            L->data[j + 1] = L->data[j]; // 元素统一日后挪
            j--;
        }
        L->data[j + 1] = x;
        L->length++;
    }
}

6、错题集

  1. 长为 \(n\) 的顺序表中，任意位置插入的可能次数为n+1​次（包括头前和尾后）

  2. 设栈 \(S\) 和队列 \(Q\) 的初始状态为空，元素 e一、$e\(二、\)e\(三、\)e\(四、\)e$5 和 $e$6 依次经过栈 \(S\)，

    一个元素出栈后即进入队列 \(Q\)，若 6 个元素出队的序列为 $e\(二、\)e\(四、\)e\(三、\)e\(六、\)e$5 和 $e$1，则栈 \(S\)

    的容量至少应该为3​

  3. 编号为 \(1,2,3,4\) 的四列火车经过一个栈式的列车调度站，可能获得的调度结果总共有14种

    1. 使用公式：出栈元素不一样排列个数为 \(\frac{1}{n+1}C_{2n}^{n}\)
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程