数据结构笔记|C++

最新推荐文章于 2024-03-05 22:26:10 发布
最新推荐文章于 2024-03-05 22:26:10 发布
阅读量485 收藏 7
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48856795/article/details/120399098
版权
这篇博客详细介绍了C++实现的数据结构，包括线性表、栈、队列、字典、二叉树的遍历和操作，以及树、图的概念和遍历算法。还涉及了排序算法如插入排序、冒泡排序、堆排序等，并提到了二叉检索树、哈夫曼树、堆和优先队列等相关内容。
摘要由CSDN通过智能技术生成

1.数据结构与算法

2.数学预备知识

3.算法分析

4.线性表、栈和队列

4.1线性表

4.1.1线性表ADT（C++中ADT以抽象类实现）

#include<iostream>
using namespace std;

template<typename E>
class List{
   
private:
    void operater =(const List&){
   };
    List(const List&){
   };
public:
    List(){
   };
    virtual ~List(){
   };

    virtual void clear()=0;

    virtual void insert(const E& item)=0;

    virtual void append(const E& item)=0;
    
    virtual E remove()=0;

    virtual void moveToStart()=0;

    virtual void moveToEnd()=0;

    virtual void prev()=0;

    virtual void next()=0;

    virtual int length() const =0;

    virtual int currPos() const =0;

    virtual void moveToPos(int Pos)=0;

    virtual const E& getValue() const =0;

};

bool find(Link<int>& L,int k)//find单独实现
{
   
    int it;
    for(L.moveToStart();L.currPos()<L.length();L.next()){
   
        it=getValue();
        if(k==it)
            return true;
    }
    return false;
}

4.1.2顺序表的实现：

//顺序表的实现
template<typename E>
class AList:public List<E>{
   
private:
    int maxSize;
    int listSize;
    int curr;
    E* listArray;
public:
    Alist(int size=defaultSize){
   //constrcutor
        maxSize=size;
        listSize=curr=0;
        listArray = new E[maxSize];
    }

    ~AList(){
   delete [] listArray;}//destructor

    //Insert "it" at current position
    void insert(const E& it){
   
        Assert(listSize<maxSize,"list capacity exceeded");
        for(int i=listSize;i>curr;i--){
   
            listArray[i]=listArray[i-1];
        }
        listArray[curr]=it;
        listSize++;
    }

    void append(const E& it){
   //Append "it"
        Append(listSize<maxSize,"List capacity exceed");
        listArray[listSize++]=it;
    }
    
    //Remove and return the current element
    E remove(){
   
        Assert((cur>=0)&&(cur<listSize),"No element");
        E it = listArray[curr];
        for(int i=curr;i<listSize-1;i++)
            list[i]=list[i+1];
        listSize--;
        return it;
    }

    void moveToStart(){
   curr=0};
    void moveToEnd(){
   curr=listSize-1};
    void prev(){
   if(curr>0) curr--};
    void next(){
   if(curr<listSize) curr++};//可以是12|13->12 13|

    int length() const {
   return listSize;}

    int currPos() const{
   return curr};

    void moveToPos(int pos){
   
        Assert(pos>=0&&pos<=listSize,"Pos out of range");
        curr=pos;
    }

    const E& getValue() const{
   //return the current element
        Assert(curr>=0&&curr<listSize,"No element");
        return listArray[curr];
    }
};

4.1.3链表实现

//链表实现Linked list implementation
template<typename E>
class Link{
   
private:
    E element;
    Link *next;

    //constructors
    Link(const E& e,Link* p=NULL){
   element=e;next=p;}
    Link(Link* p=NULL){
   next=p;}
};

template<typename E> 
class LList:public List<E>{
   
private:
    Link<E>* head;
    Link<E>* tail;
    Link<E>* curr;
    int cnt;//size of list

    void init(){
   //Initialization helper method
        head=tail=curr=new Link<E>;
        cnt=0;
    }

    void removeall(){
   //Return link nodes to free store
        while(head!=NULL){
   
            curr=head;
            head=head->next;
            delete curr;
        }
    }

public:
    LList(int size=defaultSize){
   init();}
    ~LList(){
   removeall();}

    void print(){
   };
    void clear(){
   removeall();init();}

    void insert(const E& it){
   
        Link<E>* p=new Link<E>;
        p->element=it;
        p->next=curr->next;
        curr->next=p;

        if(tail==curr)
            tail=curr->next;
        cnt++;
    }

    void append(const E& it){
   
        tail->next=new Link(it,NULL);
        tail=tail->next;
        cnt++;
    }

    E remove(){
   
        Assert(curr->next!=NULL,"No element");
        Link<E>* temp=curr->next;
        E it=curr->next->element;
        if(tail==curr->next)//Reset tail
            tail=curr;
        curr->next=curr->next->next;
        delete temp;
        cnt--;
        return it;
    }

    void moveToStart(){
   curr=head;}
    void moveToEnd(){
   curr=tail;}

    void prev(){
   
        if(curr=head)return;
        Link<E>* temp=head;
        while(temp->next!=curr)temp=temp->next;
        curr=temp;
    }

    void next(){
   
        if(curr==tail)return;
        curr=curr->next;
    }

    int length() const{
   return cnt;}

    int currPos() const{
   
        Link<E>* temp=head;
        int i;
        for(i=0;temp!=curr;i++)
            temp=temp->next;
        return i;
    }

    void moveToPos(int pos){
   
        Assert(pos>=0&&pos<=cnt,"Position out of range");
        curr=head;
        for(int i=0;i<=pos;i++)
            curr-curr->next;
    }

    const E& getValue() const{
   
        Assert(curr->next!=NULL,"No value");
        return curr->next->element;
    }
};

4.1.4freelists可利用空间表

//链表实现Linked list implementation
template<typename E>
class Link{
   
private:
    E element;
    Link *next;

    //constructors
    Link(const E& e,Link* p=NULL){
   element=e;next=p;}
    Link(Link* p=NULL){
   next=p;}


    //Freelists
    //Linked list implementation
    //没有头结点，只对头指针操作，头插法
    static Link<E>* freelist;

public:
    void* operator new(size_t){
   //overload new
        if(freelist==NULL)return ::new Link;
        Link<E>* temp=freelist;
        freelist=freelist->next;
        return temp;
    }

    void operator delete(void* ptr){
   
        (Link<E>*)ptr->next=freelist;
        freelist=((Link<E>*)ptr);
    }
};

//The freelist head pointer is actually created here
template<typename E>
Link<E>* Link<E>::freelist=NULL;

4.1.5 双链表

//Doublely Linked List implementation
template<typename E>
class DLink{
   
private:
    static DLink* freelist;
public:
    E element;
    DLink<E>* next;
    DLink<E>* prev;

    DLink(const E& e,DLink<E>* n=NULL,DLink<E>* p=NULL){
   
        element=e;
        next=n;
        prev=p
    }

    DLink(DLink<E>* n=NULL,DLink<E> p=NULL){
   
        next=n;
        prev=p;
    }

    void* operator new(size_t){
   //overload new
        if(freelist==NULL)return ::new Link;
        Link<E>* temp=freelist;
        freelist=freelist->next;
        return temp;
    }

    void operator delete(void* ptr){
   
        (Link<E>*)ptr->next=freelist;
        freelist=((Link<E>*)ptr);
    }
};

template<typename E>
DLink<E>* DLink<E>::freelist=NULL;

template<typename E>
class DList:public List{
   
private:
    DLink<E>* head;
    DLink<E>* curr;//还是指当前节点的上一个
    DLink<E>* tail;//双链表包含尾结点
    int cnt;
public:
    // void insert(const E& it){
   
    //     curr->next=curr->next->prev=new DLink(it,curr,curr->next);
    //     cnt++;
    // }

    void insert(const E& it){
   
        DLink<E>* temp=new DLink<E>(it);
        curr->next->prev=temp;
        temp->next=curr->next;
        temp->prev=curr;
        curr->next=temp;
        cnt++;
    }
    // void append(const E& it){
   
    //     tail->prev->next=tail->prev=new DLink(it,tail->prev,tail);
    //     cnt++;
    // }
    void append(const E& it){
   
        DLink<E>* temp=new DLink<E>(it);
        tail->prev->next=temp;
        temp->prev=tail->prev;
        temp->next=tail;
        tail->prev=temp;
        cnt++;
    }

    E remove(){
   
        if(curr->next==tail)
            return NULL;
        DLink<E>* it=curr->next;
        E it=it->element;
        curr->next->next->prev=curr;
        curr->next=curr->next->next;
        delete it;
        cnt--;
        return it;
    }

    void prev(){
   if(curr!=head)curr=curr->prev;}

};

4.2 栈

4.2.1栈ADT

#include<bits/stdc++.h>
using namespace std;
//Stack ADT
//Stack avstract class
template<typename E>
class Stack{
   
private:
    void operator=(const Stack&){
   };
    Stack(const Stack&){
   };

public:
    Stack(){
   };
    virtual void clear()=0;
    virtual void push(const E& it)=0;
    virtual E pop()=0;
    virtual const E& top() const =0;
    virtual int length()=0;
};

4.2.2数组实现

//Array-based stack implementation
template<typename E>
class AStack:public Stack<E>{
   
private:
    int maxSize;
    int top;//index for the top element +1
    E* listArray;
public:
    AStack(int size=defaultSize){
   
        maxSize=size;
        top=0;
        listArray=new E[size];
    }
    ~AStack(){
   delete[]listArray;}

    void clear(){
   top=0;}

    void push(const E& it){
   
        Assert(top!=maxSize,"Stack is full");
        listArray[top++]=it;
    }

    E pop(){
   
        Assert(top!=0,"No element");
        return listArray[--top];
    }

    const E& top(){
   
        Assert(top!=0,"Stack is empty");
        return listArray[top-1];
    }
    int <
最低0.47元/天 解锁文章
Saint Gut-Free
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构笔记（C++实现）
qq_36028321的博客
05-13 409
数据结构笔记（大话数据结构）**序**1、数据结构绪论基本术语2、算法2.1、算法的特性2.2、算法的设计要求 序 这是我的第一篇在网络上记载的笔记，实是记录在学习过程中的一些心得体会。毕竟逐渐的发现学习的过程中没有记录，即使当时认真学过，一段时间之后就会变成过眼云烟。本科学了几年机械，从无感到热爱再到这个专业成为别人口中的笑柄。回头想想，其实错不在某个专业学什么，也不在这个专业下的学生，只是风向不同而已。在此之前，已经学习过吴恩达的ml和黑马的c++，虽然课是听完了，但也就大致摸索到个概念而已。并不是说这
【学习笔记】CH5 Binary Trees | Data Structure& Algorithm Analysis in C++（ed. 3)
TemperanceH的博客
03-30 225
Definitions and Properties Nodes, subtrees. Ancestors and descendants 后代和前面点的关系 Parent and child. 直接的上下关系
数据结构笔记（c++版，期末复习）
basai123的博客
02-15 6607
期末复习时前写的数据结构笔记
C++学习笔记——数据结构
starvapour的博客
01-04 1273
C++学习笔记——数据结构0. begin()、front()、end()、back()1. a[5] 数组（长度固定，连续存储）2. string 字符串3. Array 数组（长度固定，连续存储）4. vector 向量（长度可变，连续存储）5. list 列表（长度可变，不连续存储）6. unordered_map 哈希表 记录c++学习中的常用数据结构容器，以及它们的常用方式。 如有错误，欢迎指出帮助修正。
c++ swap函数_C++基础函数模板
weixin_39832875的博客
11-21 329
“千里之行始于足下”01 前言我们知道C++作为一种强类型语言，有强类型语言可靠安全的优势。但有时实现一些相对简单的函数似乎是个障碍，比如我们要实现swap、min、max这些函数的时候，强类型语言要求我们为所有希望比较的类型都实现一个实例，那似乎是很繁琐无趣的，当然我们可以通过定义宏来实现，比如：#define min(a,b) ((a) < (b) ? (a)...
数据结构笔记(C++版)
01-20
本篇将详细介绍《数据结构笔记(C++版)》中的关键知识点，帮助读者深入理解数据结构的基础概念及其在C++中的实现。 #### 二、数据结构的核心概念 1. **数据**: 能够被计算机处理的各种符号的集合，包括数字、字符、...
C++及数据结构复习笔记
07-31
是本人博客部分内容的整合，《C++及数据结构复习笔记》的第一章到第15章的部分。由于只校对了一次，在所难免存在表达不合适的地方，还有可能存在错别字。 该复习文档是本人根据谭浩强老师的《C++程序设计》、邓俊辉...
C++数据结构与算法学习笔记
11-22
### C++数据结构与算法学习笔记 #### 第1章 数据结构和算法 ##### 主要目的 本章的主要目的是为了帮助读者构建一个扎实的基础，以便更好地理解和应用数据结构与算法。具体来说，它包括以下几个方面： 1. **学习...
数据结构笔记(C++版)_面试_C++_singleo2t_数据结构_
10-02
总之，这份“数据结构笔记(C++版)”将带你深入了解C++中的数据结构，包括其内在逻辑、实现方法以及在面试中的应用。通过学习，你将能够更好地解决实际问题，提升编程能力，为成为一名C++大神奠定坚实基础。
数据结构笔记附算法c和c++代码资源
最新发布
08-13
本资源简介将带你探索《数据结构笔记附算法c和c++代码》——一本结合理论深度与实践应用的宝典，旨在提升你的编程内功至新高度。 首先，让我们以数据说话：《数据结构笔记附算法c和c++代码》涵盖了逾80%的常用数据...
C++数据结构笔记
qq_45948139的博客
04-20 224
C++数据结构与算法1.顺序表 1.顺序表 #include <iostream> #include <cstring> using std::cout; using std::endl; template <typename Type> class Vector { private: int size, length; Type *data; public: Vector(int input_size) { //构造函数 size
数据结构C++笔记
codespad的专栏
03-04 428
基础要打牢，重学一下数据结构。 第一章 递归函数 对于函数f (n) 的一个递归定义（假定是直接递归） ，要想使它成为一个完整的定义，必须 满足如下条件： • 定义中必须包含一个基本部分（b a s e） ，其中对于n 的一个或多个值，f  (n)必须是直接定 义的（即非递归） 。为简单起见，我们假定基本部分包含了n≤k 的情况，其中k 为常数。 （在基 本部分中指定n≥k 的情
C++数据结构笔记总结
2401_82760887的博客
03-05 1501
顺序结构：程序按照顺序执行，不发生跳转选择结构：依据条件是否满足，有选择地执行相应功能循环结构：依据条件是否满足，循环多次执行某段代码。
C++学习笔记-数据结构
cuihwchn的博客
02-24 441
C++学习笔记-数据结构
2.复杂性、队列和堆栈
qq_33768452的博客
01-03 329
萌新级数据结构教程
数据结构（c++）学习笔记--图
VaIOReTto1的博客
01-27 415
数据结构学习笔记的一部分，主要用于个人记忆和复习，在代码和编辑习惯上也倾向于本人特点，主要专注于能读性和简便性。
算法笔记_2022
圣无肠的博客
02-17 118
无
C++数据结构详解与程序员实战笔记
本资源是一份资深程序员关于C++数据结构的笔记，专为初学者设计，旨在帮助他们掌握基础的C++数据结构编程技巧和注意事项。内容覆盖了软考指南中涉及的核心知识点，包括： 1. 数据结构基础知识：对象定义、存储表示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值