数据结构_C++

其他 2020-03-16 11:19:32 阅读次数: 0

数据结构

文章目录

1.数据结构基本概念

1.数据
2.数据对象
3.数据元素
4.数据项
数据结构为研究数据元素之间的关系。即结点与结点之间的关系
数据结构具体表现为数组,链表,树,图,队列…

在这里插入图片描述

2.数据结构关系

逻辑结构和物理结构

2.1逻辑结构

逻辑结构可分为
1.集合
2.线性结构
3.树形结构
4.图形结构
简而言之就是1-1,n-1.n-n的关系
线性结构为1-1,树形结构为n-1,图形结构为n-n。

在这里插入图片描述

2.2 物理结构

物理结构:顺序,链式,索引,散列
最常用的是顺序和链式。
在这里插入图片描述

算法的设计依赖于逻辑结构
算法的实现依赖于存储结构

2.3 数据的运算

有数据的插入,删除,修改,查找以及排序

在这里插入图片描述

3.算法

3.1算法概念

算法是特定问题求解概念的描述
在计算机中表现为指令的有限序列
算法是独立存在的一种解决的方法和思想
对于算法而言,语言并不重要,重要的思想

3.2算法和数据结构的区别

数据结构是静态的描述数据元素之间的关系。
高效的程序需要在数据结构的基础上设计和选择算法。
程序=数据结构+算法

算法是为了解决问题而设计的。
数据结构是算法需要处理的问题载体。
数据结构和算法相辅相成

3.3算法的特性

输入,输出,有穷性,确定性,可行性

3.4算法的效率

3.4.1时间复杂度

大O表示法

在这里插入图片描述

在企业中项目经理会评估写的代码的O。

优秀的代码大O很小。

3.4.2空间复杂度

int - 4
char - 1
long - 4
short - 2
double - 8
float - 4

3.4.3时间与空间

空间换时间
比如如果是稀疏矩阵的话如果要遍历则可以通过变为n+1行3列的数据。

4.线性表

线性表List是零个或者多个数据元素的集合。
线性表中的数据元素之间是有顺序的。
线性表中的数据元素数目是有限的。
线性表中的数据元素的数据类型必须一致。

性质
a0为线性表的第一个元素,只有一个后继
an-1为线性表的最后一个元素,只有一个前驱
除a0和an-1以外的元素都有前驱和后继。

操作
创建线性表
销毁线性表
清空线性表
将元素插入到线性表
将元素从线性表中清除
获取线性表某个位置的元素
获取线性表的长度

List.h

#pragma once
#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#define LIST_INIT_SIZE 100
#define MAXSIZE 100

typedef int ElemType;

typedef struct Sqlist {
    ElemType * elem;
    int length;
    int listsize;
}Sqlist, *ListPtr;

typedef enum Status {
    success, fail, fatal, rangeerror,overflow
}Status;

Status List_Init(ListPtr L);

void List_Destroy(ListPtr L);

void List_Clear(ListPtr L);

bool List_Empty(ListPtr L);

int List_Size(ListPtr L);

Status List_Retrieve(ListPtr L, int pos, ElemType * elem);

Status List_Locate(ListPtr L, ElemType elem, int *pos);

Status List_Insert(ListPtr L, int pos, ElemType elem);

Status List_Remove(ListPtr L, int pos);

Status List_Prior(ListPtr L, int pos, ElemType * elem);

线性表.cpp

#include "stdafx.h"
#include<iostream>
#include "List.h"
using namespace std;

Status List_Retrieve(ListPtr L, int pos, ElemType * elem) {
    Status status = rangeerror;
    int len = L->length;
    if (1 <= pos&&pos <= len) {
        *elem = L->elem[pos];
        status = success;
    }
    return status;
}

Status List_Locate(ListPtr L, ElemType elem, int * pos) {
    Status status = rangeerror;
    int len = L->length;
    int i = 1;
    while (i <= len && L->elem[i]==elem) {
        i++;
    }
    if (i <= len) {
        *pos = i;
        status = success;
    }
    return status;
}

Status List_Insert(ListPtr L, int pos, ElemType elem) {
    Status status = rangeerror;
    int len = L->length,i;
    if (len > MAXSIZE)status = overflow;
    else if (1 <= pos && pos <= len + 1) {
        for (i = len; i >= pos; i--)
            L->elem[i + 1] = elem;
        L->elem[pos] = elem;
        L->length++;
        status = success;
    }
    return status;
}

Status List_Init(ListPtr L) {
    Status status = fatal;
    L->elem = (ElemType*)malloc((MAXSIZE + 1) * sizeof(ElemType));
    if (L->elem) {
        L->length = 0;
        status = success;
    }
    return status;
}

void List_Destroy(ListPtr L) {
    if (L->elem) {
        free(L->elem);
        L->elem = NULL;
    }
    L->length = 0;
}

void List_Clear(ListPtr L) {
    L->length = 0;
}

bool List_Empty(ListPtr L) {
    return L->length == 0;
}

Status List_Prior(ListPtr L, int pos, ElemType * elem) {
    Status status = fail;
    int len = L->length;
    if (2 <= pos && pos <= len) {
        *elem = L->elem[pos - 1];
        status = success;
    }
    return status;
}

Status List_Next(ListPtr L, int pos, ElemType * elem) {
    Status status;
    int len = L->length;
    if (1 <= pos && pos <= len - 1) {
        *elem = L->elem[pos+1];
        status = success;
    }
    return status;
}

int List_Size(ListPtr L) {
    return L->length;
}

Status List_Remove(ListPtr L, int pos) {
    Status status = rangeerror;
    int len = L->length, i;
    if (1 <= pos && pos <= len) {
        for (i = pos; i < len; i++) 
            L->elem[i] = L->elem[i + 1];
        L->length--;
        status = success;
    }
    return status;
}


Status List_Union(ListPtr La, ListPtr Lb) {
    ElemType elem;
    Status status= fail;
    int i, len = List_Size(Lb);
    for (i = 1; i <= len; i++) {
        List_Retrieve(Lb, i, &elem);
        if (status != success) {
            status = List_Insert(La, 1, elem);
            if (status != success)break;
        }
    }
    return status;
}



Status List_Merge(ListPtr La, ListPtr Lb, ListPtr Lc) {
    ElemType elem1, elem2;
    Status status=fail;
    status = List_Init(Lc);
    if(status != success)return status;
    int i = 1, j = 1, k = 1;
    int n = List_Size(La), m = List_Size(Lb);
    while (i <= n && j <= m) {
        List_Retrieve(La, i, &elem1), List_Retrieve(Lb, j, &elem2);
        if (elem1 < elem2) {
            status = List_Insert(Lc, k, elem1);
            i++;
        }
        else {
            status = List_Insert(Lc, k, elem2);
            j++;
        }
        if (status != success) return status;
        k++;
    }
    while (i <= n) {
        List_Retrieve(La, i, &elem1);
        status = List_Insert(Lc, k, elem1);
        if (status != success) return status;
        i++, k++;
    }
    while (j <= m) {
        List_Retrieve(Lb, j, &elem2);
        status = List_Insert(Lc, k, elem2);
        if (status != success) return status;
        j++, k++;
    }
    return status;
}


int main() {
    ListPtr La = new Sqlist, Lb = new Sqlist, Lc = new Sqlist;;
    List_Init(La);
    List_Init(Lb);
    List_Init(Lc);
    int arra[5] = { 2,4,6,7,8 };
    for (int i = 1; i <= 5; i++)
        List_Insert(La, i, arra[i-1]);
    
    for(int i=1;i<=5;i++)
        cout << La->elem[i] << " ";
    cout << endl;

    int arrb[5] = { 1,5,9,10,11 };
    for (int i = 1; i <= 5; i++)
        List_Insert(Lb, i, arrb[i - 1]);

    for (int i = 1; i <= 5; i++)
        cout << Lb->elem[i] << " ";
    cout<< endl;

    Status status = List_Merge(La, Lb, Lc);
    cout << status << endl;
    if (status != success)return EXIT_FAILURE;

    for (int i = 1; i <= 10; i++)
        cout << Lc->elem[i] << " ";
    cout << endl;


    system("pause");
    return EXIT_SUCCESS;
}

5.静态链表

链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的
在这里插入图片描述

#include "stdafx.h"
#include<iostream>

using namespace std;

#define MAXSIZE 100

typedef int ElemType;

typedef struct {
    ElemType data;
    int cur;
}component,SLinkList[MAXSIZE];

void InitSpace_SL(SLinkList &space) {
    for (int i = 0; i < MAXSIZE - 1; ++i) space[i].cur = i + 1;
    space[MAXSIZE - 1].cur = 0;
}

int Malloc_SL(SLinkList &space) {
    int i = space[0].cur;
    if (space[0].cur) space[0].cur = space[i].cur;
    return i;
}

void Free_SL(SLinkList & space, int k) {
    space[k].cur = space[0].cur; space[0].cur = k;
}

void difference(SLinkList &space, int &S) {
    InitSpace_SL(space);  //初始化备用空间
    S = Malloc_SL(space);  //生成S的头结点
    int r = S;
    cout << "请输入A,B集合的元素个数,用空格隔开" << endl;
    int m, n;
    cin >> m >> n;
    int i, j;
    cout << "请依次输入A集合的元素并按回车" << endl;
    int nn;
    //给A集合添加数据
    for (j = 1; j <= m; ++j) {
        i = Malloc_SL(space); //取出下一个空间索引
        cin>>nn; //赋值
        space[i].data = nn;
        space[r].cur = i;  //尾插法（r指向的是最后一个结点，让上一次最后结点指向i索引）
        r = i;     //r指向最后的节点
    }

    space[r].cur = 0;  //将最后一个结点指向空（也就是0）
    printf("请依次输入B集合的元素\n");
    int b;
    int p;
    int k;
    for (j = 1; j <= n; ++j) {
        cin >> b; //读取并记录到临时变量b
        p = S;  //记录头结点
        k = space[S].cur;  //k指向第一个结点
        while (k != space[r].cur && space[k].data != b) {
            p = k;
            k = space[k].cur; //指向下一个结点
        }
        if (k == space[r].cur) {  //不存在元素b,插入到r所指结点之后
            i = Malloc_SL(space);
            space[i].data = b;
            space[i].cur = space[r].cur;
            space[r].cur = i;
        }
        else {  //存在元素b，删除
            space[p].cur = space[k].cur;
            Free_SL(space, k);
            if (r == k) r = p;
        }
    }
    //指回头指针
    space[0].cur = S;

}

void Show_SL(SLinkList &space) {
    printf("链表的打印结果是\n");
    int s = Malloc_SL(space); //指向头结点
    while (space[s].cur != 0) {
        s = Malloc_SL(space);
        cout << space[s].data<<" ";
    }
    cout << endl;
}


int main() {
    SLinkList sl;
    int s;
    difference(sl, s);
    Show_SL(sl);
    system("pause");
    return EXIT_SUCCESS;
}

在这里插入图片描述

959ggg
发布了204 篇原创文章 · 获赞 20 · 访问量 1万+
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_43141726/article/details/104859245
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
NEFU 117 素数个数的位数
Closest Common Ancestors (Lca,tarjan)
ELK部署
【转载】Hive笔记整理（三）
SQL语句（一）基本表的定义
关于Java web开发中的MySQL的事务语句
MFC创建自定义窗体
如何用一句话激怒程序员？
《逆袭大学》文摘——9.4 基础和应用的平衡中找到大学的节奏
【spring源码分析】@Value注解原理
每日归档
更多
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022