数据结构 Daily Practice

已于 2023-10-09 14:25:44 修改
阅读量176 收藏
点赞数
文章标签： 数据结构
于 2023-09-18 13:40:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxybin/article/details/132974919
版权

一、前言

  欢迎大家进入本学期数据结构的学习，这篇文章分享的是数据结构的日常练习题的答案，答案仅供参考。希望大家在本学期能够学会、学好数据结构，并希望大家能够重视起这门课程，我只能说这门课程对以后的code精进、计算机相关比赛很有帮助。当然想考研的同学，必须要学好这门课程！最后祝大家：欢愉且胜意，万事皆可期。

二、快捷查找方法

  手机端通过 目录查找

  电脑端通过 1. ctrl + f 输入名字查找
                     2. 目录查找

  当然，大家也可以保存本篇文章的地址，方便以后查询老师留的其他题的答案。

三、正文

章节 02

1. 用类实现顺序线性表

#include <iostream>
using namespace std;
#include<iostream>
#include<fstream>
#include<string> 
#include <iomanip>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE 100

typedef int Status;
typedef int ElemType;

class Sqlist {
protected:
    int length;
    ElemType *elem;

public:
    Sqlist() {
        length = 0;
        elem = new ElemType[MAXSIZE];
    }

    void show() {
        for (int i = 1; i <= length; i++) {
            cout << i << ":" << elem[i-1] << endl;
        }
    }

    Status insert(ElemType s) {
        if (length >= MAXSIZE) return ERROR;
        elem[length] = s;
        length++;
        return OK;
    }

    Status deleteLoc(int loc) {
        if (loc < 1 || loc > length) return ERROR;
        for (int i = loc; i < length; i++) {
            elem[i-1] = elem[i];
        }
        length--;
        return OK;
    }
};

int main()
{
    //线性表的的初始化、插入、取值
    Sqlist Lscore; //创建Sqlist对象并初始化，用来存储学生《数据结构》成绩（最多100人） 
    
    for(int i=1; i<=3; i++) //输入3个学生成绩，依次添加到线性表中 
    {
        int s;
        cin>>s;
        Lscore.insert(s);
    } 
    Lscore.show(); //遍历线性表 
    
    int loc;
    cin>>loc; //输入要删除的位置
    if(Lscore.deleteLoc(loc)==OK) cout<<"delete success!"<<endl;
    else cout<<"Error!"<<endl;
    
    Lscore.show();

    return 0;
}

2. 后插法创建单链表

#include <stdio.h>
#include <stdlib.h>
typedef int E;
typedef struct LNode {
    char data[5];
    struct LNode *next;
} LNode, *LinkList;

void InitList(LinkList &head) {
    head = (LinkList)malloc(sizeof(LNode));
    head->next = NULL;
}

void showList(LinkList Lname) {
    if (Lname->next == NULL) printf("empty!\n");
    int i = 1;
    LNode *node = Lname->next;
    while (node != NULL) {
        printf("%d:%s\n", i, node->data);
        node = node->next;
        i++;
    }
}

void CreateList_R(LinkList Lname, E element) {
    LNode *L = Lname;
    for (int i = 0; i < element; i++) {
        LNode *node = (LNode *)malloc(sizeof(LNode));
        scanf("%s", node->data);
        node->next = NULL;
        L->next = node;
        L = node;
    }
}

 int main()
{
    LinkList Lname;
    InitList(Lname); //初始化单链表 
    showList(Lname); //单链表遍历 
    CreateList_R(Lname,5); //后插法创建单链表 
    showList(Lname); //单链表遍历 
    return 0;
} 

3. 双向链表的删除

#include<iostream>
using namespace std;

#define OK 1
#define ERROR 0

typedef int E;
typedef struct DuLNode {
    E element;
    struct DuLNode *prev; 
    struct DuLNode *next;  
} DuLNode, *DuLinkList;


E InitDuLNode(DuLinkList &head) {
    head = new DuLNode;
    if (head == NULL) return ERROR;
    head->prev = head->next = NULL;   
    return OK;
}

E CreateDuL_H(DuLinkList &head, E element) {
    head->next = NULL;
    for (int i = 0; i < element; i++) {
        DuLinkList node = new DuLNode;
        if (node == NULL) return ERROR;
        cin >> node->element;
        node->next = head->next;
        if (head->next != NULL) {
            head->next->prev = node;
        }
        node->prev = head;
        head->next = node;
    }
    return OK;
}


void show(DuLinkList head) {
    DuLinkList node = head->next;
    for(int i = 1; node != NULL; i++) {
        cout<<i<<":"<<node->element<<endl;
        node = node->next;
    }
}

E ListDelete_DuL(DuLinkList head, int index) {
    int j = 0;
    DuLinkList node = head;
    while (node && j < index - 1) {
        node = node->next;
        j++;
    }
    if (!node || j > index - 1) return ERROR; 
    DuLinkList poi = node->next;
    if (!poi) return ERROR; 
    node->next = poi->next;
    if (poi->next)  poi->next->prev = node;
    delete poi;
    return OK;
}

int main()

{

    DuLinkList L;

    InitDuLNode(L); //初始化双向链表

    CreateDuL_H(L,4); //前插法创建双向链表

    show(L); //遍历双向链表

    int i;

    cout<<"Please input the location you want to delete:"<<endl;

    cin>>i;

    if(ListDelete_DuL(L,i)==OK)

        cout<<"Delete success!"<<endl;

    else

        cout<<"Delete Error!"<<endl;

    show(L);

    return 0;

}

4. 递增链表合并（不重复）

#include <iostream>
using namespace std;

typedef int E;
typedef struct Node {
    E element;
    struct Node* next;
} Node, *LinkList;

void InitList(LinkList &head) {
    head = new Node;
    head->next = NULL;
}


void CreateList_Up(LinkList head, E element) {
    LinkList p, q;
    for (int i = 0; i < element; i++) {
        p = new Node;
        cin>>p->element;
        p->next = NULL;
        q = head;
        while (q->next && q->next->element < p->element) {
            q = q->next;
        }
        if (!q->next || q->next->element > p->element) {
            p->next = q->next;
            q->next = p;
        }
        else {
            delete p;
        }
    }
}

void showList(LinkList head) {
    Node* node = head->next;
    for(int i = 1; node !=NULL; i++) {
        cout<<i<<":"<<node->element<<endl;
        node = node->next;
        
    }
}

void MergeList(LinkList La, LinkList Lb, LinkList Lc) {
    Node* pa = La->next;
    Node* pb = Lb->next;
    Node* pc = Lc;
    while (pa && pb) {
        if (pa->element < pb->element) {
            pc->next = pa;
            pa = pa->next;
        }
        else if (pa->element > pb->element) {
            pc->next = pb;
            pb = pb->next; 
        }
        else {
            pc->next = pa;
            pa = pa->next;
            pb = pb->next;
        }
        pc = pc->next;
        
    }
    pc->next = pa ? pa : pb;
}

请注意，main()函数必须按如下所示编写：
int main()
{
    LinkList La,Lb,Lc;
    InitList(La);InitList(Lb);InitList(Lc); //初始化带头结点的单链表(存储int类型数据) 
    CreateList_Up(La,3); //创建递增单链表（去掉重复数据） 
    cout<<"Show La:"<<endl;
    showList(La); //单链表遍历 
    CreateList_Up(Lb,4); //创建递增单链表（去掉重复数据） 
    cout<<"Show Lb:"<<endl;
    showList(Lb); //单链表遍历 
    
    MergeList(La,Lb,Lc);
    cout<<"Show Lc:"<<endl;
    showList(Lc); //单链表遍历
    return 0;
} 

章节03

1. 括号匹配

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

typedef struct {
    char data[20];
    int top;
} Stack;

void initStack(Stack *s) {
    s->top = -1;
}

void pushStack(Stack *s, char c) {
    if (s->top < 19) {
        s->data[++(s->top)] = c;
    }
}

char popStack(Stack *s) {
    if (s->top >= 0) {
        return s->data[(s->top)--];
    }
    return '\0';
}

bool Left(char c) {
    return (c == '(' || c == '[' || c == '{');
}

bool Right(char c) {
    return (c == ')' || c == ']' || c == '}');
}

bool Matching(string str) {
    Stack s;
    initStack(&s);
    int len = str.length();

    for (int i = 0; i < len; i++) {
        char c = str[i];
        if (Left(c)) {
            pushStack(&s, c);
        } else if (Right(c)) {
            char topC = popStack(&s);
            if ((c == ')' && topC != '(') ||
                (c == ']' && topC != '[') ||
                (c == '}' && topC != '{')) {
                return false; 
            }
        }
    }

    return s.top == -1; 
}

请注意，main()函数必须按如下所示编写：
int main()
{
    string str;
    getline(cin,str);
    if(Matching(str)) cout<<"True"<<endl;
    else cout<<"False"<<endl;
    return 0;
}

2. 循环队列tag

#include<iostream>
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE 3
typedef int Status;
typedef float QElemType;

typedef struct {
    QElemType* base;
    int front, rear, tag;
} SqQueue;

Status InitQueue(SqQueue& SQ) {
    SQ.base = new QElemType[MAXSIZE];
    if (!SQ.base) return OVERFLOW;
    SQ.front = SQ.rear = 0;
    SQ.tag = 0; 
    return OK;
}

Status EnQueue(SqQueue& SQ, QElemType QE) {
    if (SQ.front == SQ.rear && SQ.tag == 1) {
        return ERROR;
    }
    SQ.base[SQ.rear] = QE;
    SQ.rear = (SQ.rear + 1) % MAXSIZE;
    SQ.tag = 1; 
    return OK;
}

Status DeQueue(SqQueue& SQ, QElemType& QE) {
    if (SQ.front == SQ.rear && SQ.tag == 0) {
        return ERROR;
    }
    QE = SQ.base[SQ.front];
    SQ.front = (SQ.front + 1) % MAXSIZE;
    SQ.tag = 0;
    return OK;
}

请注意，main()函数必须按如下所示编写：
int main()
{
    SqQueue Q;
    InitQueue(Q); 
    int i,n;
    float f;
    cin>>n;
    for(i=0;i<n;i++)
    {
        cin>>f;
        if(EnQueue(Q,f)==ERROR) cout<<"Full!"<<endl;
        else cout<<"EnQueue:"<<f<<endl;
    }
    
    for(i=0;i<n;i++)
    {
        if(DeQueue(Q,f)==ERROR) cout<<"Empty!"<<endl;
        else cout<<"DeQueue:"<<f<<endl;
    }
    return 0;
}

sxybin
关注
python_Daily practice (每日一练) 40
weixin_44786482的博客
06-10 772
名片管理器v1.0 要求优化之前的打印名片程序 控制姓名长度为6-20 电话号码长度11 性别只能允许输入男或女 每一样信息不允许为空 参考代码 # coding=utf-8 while True: # 获取用户输入 name = input("请输入姓名(6-20)：") # 如果输入“QUIT”则退出程序 if name == "QUIT": b...
leetcode答案-daily-practice-xianzhiyun:daily-practice-xianzhiyun
06-30
工作日的每天，都会更新一道题目，题目类型不限于算法，数据结构等。 出题的人可以从以下的链接中找出一道你觉得合适的题目上传到仓库让团队与团队其他小伙伴进行互动解答。 觉得每天一道题不够做也可以从下面的仓库...
数据结构-数组
temperamentalkj
04-06 1786
数组一、双指针*1、hot100 - 283. 移动零 一、双指针 *1、hot100 - 283. 移动零 题目：https://leetcode-cn.com/problems/move-zeroes/ 解法： 使用双指针，左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。 右指针不断向右移动，每次右指针指向非零数，则将左右指针对应的数交换，同时左指针右移 注意以下性质: 左指针左边均为非零数； 右指针左边直到左指针处均为零。 时间复杂度：O(n) 空间复杂度：O(1) c
算法数据结构必备篇章3
2301_81486828的博客
08-11 333
文章目录47. (必备)一维差分与等差数列差分48. (必备)二维前缀和, 二维差分, 离散化技巧49. (必备)滑动窗口技巧以及相关题目50. (必备)双指针技巧及相关题目51. (必备)二分答案法及相关题目52. (必备)单调栈上53. (必备)单调栈下54. (必备)单调队列上55. (必备)单调队列下56. (必备)并查集上57. (必备)并查集下 47. (必备)一维差分与等差数列差分 package class047; // 航班预订统计 // 这里有 n 个航班，它们分别从 1 到 n 进行
[LeetCode] Daily Practice 1 两数之和(Two Sum)
fgc_sha的博客
03-23 116
两数之和(Two sum): 给定一个整数数组 nums和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。
[Daily Practice] -最不经常使用（LFU）缓存的数据结构
zgliulin
04-05 408
题目描述 设计并实现最不经常使用（LFU）缓存的数据结构。它应该支持以下操作：get 和 put。 get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。 put(key, value) - 如果键不存在，请设置或插入值。当缓存达到其容量时，它应该在插入新项目之前，使最不经常使用的项目无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，最近最少使用的键...
Daily practice——2021/5/20
qq_45902301的博客
05-20 521
一个萌新的日常练习。
Daily practice——2021/1/28
qq_45902301的博客
01-28 276
一个萌新的日常练习。
数据结构 单词查找 二分法-索引表-Hash表
热门推荐
Wang121201的博客
04-05 1万+
问题说明： 从标准输入中读入一个英文单词及查找方式，在一个给定的英文常用单词字典文件dictionary3000.txt中查找该单词，返回查找结果（查找到返回1，否则返回0）和查找过程中单词的比较次数。 实现查找的4种方法： 1、在单词表中以顺序查找方式查找，因为单词表已排好序，遇到相同的或第一个比待查找的单词大的单词，就要终止查找； 2、在单词表中以折半查找方式查找； 3、在单词表中通过索引表来获取单词查找范围，并在该查找范围中以折半方式查找。索引表构建方式为：以26个英文字母为头字母的单词在字典中的起始
[Daily Practice] -字典树（Trie）
zgliulin
03-28 181
题目描述 给定一个单词列表，我们将这个列表编码成一个索引字符串 S 与一个索引列表 A。 例如，如果这个列表是 [“time”, “me”, “bell”]，我们就可以将其表示为 S = “time#bell#” 和 indexes = [0, 2, 5]。 对于每一个索引，我们可以通过从字符串 S 中索引的位置开始读取字符串，直到 “#” 结束，来恢复我们之前的单词列表。 那么成功对给定单词列表...
Daily_practice_problems
02-14
综上所述，"Daily_practice_problems"项目覆盖了C语言的广泛知识，从基础语法到高级特性，包括数据类型、流程控制、结构体、文件操作、错误处理、内存管理、预处理器、位操作、算法和数据结构等。通过这样的日常练习...
daily-algorithms-practice:日常算法练习
03-15
"algorithms-and-data-structures" 提到的是算法和数据结构，这是计算机科学的基础，包括排序、搜索、图算法、树结构等。"Python" 再次强调了项目使用的编程语言。 根据 "daily-algorithms-practice-master" 这个...
daily_Web_practice
02-18
在日常的Web开发实践中，HTML（HyperText Markup Language）是构建网页内容的基础，它定义了网页...而持续的实践是提高技能的关键，"daily_Web_practice"这样的日常练习能够帮助开发者巩固理论知识，提升实际操作能力。
algorithm_daily_practice_cpp:日积月累-每日一题
04-01
"堆"是一种特殊的树形数据结构，分为最大堆和最小堆，满足父节点的值总是大于或等于（最大堆）或小于或等于（最小堆）其子节点的值。堆常用于实现优先队列，优化排序算法（如堆排序），以及在图算法中的最小生成树...
数据结构：树的定义及其性质
pranaa的博客
09-24 703
树是一种重要的非线性数据结构，树作为一种逻辑结构，同时也是一种分层结构。具有以下两个特点：1.树的根结点没有前驱，除根结点意外的节点只有一个前驱2.树中所有结点都可以有0个或多个后继树结构在多个领域都有广泛应用，如表示文件系统的结构、数据库的索引、层次数据关系等。具体来说，树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。
数据结构之——栈
m0_71974552的博客
09-24 1177
栈：数据结构的基石
matlab的‌基础语法和数据类型
weixin_45710581的博客
09-25 581
MATLAB中的函数用于封装可重复使用的代码块。
数据结构：详解搜索二叉树
最新发布
Another_Shi的博客
09-28 772
搜索二叉树的结构跟二叉树差不多——两个指针来指向左右子树，一个对象来存放数据。
assets prices daily股票数据集
11-11
"assets prices daily股票数据集"是一个包含每日股票价格的数据集。这个数据集可以包括不同公司的股票价格，例如蓝筹股、科技股或其他行业的股票。 这个数据集通常包括每个交易日的开盘、收盘、最高和最低价格，以及交易量等数据。通过分析这些数据，可以了解股票的波动性、价格走势和交易活跃程度等信息。 数据集中的股票价格数据对于投资者、金融分析师和研究人员非常有用。它们可以利用这些数据来进行技术分析、基本面分析和市场预测等。通过分析股票价格数据，可以识别出股票的趋势、买入和卖出信号，并作出相应的投资决策。 此外，股票价格数据还可以用于构建模型和回测策略。通过利用历史股票价格数据，可以开发出各种交易策略，并测试其在过去的表现。这可以帮助投资者提高投资回报率，并降低投资风险。 总之，"assets prices daily股票数据集"是一个重要的金融数据集，对于投资者和研究人员来说是非常有价值的。它提供了每日股票价格的信息，可以用于技术分析、基本面分析和市场预测，同时也可以用于构建和测试交易策略。通过对这些数据的分析和利用，投资者和研究人员可以更好地了解股票市场，并做出更明智的投资决策。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值