Loading...

数据结构与算法（三）——列表

数据结构与算法（三）——列表
　　iwehdio的博客园：https://www.cnblogs.com/iwehdio/
Github：https://github.com/iwehdio/DSA_THU_DJH_asJava

导图

列表的Java实现见：https://www.cnblogs.com/iwehdio/p/12621460.html

1、列表的定义

  • 静态与动态：

    • 操作的静态与动态：
      • 静态：仅读取，数据结构的内容与组成一般不变。
      • 动态：需写入，数据结构的局部或整体将改变。
    • 数据元素存储与组织方式的静态与动态：
      • 静态：数据空间整体创建或销毁，数据元素的物理存储词语与其逻辑次序一致。 静态操作高效，动态操作相对低效。如向量。
      • 动态：为各数据元素单独分配和回收物理空间。逻辑上相邻的元素记录彼此的物理地址，在逻辑上形成一个整体。动态操作高效，静态操作相对低效。如列表。

  • 列表：采用动态存储的典型结构。

    • 每个元素称为节点（ node ）。
    • 各个节点通过指针或引用彼此联接，在逻辑上构成一个线性序列。
    • 相邻节点彼此互称前驱和后继。如果存在前驱和后继，那么必然是唯一的。
    • 没有前驱的节点称为首，没有后继的节点称为末。此外，可以认为头存在一个哨兵前驱称为头，末存在一个哨兵后继称为尾。
    • 可以认为 头、首、末、尾 节点的秩分别为 -1、0、n-1、n。
    • 在访问时尽量不使用循秩访问，而使用循位置访问。即利用节点之间的相互引用，找到特定的节点。

  • 列表元素的ADT接口：

  • 列表节点：ListNode 模板类。

    #define Posi(T) ListNode<T>*	//定义指向列表节点的数据类型(节点位置)
template <typename T>
struct ListNode{
    T data;			//数值内容
    Posi(T) pred;	//前驱
    Post(T) succ;	//后继
    ListNode() {}	//针对头尾哨兵的无参构造
    ListNode(T e, Posi(T) p=null, Posi(T) s=null)
        : data(e), pred(p), succ(s) {}	//默认构造器
    Posi(T) insertAsPred(T const& e);	//前插入
    Posi(T) insertAsSucc(T const& e);	//后插入	
}

  • 列表的ADT接口：

  • 列表：List 模板类：

    #include "ListNode.h"	//引入列表节点类
template <typename T>
class List {
private:	int _size;
    		Posi(T) header; Posi(T) trailer;	//头尾哨兵
protected:	/*内部函数*/
public:		/*构造函数、析构函数、对外的接口函数等*/
}

  • 列表的初始化函数：

    template <typename T>
void List<T>::init() {
    header = new ListNode<T>;	//创建头尾哨兵节点
    trailer = new ListNode<T>;
    header -> succ = trailer;	//互联元素
    header -> pred = null;
    trailer -> pred = header;
    trailer -> succ = null;
    _size = 0;		//记录规模
}

2、无序列表的操作

  • 循秩访问：

    • 列表也可以模仿向量的循秩访问（通过重载下标运算符）。

    • 但是效率比较低，时间复杂度为 O(n) 。

    • 实现：

      template <typename T>
T List<T>::operator[](Rank r) const {
    Posi(T) p = first();	//从首节点出发
    while(0 < r++) p = p->succ;		//顺数第r个节点
    return p ->data;
}

  • 查找操作：

    • 定义：在指定节点 p （可能为尾哨兵）的 n 个真前驱中找到等于 e 的最后者。

    • 实现：

      template <typename T>
Posi(T) List<T>::find(T const& e, int n, Posi(T) p) const {
    while(0 < n--)	//从右到左逐个比较，直到命中或越界
        if(e == (p = p->pred)->data) return p;
    return null;
}

  • 插入操作（以前插入为例）：

    • 创建一个新节点 e ，并将其作为 p 的前驱插入。

    • 创建新节点e，前驱是 p 的原前驱，后继是 e。设 p 的原前驱的后继是 e，p 的新前驱是 e。

    • 实现：

      template <typename T>
Posi(T) List<T>::insertBefore(Posi(T) p, T const& e){
    _size++;
    return p->insertAsPred(e);	//把e当作p的前驱插入
}

template <typename T>
Posi(T) ListNode<T>::insertAsPred(T const& e){
    Posi(T) x = new ListNode(e, pred, this);	//创建新节点e，前驱是p的原前驱，后继是e
    pred->succ = x;		//p的原前驱的后继是e
    pred = x;		    //p的新前驱是e
    return x;	//返回新节点的位置
}

  • 基于复制的构造：

    • 创建一个空列表，然后将传入的自 p 节点开始的 n 项依此作为末节点插入。

    • 实现：

      template <typename T>
void List<T>::copyNodes(Post(T) p, int n){
    init();		//初始化空列表
    while(n--){
        //insertAsLast(p->data)实际上就是insertBefore(trailer, p->data)
        insertAsLast(p->data);
        p = p->succ;
    }
}

  • 删除操作：

    • 传入所要删除的 p 处的节点。

    • 将 p 的前驱的新后继赋值为 p 的原后继，将 p 的后继的新前驱赋值为 p 的原前驱。

    • 实现：

      template <typename T>
T List<T>::remove(Posi(T) p){
    T e = p->data;
    p->pred->succ = p->succ;	//将p的前驱的新后继赋值为p的原后继
    p->succ->pred = p->pred;	//将p的后继的新前驱赋值为p的原前驱。
    delete p;
    _size--;
    return e;	//返回被删除的值
}

  • 析构操作：

    • 首先删除所有可见节点，然后删除头尾哨兵。

    • 删除可见节点通过反复删除首节点直到规模为 0 实现。

    • 实现：

      template <typename T>
List<T>::~List()	//列表析构
{
    clear();
    delete header;
    delete trailer;
}

template <typename T>
int List<T>::clear(){
    int oldSize = _size;
    while(0 < _size){
        remove(header->succ);
    }
    return oldSize;
}

  • 列表的唯一化：

    • 删除无序列表中的重复节点。

    • 从首节点开始，依此寻找其前驱中是否有重复节点。使得向后扩展时，搜索节点的前驱总是无重复的，这样就只需比对该搜索节点在前驱中是否有雷同项。

    • 实现：

      template <typename T>
int List<T>::dedupicate(){
    if(_size < 2) return 0;
    int oldSize = _size;
    Posi(T) o = first();	//从首节点开始
    Rank r = 1;
    while(trailer != (p = p->succ)){
        Posi(T) q = find(p->data, r, p);	//在p的r个真前驱中，有没有雷同的
        q ? remove(q) : r++;	//如果有雷同的就移除前驱中雷同的项，否则将不雷同的前驱向后扩展一项
    }
    return oldSize - _size;		//返回被删除的元素数
}

  • 有序列表的唯一化：

    • 删除有序列表中的重复节点。

    • 由于有序，如有雷同则必定是紧邻在一个区段中的。

    • p 指向每个区段的第一个节点，删除与之相同的后继。如果出现不相同的后继，则 p 指向这个后继。

    • 实现：

      template <typename T>
int List<T>::uniquify(){
    if(_size < 2) return 0;
    int oldSize = _size;
    ListNodePosi(T) p = first();	//p初始化为首节点，p为每个区段的首节点
    ListNodePosi(T) q = p->succ;	//q为各个区段中p的后继
    while(trailer != (q->succ)){	//考察紧邻的节点对
        if(p->data != q->data){
            p = q;
        } else {
            remove(q);
        }
        q = p->succ;
    }
    return oldSize - _size;
}

    • 时间复杂度为 O(n)。

  • 有序列表查找操作：

    • 与无序向量的查找算法完全相同，在效率上并没有提高，这是由列表的循位置访问的特点决定的。

3、选择排序与插入排序

  • 选择排序：

    • 选取所有元素中最大的放在列表末，然后再选择剩下的元素中最大的放在末的前驱位置，反复执行。也就是说，每次选择出剩余集合中的最大值。

    • 冒泡排序就是一种选择排序，但是由于每次只进行相邻元素的位置交换，导致效率很低。

    • 改进思路：将序列分为前缀无序子序列 U 和后缀有序子序列 L ，其中 L 中的元素大于等于 U 中的元素。在每次迭代中，选取 U 中最大的元素，并将其移动至 L 的最前端。

    • 实现：

      template <typename T>
void List<T>::selectionSort(Posi(T) p, int n){
    Posi(T) head = p->pred;
    Posi(T) tail = p;
    for(int i=0; i<n; i++)	
        tail = tail->succ;	//待排序区间为(head,tail)
    //从待排序区间内找出最大者，将其从原位置删除并插入tail的位置，然后将tail前移，，待排序区间宽度-1
    while(1 < n){
        //insertBefore()和remove()虽然可以认为时O(1)时间，但由于使用了动态内存分配，会使效率大大降低。实际上更倾向于进行节点数据域的交换
        insertBefore(tail, remove(selectMax(head->succ, n)));
        tail = tail->pred;
        n--;
    }
}

template <typename T>	//获取起始于p的n个元素的最大值，画家算法
Posi(T) List<T>::selectMax(Posi(T) p, int n){
    Posi(T) max = p;	//初始化p为最大
    for(Posi(T) cur=p; 1<n; n--){
        //后续节点与max逐一比较，!lt(a，b)比较器表示a不小于（not less than，即>=）b时
        if(!lt((cur=cur->succ)->data, max->data){
            max = cur;
        }
    }
    return max;
}

    • 时间复杂度总是 Θ(n^2)，没有最好和最坏情况。但是与冒泡排序相比元素移动操作大大减少。

  • 插入排序：

    • 将整个序列分为前缀有序序列 [ 0, r ) 和后缀无序序列 [ r, n)，然后将第 r 个元素插入到前缀有序序列中的合适位置，使得前缀有序序列仍然有序并且规模加一。

    • 与选择排序的区别：选择排序中无序部分中元素总小于有序部分，而插入排序无此限制；而且因此选择排序的操作对象为无序部分中的最大值，而插入排序的操作对象为无序部分与有序部分交界的元素。

    • 实现：

      template <typename T>
void List<T>::insertionSort(Posi(T) p, int n){
    for(int r=0; r<n; r++){		//r实际上就是有序前缀序列的长度
        //每次在search()返回的位置插入，然后删除原位置上的节点
        insertAfter(search(p->data, r, p), p->data);
        p = p->succ;
        remove(p->pred);
    }
}

    • 时间复杂度：最好 O(n)，最差 O(n^2)，平均复杂度为 O(n^2)。

    • 逆序对：两个元素前大后小。

      • 如果 a、b 是一个逆序对( a>b )，我们将 b 所对应的逆序对数加一。也就是某个元素对应逆序对数，记为其作为逆序对中较右、较小的角色的逆序对数量。
      • 对于插入排序，列表的逆序对数就表征了所要进行的比较次数。最好情况下，列表为顺序的，逆序对数为 0 。最差情况下，列表为逆序的，逆序对数为 n^2。时间复杂度为插入时间加比较时间，比较时间最好为 0，最差为 O(n^2)；插入时间为 O(n)。则总得复杂度为最好 O(n)，最差 O(n^2)。
      • 插入排序的时间复杂对依赖于输入序列的逆序对数，是输入敏感的。

参考：数据结构与算法（清华大学C++描述）：https://www.bilibili.com/video/av49361421


iwehdio的博客园：https://www.cnblogs.com/iwehdio/

posted @ 2020-02-10 11:33  iwehdio  阅读(374)  评论(0)  编辑  收藏  举报