数据结构线性表之吐血攻略

原创已于 2024-10-20 21:24:48 修改 · 置顶 · 704 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #链表 #算法

于 2018-10-17 10:42:27 首次发布

数据结构专栏收录该内容

34 篇文章

订阅专栏

这是一篇闲狗写给闲狗看的线性表攻略。

数组（Array）

数组对应于内存的一块连续的存储区域。

数组的插入删除操作都涉及后面元素的挪动。

数组支持随机访问，根据下标随机访问的时间复杂度为 O(1)，插入和删除为 O(n)。

为什么大多数编程语言中，数组要从 0 开始编号，而不是从 1 开始呢？

“下标”最确切的定义应该是“偏移（offset）”。如果用 a 来表示数组的首地址，a[0]就是偏移为 0 的位置，也就是首地址，a[k]就表示偏移 k 个 type_size 的位置，所以计算 a[k]的内存地址只需要用这个公式：

a[k]_address = base_address + k * type_size

但是，如果数组从 1 开始计数，那我们计算数组元素 a[k]的内存地址就会变为：

a[k]_address = base_address + (k-1)*type_size

对比两个公式，我们不难发现，从 1 开始编号，每次随机访问数组元素都多了一次减法运算，对于 CPU 来说，就是多了一次减法指令。

链表（Linked List）

链表：不需要一块连续的内存空间，它通过指针将一组零散的内存块串联起来使用。

我们把内存块称为链表的“结点”。为了将所有的结点串起来，每个链表的结点除了存储数据之外，还需要记录链上的下一个结点的地址，叫作后继指针 next。

单链表（Linked List）

而且单链表并不支持直接获取前驱结点，所以，为了找到前驱结点，我们还是要从头结点开始遍历链表，直到 p->next=q。

把链表想象成一个队伍，队伍中的每个人都只知道自己后面的人是谁，所以当我们希望知道排在第 k 位的人是谁的时候，我们就需要从第一个人开始，一个一个地往下数。所以，链表随机访问的性能没有数组好，需要 O(n) 的时间复杂度。

双链表

双向链表需要额外的两个空间来存储后继结点和前驱结点的地址。所以，如果存储同样多的数据，双向链表要比单链表占用更多的内存空间。虽然两个指针比较浪费存储空间，但可以支持双向遍历，这样也带来了双向链表操作的灵活性。

比如要删除结点 q 时，需要知道其前驱结点，而单链表并不支持直接获取前驱结点，所以，为了找到前驱结点，我们还是要从头结点开始遍历链表，直到 p->next=q，说明 p 是 q 的前驱结点。

但是对于双向链表来说，这种情况就比较有优势了。因为双向链表中的结点已经保存了前驱结点的指针，不需要像单链表那样遍历。所以，针对第二种情况，单链表删除操作需要 O(n) 的时间复杂度，而双向链表只需要在 O(1) 的时间复杂度内就搞定了！

实际使用场景：Java 的 LinkedHashMap

双链表结点类型

template <class T> class Link {
    public:
    T data; // 用于保存结点元素的内容
    Link<T> * next; // 指向后继结点的指针
    Link<T> *prev; // 指向前驱结点的指针
   
    // 给定值和前后指针的构造函数
    Link(const T info, Link<T>* preValue = NULL, Link<T>* nextValue = NULL) {
        data = info;
        next = nextValue;
        prev = preValue;
    }

    //给定前后指针的构造函数
    Link(Link<T>* preValue = NULL, Link<T>* nextValue = NULL) {
        next = nextValue;
        prev = preValue;
    }
}

插入结点

经理p将一些设备分配给新来的员工q，

q再将自己的一些信息告诉经理p

1（华文课后题）完成在双循环链表结点p之后插入s的操作为AD

A、p->next->prev=s; s->prev=p; s->next=p->next; p->next=s; (4,2,1,3)

B、p->next->prev=s; p->next=s; s->prev=p; s->next=p->next;(4,3,2,1)

解析：造成原来的p结点后来的next信息丢失

C、s->prev=p; s->next=p->next; p->next=s; p->next->prev=s;(2,1,3,4)

解析：先更改p->next成s再更改p->next->prev，会造成原来的p结点后来的next信息丢失

D、s->next=p->next; p->next->prev=s; s->prev=p; p->next=s;(1,4,2,3)

删除结点

1 （2016计算机联考真题）

循环链表

与单链表相比，循环链表的优点是从链尾到链头比较方便。当要处理的数据具有环型结构特点时，就特别适合采用循环链表。

静态链表

借助数组来描述线性表的链式存储结构，结点也有数据域data和指针域next。不同的是，这里的指针是结点的相对地址（数组下标），又称为游标。

与顺序表一样，静态链表也要预先分配一块连续的内存空间。

栈

栈的实现方式

顺序栈（Array-based Stack）

链式栈（Linked Stack）

共享栈

栈的应用-四则运算表达式求值

后缀表达式

后缀表达式：运算符号位于两个运算数之后。

用堆栈实现后缀表达式求值：

运算数：入栈
运算符：从栈中弹出最前的两个数，计算并将结果入栈
栈顶上的元素就是表达式的结果值

例：

漫画乱入，纯属娱乐。

中缀表达式

中缀表达式：运算符号位于两个运算数之间。

中缀表达式求值：将中缀表达式转换为后缀表达式，然后求值。

中缀表达式转换为后缀表达式：

从头到尾读取中缀表达式的每个对象
运算数：直接输出
左括号：压入堆栈
右括号：将栈顶的运算符弹出并输出，知道遇到左括号（出栈，括号不输出）
运算符：

若优先级大于栈顶运算符时，把它压栈
若优先级小于栈顶运算符时，将栈顶运算符弹出并输出，而它进栈
若各对象处理完毕，则把堆栈中存留的运算符一并输出

队列

队列的实现方式

顺序队列

例子：假设现在顺序队列Q分配了6个空间

(1) 开始时为空队，Q.front=Q.rear

(2) 元素a1进队，放入尾指针Q.rear（整型下标）的位置，Q.rear后移一位

(3) 元素a2进队，放入尾指针Q.rear（整型下标）的位置，Q.rear后移一位

(4) 元素a3，a4，a5分别按顺序进队，尾指针Q.rear依次后移

(5) 元素a1出队，头指针Q.front（整型下标）后移一位

(6) 元素a2出队，头指针Q.front（整型下标）后移一位

(7) 元素a6进队，放入尾指针rear（整型下标）的位置，rear后移一位

(8) 元素a7进队，此时尾指针Q.rear已经超过了数组的下标，无法再存储进队，但是我们发现前面明明有2个空间，却出现了队满的情况，这种情况称为"假溢出"。

那么如何解决该问题呢？

能否利用前面的空间继续存储入队呢？

循环队列

上面第（7）步元素a6进队之后，尾指针Q.rear要后移一个位置，此时已经超过了数组的下标，即Q.rear+1=Maxsize（最大空间数6），那么如果前面有空闲，Q.rear可以转向前面0的位置

然后元素a7进队，放入尾指针Q.rear（整型下标）的位置，Q.rear后移一位

元素a8进队，放入尾指针Q.rear（整型下标）的位置，Q.rear后移一位

这时候虽然队列空间存满了，但是出现了一个大问题，队满时Q.front=Q.rear，这和队空的条件一模一样，无法区分队空还是队满，如何解决呢？有两种办法：一是设置一个标志，标记队空和队满；另一种办法是浪费一个空间，当尾指针Q.rear的下一个位置Q.front是时，就认为是队满。如图所示：

上述到达尾部又向前存储的队列称为循环队列，为了避免"假溢出"，我们通常采用循环队列。

循环队列无论入队还是出队，队尾、队头加1后都要取模运算，例如入队后队尾后移一位：Q.rear =(Q.rear+1)%Maxsize。

为什么要%Maxsize呢？

主要是为了处理临界状态，即Q.rear向后移动一个位置Q.rear+1后，很有可能超出了数组的下标，这时它的下一个位置其实是0，如果将一维数组画成环形图，如图所示：

上图中最大空间Maxsize，当Q.rear=Maxsize-1时，(Q.rear+1)%Maxsize=0，而且Q.front=0，正好满足队满的条件：(Q.rear+1) %Maxsize= Q.front，此时为队满。

因此无论是front还是rear向后移动一个位置时，都要加1与最大空间Maxsize取模运算，处理临界问题。

总结：

队空：Q.front=Q.rear; // Q.rear和Q.front指向同一个位置

队满： (Q.rear+1) %Maxsize=Q.front; // Q.rear向后移一位正好是Q.front

入队：

Q.base[Q.rear]=x; //将元素放入Q.rear所指空间

Q.rear =( Q.rear+1) %Maxsize; // Q.rear向后移一位

出队：

e= Q.base[Q.front]; //用变量记录Q.front所指元素

Q.front=(Q.front+1) %Maxsize // Q. front向后移一位

循环队列中包含的元素个数：

链式队列

2.2.4 双端队列

双端队列可以在队列任意一端入队和出队。将队列的两端分别称为前端和后端。

（1）输出受限的双端队列

允许在一端进行入队和出队，在另一端只允许入队。

（2）输入受限的双端队列

允许在一端进行入队和出队，在另一端只允许出队

漫画乱入，甭管我。

队列的应用

队列在计算机系统中的应用

本文参考自：

张铭《数据结构与算法》

程杰《大话数据结构》

陈越，何钦铭《数据结构》