C++数据结构笔记

最新推荐文章于 2023-01-16 15:11:57 发布
最新推荐文章于 2023-01-16 15:11:57 发布
阅读量222 收藏 2
点赞数
分类专栏： C++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45948139/article/details/115913055
版权

C++数据结构

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 = input_size;
        length = 0;
        data = new Type[size];
    }
    ~Vector() { // 析构函数
        delete[] data;
    }
    bool insert(int loc, Type value) { // 插入函数
        if (loc < 0 || loc > length) {
            return false;
        }
        if (length >= size) {
            expand();
        }
        for (int i = length; i > loc; --i) {
            data[i] = data[i - 1];
        }
        data[loc] = value;
        length++;
        return true;
    }
    void expand() { // 扩容函数
        Type *old_data = data;
        size = size * 2;
        data = new Type[size];
        for (int i = 0; i < length; ++i) {
            data[i] = old_data[i];
        }
        delete[] old_data;
    }
    int search(const Type &value) { //搜索函数
        for (int i = 0; i < length; ++i) {
            if (data[i] == value) {
                return i;
            }
        }
        return -1;
    }
    bool remove(int index) { //删除函数
        if (index < 0 || index >= length) {
            return false;
        }
        for (int i = index + 1; i < length; ++i) {
            data[i - 1] = data[i];
        }
        length = length - 1;
        return true;
    }
    void print() { //打印输出函数
        for(int i = 0; i < length; i++){
            if(i > 0){
                cout << " ";
            }
            cout << data[i];
        }
        cout << endl;
    }
};
int main() {
    Vector<int> a(100);
    cout << a.insert(0, 1) << endl;
    cout << a.insert(0, 2) << endl;
    a.print();
    cout << a.remove(1) << endl;
    a.print();
    cout << a.search(0) << endl;
    cout << a.search(1) << endl;
    return 0;
}

2.链表

#include <iostream>
#include<iostream>
using namespace std;

template <typename Type> class Node {
public:
    Type data;
    Node<Type> *next;
    Node(const Type &_data){
        data = _data;
        next = NULL;
    }
};
template <typename Type> class LinkedList {
private:
    Node<Type> *head;
public:
    LinkedList() {
        head = NULL;
    }
    ~LinkedList() {
        Node<Type> *current_node = head;
        while(current_node != NULL){
            Node<Type> *delete_node = current_node;
            current_node = current_node->next;
            delete delete_node;
        }
    }
    bool insert(Node<Type> *node, int index) {
        if(head == NULL){
            if(index != 0){
                cout << "failed" << endl;
                return false;
            }
            head = node;
            cout << "success" << endl;
            return true;
        }
        if(index == 0){
            node->next = head;
            head = node;
            cout << "success" << endl;
            return true;
        }
        Node<Type> *current_node = head;
        int count = 0;
        while (current_node->next != NULL && count < index - 1){
            current_node = current_node->next;
            count++;
        }
        if(count == index - 1){
            node->next = current_node->next;
            current_node->next = node;
            cout << "success" << endl;
            return true;
        }else{
            cout << "failed" << endl;
            return false;
        }
    }
    void output() {
        Node<Type> *current_node = head;
        while(current_node != NULL){
            if(current_node != head)cout << " ";
            cout << current_node->data;
            current_node = current_node->next;
        }
        cout << endl;
    }
};
int main() {
    LinkedList<int> linkedlist;
    int a, b, c;
    cin >> a;
    for(int i = 0; i < a; i++){
        cin >> b >> c;
        Node<int> *node = new Node<int>(c);
        linkedlist.insert(node, b);
    }
    linkedlist.output();
    return 0;
}

链表删除

// 请在下面实现删除结点方法 delete_node
void delete_node(int index){
    if(head == NULL){
        return ;
    }
    Node<Type> *current_node = head;
    int count = 0;
    if(index == 0){
        head = head->next;
        delete current_node;
        return;
    }
    while(current_node->next != NULL && count < index - 1){
        current_node = current_node->next;
        count++;
    }
    if(count == index - 1 && current_node->next != NULL){
        Node<Type> *delete_node = current_node->next;
        current_node->next = delete_node->next;
        delete delete_node;
    }
}

链表反转

// 请在下面实现链表的反转方法 reverse
    void reverse(){
        if(head == NULL){
            return ;
        }
        Node<Type> *next_node, *current_node;
        current_node = head->next;
        head->next = NULL;
        while(current_node != NULL){
            next_node = current_node->next;//记录流动结点的下一个结点
            current_node->next = head;//将流动结点前面的链接入流动结点
            head = current_node;//将链表头更新为当前的流动结点
            current_node = next_node;//更新流动结点为下一个结点
        }
    }

3.队列

#include <iostream>
using std::cout;
using std::endl;
template <typename Type> class Queue {
private:
    Type *data;
    int head, tail, length;
public:
    Queue(int length_input) {
        data = new Type[length_input];
        length = length_input;
        head = 0;
        tail = -1;
    }
    ~Queue() {
        delete[] data;
    }
    bool push(Type element) {
        if (tail + 1 >= length) {
            return false;
        }
        tail++;
        data[tail] = element;
        return true;
    }
    void output() {
        for (int i = head; i <= tail; i++) {
            cout << data[i] << " ";
        }
        cout << endl;
    }
    // 请在下面实现队首元素输出方法 front
    Type front(){
        return data[head];
    }
    // 请在下面实现删除队首元素方法 pop
    void pop(){
        head++;
    }
    // 请在下面实现判断队列是否为空的方法 empty
    bool empty(){
        return head > tail;
    }
};
int main() {
    Queue<int> queue(100);
    for (int i = 1; i <= 10; i++) {
        queue.push(i);
    }
    queue.output();
    if(!queue.empty()){
        cout << queue.front() << endl;
        queue.pop();
    }
    queue.output();
    return 0;
}

循环队列

#include <iostream>
using std::cout;
using std::endl;
template <typename Type> class Queue {
private:
    Type *data;
    int head, tail, length, count;
public:
    Queue(int length_input) {
        data = new Type[length_input];
        length = length_input;
        head = 0;
        tail = -1;
        count = 0;  //此处和普通队列不同
    }
    ~Queue() {
        delete[] data;
    }
    bool push(Type element) {
        if (count >= length) {
            return false;
        }
        tail = (tail + 1) % length;
        data[tail] = element;
        count++; //此处和普通队列不同
        return true;
    }
    void output() {//此处和普通队列不同
        int i = head;
        do {
            cout << data[i] << " ";
            i = (i + 1) % length;
        } while(i != (tail + 1) % length);
        cout << endl;
    }
    Type front() {
        return data[head];
    }
    void pop() {
        head = (head + 1) % length;//此处和普通队列不同
        count--;//此处和普通队列不同
    }
    bool empty() {
        return count == 0;//此处和普通队列不同
    }
};
int main() {
    Queue<int> queue(100); 
    for (int i = 1; i <= 10; i++) {
        queue.push(i);
    }
    queue.output();
    if (!queue.empty()) {
        cout << queue.front() << endl;
        queue.pop();
    }
    queue.output();
    return 0;
}

表达式求值

// 实现有‘+’,‘-’,’*’,’/‘的表达式的求值
#include<iostream>
#include<string>
#include<cassert>
using std::cin;
using std::cout;
using std::endl;
using std::string;
template<typename Type> class Stack {
private:
    Type *elements;
    int top_index, size;
public:
    Stack(int input_length) {
        elements = new Type[input_length];
        top_index = -1;
        size = input_length;
    }
    ~Stack() {
        delete [] elements;
    }
    bool push(const Type &value) {
        if(top_index >= size - 1){
            return false;
        }
        top_index++;
        elements[top_index] = value;
        return true;
    }
    bool pop() {
        if(top_index < 0){
            return false;
        }
        top_index--;
        return true;
    }
    Type top() {
        assert(top_index >= 0);
        return elements[top_index];
    }
    bool empty() {
        return top_index < 0;
    }
};
bool precede(char a, char b) {
    if((a == '*' || a == '/') && (b == '+' || b == '-')){
        return true;
    }else{
        return false;
    }
}
float operate(char a, double b, double c) {
    if(a == '+'){
        return b + c;
    }else if(a == '-'){
        return b - c;
    }else if(a == '*'){
        return b * c;
    }else{
        return b / c;
    }
}
void calc(Stack<double> &numbers, Stack<char> &oper) {
    double a = numbers.top();
    numbers.pop();
    double b = numbers.top();
    numbers.pop();
    numbers.push(operate(oper.top(), b, a));//注意此处a、b的顺序
    oper.pop();
}
int main() {
    string s;
    int m;
    cin >> m;
    Stack<double> numbers(m);
    Stack<char> oper(m);
    cin >> s;
    int i = 0;
    while(i < m){
        if(isdigit(s[i])){
            numbers.push(s[i] - '0');
            i++;
        }else{
            if(oper.empty() || precede(s[i], oper.top())){
                oper.push(s[i]);
                i++;
            }else{
                calc(numbers, oper);
            }
        }
    }
    while(!oper.empty()){
        calc(numbers, oper);
    }
    cout << numbers.top() << endl;
    return 0;
}

3.二叉树

三种遍历

#include<iostream>
using std::cout;
using std::endl;
class Node {
public:
    int data;
    Node *lchild, *rchild;
    Node(int _data) {
        data = _data;
        lchild = NULL;
        rchild = NULL;
    }
    ~Node() {
        if (lchild != NULL) {
            delete lchild;
        }
        if (rchild != NULL) {
            delete rchild;
        }
    }
    //类 Node 的前序遍历方法
    void preorder() {
        cout << data << " ";
        if (lchild != NULL) {
            lchild->preorder();
        }
        if (rchild != NULL) {
            rchild->preorder();
        }
    }
    //类 Node 的中序遍历方法
    void inorder() {
        if (lchild != NULL) {
            lchild->inorder();
        }
        cout << data << " ";
        if (rchild != NULL) {
            rchild->inorder();
        }
    }
    // 类 Node 的后序遍历方法 postorder
	void postorder(){
        if(lchild != NULL){
			lchild->postorder();
        }
        if(rchild != NULL){
            rchild->postorder();
        }
        cout << data << " ";
    }
};
class BinaryTree {
private:
    Node *root;
public:
    BinaryTree() {
        root = NULL;
    }
    ~BinaryTree() {
        delete root;
    }
    void build_demo() {
        root = new Node(1);
        root->lchild = new Node(2);
        root->rchild = new Node(3);
        root->lchild->lchild = new Node(4);
        root->lchild->rchild = new Node(5);
        root->rchild->rchild = new Node(6);
    }
    void preorder() {
        root->preorder();
    }
    void inorder() {
        root->inorder();
    }
    // 请在下面实现类 BinaryTree 的后序遍历方法 postorder
	void postorder(){
        root->postorder();
    }
};
int main() {
    BinaryTree binarytree;
    binarytree.build_demo();
    binarytree.preorder();
    cout << endl;
    binarytree.inorder();
    cout << endl;
	binarytree.postorder();
    cout << endl;
    return 0;
}

二叉排序树

#include<iostream>
using std::cin;
using std::cout;
using std::endl;
template <typename Type> class Node {
public:
    Type data;
    Node<Type> *lchild, *rchild, *father;
    Node(Type _data, Node<Type> *_father = NULL) {
        data = _data;
        lchild = NULL;
        rchild = NULL;
        father = _father;
    }
    ~Node() {
        if (lchild != NULL) {
            delete lchild;
        }
        if (rchild != NULL) {
            delete rchild;
        }
    }
    void insert(Type value) {
        if (value == data) {
            return;
        } else if (value > data) {
            if (rchild == NULL) {
                rchild = new Node<Type>(value, this);
            } else {
                rchild->insert(value);
            }
        } else {
            if (lchild == NULL) {
                lchild = new Node<Type>(value, this);
            } else {
                lchild->insert(value);
            }
        }
    }
    // 请在下面实现类 Node 的查找方法 search
	Node<Type>* search(Type value){
        if(data == value){
            return this;
        }else if(value > data){
            if(rchild == NULL){
                return NULL;
            }else{
                return rchild->search(value);
            }
        }else{
            if(lchild == NULL){
                return NULL;
            }else{
                return lchild->search(value);
            }
        }
    }
};
template <typename Type> class BinaryTree {
private:
    Node<Type> *root;
public:
    BinaryTree() {
        root = NULL;
    }
    ~BinaryTree() {
        delete root;
    }
    void insert(Type value) {
        if (root == NULL) {
            root = new Node<Type>(value);
        } else {
            root->insert(value);
        }
    }
    // 请在下面实现类 BinaryTree 的查找方法 find
	bool find(Type value){
        if(root == NULL){
            return false;
        }
        if(root->search(value) == NULL){
            return false;
        }else{
            return true;
        }
    }
};
int main() {
    BinaryTree<int> binarytree;
    int arr[10] = { 8, 9, 10, 3, 2, 1, 6, 4, 7, 5 };
    for (int i = 0; i < 10; i++) {
        binarytree.insert(arr[i]);
    }
	int value;
    cin >> value;
    if(binarytree.find(value)){
        cout << "search success!" << endl;
    }else{
        cout << "search failed!" << endl;
    }
    return 0;
}
头铁侠
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构笔记(C++版)
01-20
数据结构笔记(C++版)，非常不错，大家看看，可以下载看看
数据结构笔记（c++版，期末复习）
最新发布
basai123的博客
02-15 6358
期末复习时前写的数据结构笔记
C++学习笔记——数据结构
starvapour的博客
01-04 1261
C++学习笔记——数据结构0. begin()、front()、end()、back()1. a[5] 数组（长度固定，连续存储）2. string 字符串3. Array 数组（长度固定，连续存储）4. vector 向量（长度可变，连续存储）5. list 列表（长度可变，不连续存储）6. unordered_map 哈希表 记录c++学习中的常用数据结构容器，以及它们的常用方式。 如有错误，欢迎指出帮助修正。
数据结构笔记（C++实现）
qq_36028321的博客
05-13 400
数据结构笔记（大话数据结构）**序**1、数据结构绪论基本术语2、算法2.1、算法的特性2.2、算法的设计要求 序 这是我的第一篇在网络上记载的笔记，实是记录在学习过程中的一些心得体会。毕竟逐渐的发现学习的过程中没有记录，即使当时认真学过，一段时间之后就会变成过眼云烟。本科学了几年机械，从无感到热爱再到这个专业成为别人口中的笑柄。回头想想，其实错不在某个专业学什么，也不在这个专业下的学生，只是风向不同而已。在此之前，已经学习过吴恩达的ml和黑马的c++，虽然课是听完了，但也就大致摸索到个概念而已。并不是说这
数据结构C++笔记
codespad的专栏
03-04 425
基础要打牢，重学一下数据结构。 第一章 递归函数 对于函数f (n) 的一个递归定义（假定是直接递归） ，要想使它成为一个完整的定义，必须 满足如下条件： • 定义中必须包含一个基本部分（b a s e） ，其中对于n 的一个或多个值，f  (n)必须是直接定 义的（即非递归） 。为简单起见，我们假定基本部分包含了n≤k 的情况，其中k 为常数。 （在基 本部分中指定n≥k 的情
数据结构大作业——药店模拟
qq_49712456的博客
03-09 2420
药店模拟
C++数据结构与算法学习笔记
11-22
C++数据结构与算法学习笔记，供大家参考学习用，祝各位学习顺利！
C++及数据结构复习笔记
07-31
文档主要分为C++基本知识，C++数据结构2个部分。C++基本知识部分介绍了C++的基本知识，如面向过程中的选择、循环和指针等，还有面向过程的内容，包括类，继承与派生，多态性与虚函数。数据结构部分包括向量、列表、...
数据结构与算法学习笔记分享（C++）
09-15
数据结构与算法学习笔记分享（C++） 数据结构是计算机科学中的一门重要学科，它研究的是数据的组织、存储和管理。数据结构是指数据在计算机中的组织形式，包括逻辑结构和物理结构两方面。逻辑结构是指数据之间的...
数据结构笔记【高清文字版，C++】
10-15
————————————————————————————————————
C/C++数据结构大作业[2023-01-16]
程序设计
01-16 1142
数据结构大作业一、大作业的性质和目的数据结构大作业是对软件设计的综合训练，包括问题分析、总体设计、用户界面设计、程序设计基本技能和技巧，以至一套软件工作规范的训练和科学作风的培养。在数据结构实验中，完成的只是单一而“小”的算法，而本课程设计是对学生的整体编程能力的锻炼。数据结构大作业的目的是训练学生对问题的抽象能力和算法的运用能力。二、大作业的基本要求（1）界面友好：有合理的中文提示，每个功能可以设立菜单，根据提示，可以完成相关的功能。出现非法输入，会给出异常提示。
数据结构笔记(C++描述)
11-29 758
1. 创建一个二维数组: template bool make2dArray(T** &x, int numberOfRows, int numberOfColumns) { try { x= new T*[numberOfRows]; for( int i=0; i { x[i] = new int[numberOfColumns]; } return true;
数据结构C++复习笔记
Pz1o的博客
05-13 743
数据结构复习(c++) 线性表 1.线性表 线性表是一个有限序列。 线性表基于数组存储的表示叫做顺序表。常用数组作为表。 线性表基于指针的存储表示叫做链表。通常有单链表、双链表、循环链表等。 2.顺序表 0x01顺序表的定义和特点 假设顺序表A的起始存储位置为Loc(1),第i个表项的存储位置为Loc(i)则有： Loc(i)=Loc(1)+(i-1)*sizeof(T) 其中，Loc(1)为第一个表项的存储位置，即数组中第0个元素的位置。 0x02顺序表的类定义及操作 顺序表存储分为静态存储和动态存储。
数据结构笔记|C++
圣无肠的博客
09-21 468
大二上数据结构笔记 资料：《数据结构与算法分析》by Clifford A.Shaffer
数据结构笔记（c++部分）
miss_njhl的博客
10-19 180
数据结构（c++部分） ![在这里插入图片描述](https://img-blog.csdn.net/20181019110324427?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3NfbmpobA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70 ) ...
《数据结构与算法分析c++描述》读书笔记一——表
u011085626的博客
06-30 1701
学习数据结构与算法的参考书是《数据结构与算法分析c++描述》一书。         首先看的是最基本的ADT(抽象数据结构)表、栈、队列。         1、表：是一种有限且有序的序列。实现的方式有两种：数组（所有操作都可以用数组来实现，查找功能、在表尾插入数据删除数据很方便）；链表（每个数据不必存在连续存储，插入、删除数据很方便）。        2、栈： 限制数据插入和删除只能在一个位
C++及其数据结构学习笔记目录
ws41802033的博客
05-13 107
01——第二章函数与库 02——第三章string类 03——stream类
C++及数据结构复习笔记（五）（类和对象）
Lao_tan的博客
07-09 484
1.8 类和对象1.8.1 类的声明和对象的定义       C++中对象的类型称为类（class），类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，对象是具体的，占用存储空间。类的声明格式：class 类名{  public:    公用的数据和成员函数;  private:    私有的数据和成员函数;};       private和public称为成员访问限定符，被声明为私有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值