基本操作_线性表基本操作 - CSDN
精华内容
参与话题
  • 基本操作及概念

    2017-07-26 07:27:46
    一、桌面环境介绍 相对于现在的 Windows 系统,UNIX/Linux 本身是没有图形界面的,我们通常在 UNIX/Linux 发行版上看到的图形界面实际都只是运行在 Linux 系统之上的一套软件,类似 Windows95 之前的 Windows 的...

    一、桌面环境介绍

    相对于现在的 Windows 系统,UNIX/Linux 本身是没有图形界面的,我们通常在 UNIX/Linux 发行版上看到的图形界面实际都只是运行在 Linux 系统之上的一套软件,类似 Windows95 之前的 Windows 的图形界面实则也只是运行在 DOS 环境的一套软件。而 Linux 上的这套软件以前是 XFree86,现在则是 xorg(X.Org),而这套软件又是通过 X 窗口系统(X Window System,也常被称为 X11 或 X)实现的,X 本身只是工具包及架构协议,而 xorg 便是 X 架构规范的一个实现体,也就是说它是实现了 X 协议规范的一个提供图形界面服务的服务器,就像实现了 http 协议提供 web 服务的 Apache 。如果只有服务器也是不能实现一个完整的桌面环境的,当然还需要一个客户端,我们称为 X Client,像如下几个大家熟知也最流行的实现了客户端功能的桌面环境KDEGNOMEXFCELXDE 。

    二、Linux终端


    1.终端概念

    相对于现在的 Windows 系统,UNIX/Linux 本身是没有图形界面的,我们通常在 UNIX/Linux 发行版上看到的图形界面实际都只是运行在 Linux 系统之上的一套软件,类似 Windows95 之前的 Windows 的图形界面实则也只是运行在 DOS 环境的一套软件。而 Linux 上的这套软件以前是 XFree86,现在则是 xorg(X.Org),而这套软件又是通过 X 窗口系统(X Window System,也常被称为 X11 或 X)实现的,X 本身只是工具包及架构协议,而 xorg 便是 X 架构规范的一个实现体,也就是说它是实现了 X 协议规范的一个提供图形界面服务的服务器,就像实现了 http 协议提供 web 服务的 Apache 。如果只有服务器也是不能实现一个完整的桌面环境的,当然还需要一个客户端,我们称为 X Client,像如下几个大家熟知也最流行的实现了客户端功能的桌面环境KDEGNOMEXFCELXDE 。不过要注意的是这里所说的终端(Terminal)和控制台(Console)是有区别的。终端本质上是对应着 Linux 上的 /dev/tty 设备,Linux 的多用户登陆就是通过不同的 /dev/tty 设备完成的,Linux 默认提供了 6 个纯命令行界面的 “terminal”(准确的说这里应该是 6 个 virtual consoles)来让用户登录。在物理机系统上你可以通过使用[Ctrl]+[Alt]+[F1]~[F6]进行切换,不过在我们的在线实验环境中可能无法切换,因为特殊功能按键会被你的主机系统劫持。当你切换到其中一个终端后想要切换回图形界面,你可以按下[Ctrl]+[Alt]+[F7]来完成。

    2.Shell

    通常在图形界面中对实际体验带来差异的不是上述的不同发行版的各种终端模拟器,而是这个 Shell(壳)。有壳就有核,这里的核就是指 UNIX/Linux 内核,Shell 是指“提供给使用者使用界面”的软件(命令解析器),类似于 DOS 下的 command(命令行)和后来的 cmd.exe 。普通意义上的 Shell 就是可以接受用户输入命令的程序。它之所以被称作 Shell 是因为它隐藏了操作系统底层的细节。同样的 UNIX/Linux 下的图形用户界面 GNOME 和 KDE,有时也被叫做“虚拟 shell”或“图形 shell”。

    UNIX/Linux 操作系统下的 Shell 既是用户交互的界面,也是控制系统的脚本语言。当然这一点也有别于 Windows 下的命令行,虽然该命令行也提供了很简单的控制语句。在 Windows 操作系统下,有些用户从来都不会直接使用 Shell,然而在 UNIX 系列操作系统下,Shell 仍然是控制系统启动、X11 启动和很多其它实用工具的脚本解释程序。

    在 UNIX/Linux 中比较流行的常见的 Shell 有 bash、zsh、ksh、csh 等等,Ubuntu 终端默认使用的是 bash,默认的桌面环境是 GNOME 或者 Unity(基于 GNOME),但我们的环境中使用的分别是 zsh 和 xfce。

    3.命令行操作


    1)输入 输出

    输入当然就是打开终端,然后按键盘输入,然后按回车,输入格式一般就是这类的

    输出会返回你想要的结果,比如你要看什么文件,就会返回文件的内容。如果只是执行,执行失败会告诉你哪里错了,如果施行成功那么会没有输出

    #创建一个名为文件,touch是一个命令touch file 

    #进入一个目录,cd是一个命令cd /etc/

    #查看当前所在目录pwd

    2)开始

    打开终端运行shell

    3)快捷键

    【Tab】:使用Tab键来进行命令补全,Tab键一般是在字母Q旁边,这个技巧给你带来的最大的好处就是当你忘记某个命令的全称时可以只输入它的开头的一部分,然后按下Tab键就可以得到提示或者帮助完成。当然不止补全命令,补全目录、补全命令参数都是没问题的

    【Ctrl + C】:使用Ctrl+c键来强行终止当前程序(你可以放心它并不会使终端退出)。

    其他:

    Ctrl+d 键盘输入结束或退出终端
    Ctrl+s 暂停当前程序,暂停后按下任意键恢复运行
    Ctrl+z 将当前程序放到后台运行,恢复到前台为命令fg
    Ctrl+a 将光标移至输入行头,相当于Home
    Ctrl+e 将光标移至输入行末,相当于End
    Ctrl+k 删除从光标所在位置到行末
    Alt+Backspace 向前删除一个单词
    Shift+PgUp 将终端显示向上滚动
    Shift+PgDn 将终端显示向下滚动
    4)历史输入命令

    使用键盘上的方向上键,恢复你之前输入过的命令。

    5)通配符

    通配符是一先使用 touch 命令创建 2 个文件,后缀都为 txt种特殊语句,主要有星号(*)和问号(?),用来对字符串进行模糊匹配(

    比如文件名、参数名)。当查找文件夹时,可以使用它来代替一个或多个真正字符;当不知道真正字符或者懒得输入完整名字时,常常使用通配符代替一个或多个真正字符.

    终端里面输入的通配符是由 Shell 处理的,不是由所涉及的命令语句处理的,它只会出现在命令的“参数值”里(它不能出现在命令名称里, 命令不记得,那就用Tab补全)。当 Shell 在“参数值”中遇到了通配符时,Shell 会将其当作路径或文件名在磁盘上搜寻可能的匹配:若符合要求的匹配存在,则进行代换(路径扩展);否则就将该通配符作为一个普通字符传递给“命令”,然后再由命令进行处理。总之,通配符实际上就是一种 Shell 实现的路径扩展功能。在通配符被处理后, Shell 会先完成该命令的重组,然后继续处理重组后的命令,直至执行该命令。

    先使用 touch 命令创建 2 个文件,后缀都为 txt

    $ touch 123456.txt asdfg.txt

    可以给文件随意命名,假如过了很长时间,你已经忘了这两个文件的文件名,现在你想在一大堆文件中找到这两个文件,就可以使用通配符:

    $ touch adsfasd.txt wergjlkas.txt



    Shell 常用通配符:

    字符 含义
    * 匹配 0 或多个字符
    ? 匹配任意一个字符
    [list] 匹配 list 中的任意单一字符
    [!list] 匹配 除list 中的任意单一字符以外的字符
    [c1-c2] 匹配 c1-c2 中的任意单一字符 如:[0-9] [a-z]
    {string1,string2,...} 匹配 string1 或 string2 (或更多)其一字符串
    {c1..c2} 匹配 c1-c2 中全部字符 如{1..10}
    6)学会在命令行获得帮助

    在 Linux 环境中,如果你遇到困难,可以使用man命令,它是Manual pages的缩写。

    Manual pages 是 UNIX 或类 UNIX 操作系统中在线软件文档的一种普遍的形式, 内容包括计算机程序(包括库和系统调用)、正式的标准和惯例,甚至是抽象的概念。用户可以通过执行man命令调用手册页。

    你可以使用如下方式来获得某个命令的说明和使用方式的详细介绍:

    $ man <command_name>
    

    比如你想查看 man 命令本身的使用方式,你可以输入:

    man man
    

    通常情况下,man 手册里面的内容都是英文的,这就要求你有一定的英文基础。man 手册的内容很多,涉及了 Linux 使用过程中的方方面面。为了便于查找,man 手册被进行了分册(分区段)处理,在 Research UNIX、BSD、OS X 和 Linux 中,手册通常被分为8个区段,安排如下:

    区段 说明
    1 一般命令
    2 系统调用
    3 库函数,涵盖了C标准函数库
    4 特殊文件(通常是/dev中的设备)和驱动程序
    5 文件格式和约定
    6 游戏和屏保
    7 杂项
    8 系统管理命令和守护进程

    要查看相应区段的内容,就在 man 后面加上相应区段的数字即可,如:

    $ man 1 ls
    

    会显示第一区段中的ls命令 man 页面。

    所有的手册页遵循一个常见的布局,为了通过简单的 ASCII 文本展示而被优化,而这种情况下可能没有任何形式的高亮或字体控制。一般包括以下部分内容:

    NAME(名称)

    该命令或函数的名称,接着是一行简介。

    SYNOPSIS(概要)

    对于命令,正式的描述它如何运行,以及需要什么样的命令行参数。对于函数,介绍函数所需的参数,以及哪个头文件包含该函数的定义。

    DESCRIPTION(说明)

    命令或函数功能的文本描述。

    EXAMPLES(示例)

    常用的一些示例。

    SEE ALSO(参见)

    相关命令或函数的列表。

    也可能存在其它部分内容,但这些部分没有得到跨手册页的标准化。常见的例子包括:OPTIONS(选项),EXIT STATUS(退出状态),ENVIRONMENT(环境),BUGS(程序漏洞),FILES(文件),AUTHOR(作者),REPORTING BUGS(已知漏洞),HISTORY(历史)和 COPYRIGHT(版权)。

    通常 man 手册中的内容很多,你可能不太容易找到你想要的结果,不过幸运的是你可以在 man 中使用搜索/<你要搜索的关键字>,查找完毕后你可以使用n键切换到下一个关键字所在处,shift+n为上一个关键字所在处。使用Space(空格键)翻页,Enter(回车键)向下滚动一行,或者使用j,k(vim 编辑器的移动键)进行向前向后滚动一行。按下h键为显示使用帮助(因为 man 使用 less 作为阅读器,实为less工具的帮助),按下q退出。

    想要获得更详细的帮助,你还可以使用info命令,不过通常使用man就足够了。如果你知道某个命令的作用,只是想快速查看一些它的某个具体参数的作用,那么你可以使用--help参数,大部分命令都会带有这个参数,如:

    $ ls --help




    展开全文
  • 二叉树的基本操作

    万次阅读 多人点赞 2019-04-21 01:43:02
    2、掌握二叉树的基本操作,如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 (一)用递归的方法实现以下算法: 1、以二叉链表表示二叉树,建立一棵二叉树(算法5.3); 2、输出二叉树的中序...

    注:实验用书为 数据结构 C语言版 第2版,人民邮电出版社出版。
    实验题目:学生管理系统的设计与实现
    实验环境:Visual C++ 6.0或其他C++环境
    一、实验目的
    1、掌握二叉树的定义;
    2、掌握二叉树的基本操作,如二叉树的建立、遍历、结点个数统计、树的深度计算等。
    二、实验内容
    (一)用递归的方法实现以下算法:
    1、以二叉链表表示二叉树,建立一棵二叉树(算法5.3);
    2、输出二叉树的中序遍历结果(算法5.1);
    3、输出二叉树的前序遍历结果(见样例);
    4、输出二叉树的后序遍历结果(见样例);
    5、计算二叉树的深度(算法5.5);
    6、统计二叉树的结点个数(算法5.6);
    7、统计二叉树的叶结点个数;
    8、统计二叉树的度为1的结点个数;
    9、输出二叉树中从每个叶子结点到根结点的路径。
    10、交换二叉树每个结点的左孩子和右孩子;
    11、设计二叉树的双序遍历(DblOrderTraverse)算法(双序遍历是指对于二叉树的每一个结点来说,先访问这个结点,再按双序遍历它的左子树,然后再一次访问这个结点,接下来按双序遍历它的右子树)。
    三、测试效果如图:
    这里写图片描述
    这里写图片描述

    四、代码如下:

    #include <iostream>
    using namespace std;
    
    typedef struct Node
    {//定义二叉树结构
        char data;
        struct Node *lchild,*rchild;
    }*BiTree,BiTNode;
    
    void CreateBiTree(BiTree &T)
    {//先序创建二叉树
        char ch;
        cin>>ch;
        if(ch=='#') T=NULL;
        else{
            T=new BiTNode;
            T->data=ch;
            CreateBiTree(T->lchild);
            CreateBiTree(T->rchild);
        }
    }
    void InOrderTraverse(BiTree T)
    {//中序遍历
        if(T)
        {
            InOrderTraverse(T->lchild);
            cout<<T->data;
            InOrderTraverse(T->rchild);
        }
    }
    void PreOrderTraverse(BiTree T)
    {//先序遍历
        if(T)
        {
            cout<<T->data;
            PreOrderTraverse(T->lchild);
            PreOrderTraverse(T->rchild);
        }
    }
    void PostOrderTraverse(BiTree T)
    {//后序遍历
        if(T)
        {
            PostOrderTraverse(T->lchild);
            PostOrderTraverse(T->rchild);
            cout<<T->data;
        }
    }
    void Copy(BiTree T,BiTree &NewT)
    {//二叉树的复制
        if(T==NULL){
            NewT=NULL;
            return;
        }else
        {
            NewT=new BiTNode;
            NewT->data=T->data;
            Copy(T->lchild,NewT->lchild);
            Copy(T->rchild,NewT->rchild);
        }
    }
    int Depth(BiTree T)
    {//树的深度
        if(T==NULL)
            return 0;
        else
        {
            int m=Depth(T->lchild);
            int n=Depth(T->rchild);
            if(m>n) return (m+1);
            else return (n+1);
        }
    }
    int NodeCount(BiTree T)
    {//统计二叉树中结点的个数
        if(T==NULL) return 0;
        else return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
    }
    int LeafCount(BiTree T)
    {//统计二叉树中叶子结点的个数
        if(!T) return 0;
        if(!T->lchild &&!T->rchild){//如果二叉树左子树和右子树皆为空,说明该二叉树根节点为叶子节点,加1.
            return 1;
        }else{
            return LeafCount(T->lchild)+LeafCount(T->rchild);
        }
    }
    int Node_1_Count(BiTree T)
    {//统计二叉树的度为1的结点个数
        if(!T) return 0;
        if((!T->lchild)&&(T->rchild)||(T->lchild)&&(!T->rchild))
            return 1 + Node_1_Count(T->lchild) + Node_1_Count(T->rchild);
        else
            return Node_1_Count(T->lchild) + Node_1_Count(T->rchild);
    }
    void PrintAllPath(BiTree T, char path[], int pathlen)
    {//二叉树中从每个叶子结点到根结点的路径
      int i;
      if(T != NULL) {
        path[pathlen] = T->data; //将当前结点放入路径中
        if(T->lchild == NULL && T->rchild == NULL) {//叶子结点
            for(i = pathlen; i >= 0; i--)
                cout << path[i] << " " ;
          cout << endl;
        }else{
          PrintAllPath(T->lchild, path, pathlen + 1);
          PrintAllPath(T->rchild, path, pathlen + 1);
        }
      }
    }
    void ExChangeTree(BiTree &T)
    {//构造函数,使用递归算法进行左右结点转换
        BiTree temp;
        if(T!=NULL){//判断T是否为空,非空进行转换,否则不转换
            temp=T->lchild;
            T->lchild=T->rchild;//直接交换节点地址
            T->rchild=temp;
            ExChangeTree(T->lchild);
            ExChangeTree(T->rchild);
        }
    }
    void DblOrderTraverse(BiTree T)
    {//二叉树的双序遍历
        if(T)
        {
            cout<<T->data;
            DblOrderTraverse(T->lchild);
            cout<<T->data;//访问两遍
            DblOrderTraverse(T->rchild);
        }
    }
    int main()
    {
        BiTree T;
        //测试例子AB#CD##E##F#GH###
        cout<<"先序遍历输入(以#结束):";
        CreateBiTree(T);
        cout<<"中序遍历输出:";
        InOrderTraverse(T);
        cout<<endl<<"先序遍历输出:";
        PreOrderTraverse(T);
        cout<<endl<<"后序遍历输出:";
        PostOrderTraverse(T);
        cout<<endl<<"树的深度:"<<Depth(T);
        cout<<endl<<"结点的个数:"<<NodeCount(T);
        cout<<endl<<"叶结点的个数:"<<LeafCount(T);
        cout<<endl<<"度为1的结点个数:"<<Node_1_Count(T);
        cout<<endl<<"二叉树中从每个叶子结点到根结点的所有路径:"<<endl;
        char path[256];
        int pathlen=0;
        PrintAllPath(T,path,pathlen);//
        //交换二叉树每个结点的左孩子和右孩子
        BiTree tem=T;//直接复制一颗树,在不改变原树的前提下,对临时树进行交换。
        ExChangeTree(tem);
        cout<<"先序遍历输出交换后的结果:";
        PreOrderTraverse(tem);
        cout<<endl<<"双序遍历输出:";
        DblOrderTraverse(T);
        return 0;
    }
    

    五、流程图:
    这里写图片描述
    这里写图片描述

    展开全文
  • 图的基本操作 还是以书上的例子来演示图的基本操作,跟着敲一遍,试着理解每一行代码,多少会有收获滴,多敲敲就可以熟练运用啦 例: 以如下图所示的带权有向图为例,编写测试上述图操作函数的程序 代码实现: ...

    图的基本操作


    还是以书上的例子来演示图的基本操作,跟着敲一遍,试着理解每一行代码,多少会有收获滴,多敲敲就可以熟练运用啦



    例: 以如下图所示的带权有向图为例,编写测试上述图操作函数的程序


    代码实现:


    注: 代码包含一个存放顶点的单链表头文件《ListVertex.h》和图的操作头文件《AdjMGraph.h》,一个测试源文件《main.cpp》

    ListVertex.h:

    #pragma once
    #include<stdio.h>
    #include<stdlib.h>
    
    /*存放图的顶点的单向链表*/
    typedef char DataType;
    typedef struct  nodeVertex
    {
        DataType data;        //数据域
        nodeVertex *next;     //指针域
    }NodeVertex;
    
    /*初始化链表*/
    void initiateSeqList(NodeVertex **head)
    {
        (*head) = (NodeVertex*)malloc(sizeof(NodeVertex));
        (*head)->next = NULL;
    }
    
    /*求链表长度*/
    int listVertexLength(NodeVertex *head)
    {
        NodeVertex *p = head;
        int i = 0;
        while (p->next != NULL)
        {
            i++;
            p = p->next;//编写的时候容易把这个语句忘掉,造成死循环,出不来结果
        }
        return i;
    }
    
    /*指定位置插入结点*/
    void listVertexInsert(NodeVertex *head, int index, DataType vertex)
    {
        NodeVertex *p = head;
        NodeVertex *q = (NodeVertex*)malloc(sizeof(NodeVertex));
        q->data = vertex;         //数据赋给新的结点
        q->next = NULL;           //新结点的指针域默认先置为空
        if (index < 0 || index > listVertexLength(p))  //防止报错
        {
            printf("参数不合法!插入失败!\n");
            return;
        }
        for (int i = 0; i < index; i++)        //遍历链表,直到指定位置index
            p = p->next;
        q->next = p->next;            //将p的下一个结点接在新结点后面
        p->next = q;                  //将新结点接在p后面
    }
    
    /*指定位置删除结点*/
    void listVertexDelete(NodeVertex *head, int index, DataType* vertex)
    {
        NodeVertex *p = head;
        if (index < 0 || index>=listVertexLength(p))  //防止报错
        {
            printf("参数不合法!插入失败!\n");
            return;
        }
        if (p->next == NULL)           //考虑空链表的情况
        {
            printf("链表已空!\n");
            return;
        }
        for (int i = 0; i < index; i++)  //遍历链表,直到指定位置
            p = p->next;
        if (p->next->next != NULL)       //如果要删除的不是最后一个结点,需要判断p->next->next是否为空,否则程序出错
            p->next = p->next->next;
        else
            p->next = NULL;              //如果要删除的是最后一个结点,直接把p的指针域置空
    
    }
    
    /*遍历输出结点*/
    void listVertexPrint(NodeVertex *head)
    {
        NodeVertex* p = head;
        while (p->next != NULL)
        {
            printf("%c ", p->next->data);
            p = p->next;
        }
        printf("\n");
    }

    AdjMGraph.h:

    #pragma once
    #include"ListVertex.h"
    #define MaxVertices 100      //最大顶点数
    #define MaxWeight 10000      //最大权值
    
    /*图的结构体*/
    typedef struct adjMGraph    
    {
        NodeVertex *VerTices;      //存放顶点
        int edge[MaxVertices][MaxVertices];//存边的二维数组
        int numOfEdges;            //边的条数
    }AdjMGraph;
    
    //初始化图
    void adjMGraphInitiate(AdjMGraph *map, int n)
    {
        int i, j;
        for (int i = 0; i < n; i++)         //初始化边
            for (int j = 0; j < n; j++)
                if (i == j)
                    map->edge[i][j] = 0;    //自身到自身,没有边,默认权值为0
                else
                    map->edge[i][j] = MaxWeight;
        map->numOfEdges = 0;                //初始化边数
        initiateSeqList(&(map->VerTices));  //单链表初始化
    }
    
    /*插入顶点*/
    void InsetVertex(AdjMGraph *map, DataType vertex)
    {
        listVertexInsert(map->VerTices, listVertexLength(map->VerTices), vertex);  //利用链表 在指定位置增加结点函数 插入顶点
    }
    
    /*插入边*/
    void InsertEdge(AdjMGraph *map, int val1, int val2, int weight)    //i,j,权值
    {
        //存放边的是一个二维数组,当i,j小于0或者i,j大于等于顶点个数,会出错
        if (val1 < 0 || val1 >= listVertexLength(map->VerTices) || val2 < 0 || val2 >= listVertexLength(map->VerTices))
        {
            printf("参数不合法!\n");
            return;
        }
        map->edge[val1][val2] = weight;     //赋边的权值
        map->numOfEdges++;                  //图中边的条数+1
    }
    
    /*删除边*/
    void DeleteEdge(AdjMGraph *map, int val1, int val2)
    {
        //同上,当i,j小于0或者i,j大于等于顶点个数,会出错
        if (val1 < 0 || val1 >= listVertexLength(map->VerTices) || val2 < 0||val2>=listVertexLength(map->VerTices)||val1==val2)
        {
            printf("参数不合法!\n");
            return;
        }
        //如果该边没有被赋过值(初始化的时候默认是MaxWeight),或者i==j时,没有这条边
        if (map->edge[val1][val2] == MaxWeight || val1 == val2)
        {
            printf("该边不存在!\n");
            return;
        }
        map->edge[val1][val2] = MaxWeight;      //若有这条边,重新恢复默认值MaxWeight
        map->numOfEdges--;                //边数-1
    }
    
    /*取第一个邻接顶点*/
    int GetFirstVex(AdjMGraph map, int index)
    /*在图中寻找index顶点的第一个邻接顶点*/
    {
        int col;
        /*参数不合法*/
        if (index < 0 || index>listVertexLength(map.VerTices))
        {
            printf("参数不合法!\n");
            return -1;
        }
        for (col = 0; col < listVertexLength(map.VerTices); col++)           //在同行取得(邻接矩阵中),一定在结点集合内
            if (map.edge[index][col] > 0 && map.edge[index][col] < MaxWeight)//值肯定在0到maxweight之间,
                return col;
        return -1;
    }
    
    /*在图中寻找val1顶点的邻接顶点val2的下一个邻接顶点*/
    int GetNextVex(AdjMGraph map, int val1, int val2)
    {
        int col;
        if (val1 < 0 || val1 >= listVertexLength(map.VerTices) || val2 < 0 || val2 >= listVertexLength(map.VerTices))
        {
            printf("参数不合法!\n");
            return -1;
        }
        for (col = val2 + 1; col < listVertexLength(map.VerTices); col++)   //col赋初值为cal2+1,在同行取得(邻接矩阵中)
        {
            if (map.edge[val1][col] > 0 && map.edge[val1][col] < MaxWeight)
                return col;
            return -1;
        }
    }
    
    //边的结构体,有行、列、权值三个属性
    struct RowColWeight    
    {
        int row;
        int col;
        int weight;
    };
    
    //在图中插入n个顶点信息V,和e条边信息E
    void CreatGraph(AdjMGraph *map, DataType V[], int n, RowColWeight E[], int e)
    {
        int i, k;
        adjMGraphInitiate(map, n);    //初始化图
        for (int i = 0; i < n; i++)   //增加n个顶点
            InsetVertex(map, V[i]);
        for (k = 0; k < e; k++)          //增加n条边
            InsertEdge(map, E[k].row,E[k].col, E[k].weight);
    }
    

    main.c:

    #include"ListVertex.h"
    #include"AdjMGraph.h"
    int main()
    {
        AdjMGraph g1;         //定义图
        DataType a[] = { 'A','B','C','D','E' };  //图的顶点集合
        RowColWeight row[] = { {0,1,10},{0,4,20},{1,3,30},{2,1,40},{3,2,50} };        //边的权值
        int p[9][9],q[9][9];
        int n = 5, e = 5;      //五个顶点和五条边
        int i, j, k;
        CreatGraph(&g1,a,n,row,e);    //创建有五个顶点,五条边的图
        //DeleteEdge(&g1, 0, 4);     //删除邻接矩阵i,j为0,4的边;
        printf("顶点集合为:");
        listVertexPrint(g1.VerTices);    //打印顶点集合(链表)
        printf("\n");
        printf("权值集合为:\n");
        for (i = 0; i < listVertexLength(g1.VerTices); i++)
        {
            for (j = 0; j < listVertexLength(g1.VerTices); j++)
                printf("%5d    ", g1.edge[i][j]);
            printf("\n");
        }
        system("pause");
        return 0;
    }

    运行结果:


    *******************************************************



    运行结果



    *******************************************************


    代码编译器:Visual Studio 2017 ok

    一个学习的小web:http://onedawn.cn/

    展开全文
  • Octave基本操作

    2019-04-24 00:57:24
    变量的基本用法: 基本加减乘除和逻辑运算: 修改符号: 赋值不加分号系统会返回提醒,加了分号则不会,%后面的内容是注释: disp()函数的使用 disp函数:显示文本或数组2、用法说明:disp(X)函数显示指定的文本或...

    变量的基本用法:
    基本加减乘除和逻辑运算:

    在这里插入图片描述
    修改符号:
    在这里插入图片描述
    赋值不加分号系统会返回提醒,加了分号则不会,%后面的内容是注释:
    在这里插入图片描述
    在这里插入图片描述
    disp()函数的使用
    disp函数:显示文本或数组2、用法说明:disp(X)函数显示指定的文本或数组
    在这里插入图片描述
    用了C语言的表达式:
    在这里插入图片描述
    format 格式
    在这里插入图片描述

    分割线分割线分割线分割线分割线分割线分割线分割线分割线分割线分割线

    向量和矩阵:
    输入矩阵
    在这里插入图片描述
    从1开始以步长0.1到2
    在这里插入图片描述
    从1到6 默认步长为1
    在这里插入图片描述
    全置为1/0的m行n列矩阵
    在这里插入图片描述
    在这里插入图片描述
    随机输出m行n列的随机矩阵
    在这里插入图片描述
    在这里插入图片描述
    高斯随机变量:
    输出服从高斯分布(正态分布)的数值
    均值为0 标准差或者方差为1
    在这里插入图片描述
    随机输出符合高斯分布10000个
    在这里插入图片描述
    可视化hist()函数 高斯分布直方图 方差为10,标准差为根号10,-6为中心
    在这里插入图片描述
    分割
    在这里插入图片描述
    n*n单位矩阵 eye(n)
    在这里插入图片描述
    size()
    在这里插入图片描述
    length() 返回矩阵的最大维数
    在这里插入图片描述
    输入help help出现操作使用帮助
    例如help rand 出现rand的使用帮助

    help rand:
    在这里插入图片描述
    help help:
    在这里插入图片描述

    展开全文
  • h5py基本操作

    千次阅读 2019-01-15 21:52:25
    h5py 文件介绍 一个h5py文件是 “dataset” 和 “group” 二合一的容器。 dataset : 类似数组组织的数据的集合,像 numpy 数组一样工作 group : 包含了其它 dataset 和 其它 group ,像字典一样工作 ...
  • 基本的文件操作

    2019-07-27 09:18:30
    目录 一、什么是文件? 二、为什么要有文件? 三、如何用文件? 3.1 从硬盘中读取数据 3.2 写入数据 ...虽然视频、音频和图片在硬盘中也是用二进制存储的,但是上一章节讲的字符编码只和文本文件有关,因为...
  • Monogo——基本操作

    千次阅读 2018-06-05 10:45:32
    mongodb的基本操作数据库相关操作查看系统中已有数据库show dbs 创建数据库mydbuse mydb 删除当前数据库db.dropDatabase() 集合相关操作查看当前数据库已有集合show collections 创建集合coll1(也可以不创建,在插入...
  • 文章目录关系代数之基本操作关系代数运算的特点关系代数运算的基本操作为什么要提出关系代数关系代数之基本操作关系代数运算的约束“并”操作“差”操作“广义笛卡尔积”操作“选择”操作投影操作小结关系代数之扩展...
  • 操作系统的基本组成部分

    千次阅读 2016-06-08 10:14:21
    1、进程管理 2、存储管理 3、文件管理 4、设备管理 5、系统调用
  • 操作系统的基本特征: 并发性、共享、虚拟、异步
  • 基本操作的约束条件 关系代数运算的基本操作 集合操作 纯关系操作 1.关系代数之基本操作 “并”操作 “差”操作 “笛卡尔积”操作 “选择”操作 “投影”操作 2.关系代数之扩展操作 1.“交”操作...
  • 关系模型之关系代数

    2019-08-21 11:12:37
    关系代数运算的基本操作为什么要提出关系代数关系代数之基本操作关系代数运算的约束(1)并操作(2)差操作(3)笛卡尔积操作(5)投影操作 学习重点 基本内容 1.关系代数之基本操作 2.关系代数之扩展操作 3.关系代数之组合...
  • 文章目录第五章 电子演示文稿第一节 PowerPoint 基础知识基本功能和编辑环境2 PPT 元素的概念和操作方法3 PPT 使用过程4 PPT 文件存储格式第二节 PowerPoint 基本操作(1)1 PPT 启动和退出2 PPT 新建演示文稿方法1 ...
  • kettle基本操作(详尽版)

    万次阅读 2018-11-27 16:47:00
    kettle基本操作(详尽版) 注意以上这些,基本上可以正常连接了,而且通过sql语句查询到的数据中文不会乱码 删除线格式 以下是转换的基本操作
  • 关系模型基本操作

    千次阅读 2019-02-22 17:10:22
    关系模型基本操作 关系模型的五种基本操作:选择,投影,并,差,笛卡尔积,其他操作都可以用这五种基本操作定义和导出。 关系操作的特点是集合操作方式,即操作的对象和结果都是集合 传统集合运算(以下R,S表示...
  • PLSQL基本操作手册

    2020-07-30 23:31:59
    PLSQL基本操作手册,常用的操作手册。PLSQL基本操作手册,常用的操作手册
  • Mac 基本操作

    2017-03-12 14:54:35
    1.截屏 2.修改文件夹权限
  • mac 基本操作

    2018-03-25 08:57:54
    1.终端查看环境变量: $ echo $PATH2.终端修改环境变量: $ sudo vi ~/.bash_profile3.终端查看系统级应用下载位置:$ which 'name'
  • OpenCV Mat基本操作总结

    千次阅读 2018-08-09 11:37:55
    OpenCV Mat基本操作总结
  • Redis通用命令

    2020-03-17 19:20:08
    Redis通用命令1.key通用操作1.key 基本操作2.key 扩展操作(时效性控制)3.key 扩展操作(查询模式)查询模式规则4.key 其他操作2.数据库通用操作1.db 基本操作2.db 相关操作 1.key通用操作 1.key 基本操作 删除...
1 2 3 4 5 ... 20
收藏数 9,470,887
精华内容 3,788,354
关键字:

基本操作