精华内容
下载资源
问答
  • 标准C语言基础知识

    2017-12-18 21:59:44
    标准C语言标准C语言标准C语言标准C语言标准C语言标准C语言标准C语言
  • 标准C语言规范

    2019-01-08 23:43:46
    标准C语言规范,详细阐述C语言标准规范,标准C语言规范阐述啊
  • 百度网盘链接:标准C语言指南 标准C语言指南 标准C语言指南 标准C语言指南 标准C语言指南 标准C语言指南 标准C语言指南
  • 标准C语言指南 基于ISO.IEC 9899.2011中文版,讲解C语言的语法规则,有利于对C语言的理解和掌握
  • 标准C语言语法 历史: 1969年之前所有的操作系统都是用汇编语言编写 肯.汤普逊 1969年 在BCPL语言的基础之后 编写了B语言 用B语言写了UNIX操作系统的内核代码 丹尼斯.里奇 1972发明C语言 在B语言的基础之上开发了...

    标准C语言语法
    历史:
    1969年之前所有的操作系统都是用汇编语言编写
    肯.汤普逊 1969年 在BCPL语言的基础之后 编写了B语言 用B语言写了UNIX操作系统的内核代码
    丹尼斯.里奇 1972发明C语言 在B语言的基础之上开发了C语言 C语言之父
    用C语言重写了UNIX内核代码
    标准:
    1983年,美国开始制定C语言标准
    1989年,制定了第一C语言标准 C89
    1999年,C99
    2011年,C1X C11
    特点:
    底层语言 C语言可以直接操作硬件

    优点:
    (1)高效 这是其它编辑语言所不具有的
    算法
    (2)功能强大
    可以操作硬件 编写应用层软件
    (3)巧灵活
    数据类型 运算符
    (4)标准库
    提供基本的操作
    (5)基本上所有的语言都可以调用C语言的代码
    (6)能够直接操作硬件

    缺点:
    (1)灵活意味着困难
    (2)比较小 不适合特别大的项目
    (3)错误隐藏比较深
    #include <stdio.h> //包含头文件 实际上是在预处理阶段进行预处理

    预处理指定

    #define
    //C语言中的函数默认返回int类型 void 表示没有返回值
    main函数的返回值其实是告诉系统这个程序执行的情况 反馈
    int main(){//main是C语言的主函数 C语言程序的入口
    printf(“Hello world!\n”);//printf是stdio.h中声明的函数 调用函数
    //“字符串”
    //\n 转义字符 换行 \t \b ’ " \r
    return 0;//返回一个值 表示该程序正确执行正常结束
    }

    语法规则:
    1.C语言源代码都是以.c为结尾
    2.注释
    方便阅读和理解程序代码的 并且不会编译到可执行程序中去内容
    // 单行注释
    /*
    多行注释
    */

    编译的步骤:gcc hello.c
    (1)预处理
    进行宏替换和头文件导入等 以及 去掉注释内容
    (2)编译
    (3)汇编
    (4)链接

    -o 对生成文件进行重命令

    程序能做什么?
    做数据处理 交互 人–电脑
    程序实现 人机交互
    什么是数据?
    世间万物 都是数据
    例如
    电影 0和1的无限组合 二进制
    图片
    帧 一帧其实就是一张图片
    图片 像素
    一个像素点 颜色(rgb) 0-255的数值
    保存一个像素点至少3个0-255的数字
    音乐
    基本数据类型
    年龄 18 整数
    余额 0.01 小数
    a b ‘中’ 字符

    整数类型: 字节
    短整型 short 2
    整数 int 4
    长整型 long 4 重要:不同的操作系统不同 4/8
    浮点类型:
    单精度浮点类型 float 4
    双精度浮点类型 double 8
    字符类型:
    char 1

    C语言为什么要分这些基本数据类型?
    1.方便计算 处理器处理数据方便
    2.节省内存
    3.为了格式化
    ‘a’ 数值

    unsigned 表示无符号类型数据
    unsigned int

    数字字面值
    1 100 168 2019

    数据在内存中的形式:二进制
    二进制是由 0和1组成的

    short int long 取值范围是多少?
    1字节 = 8bit 比特位(二进制位)

    short能够表示多大的范围:
    2字节 16个二进制位

    对于signed类型数据 二进制最高位是 符号位 1表示负数 0表示正数
    对于unsigned类型的数据 没有符号位
    short 最大值 0 15个1
    最小值 1 15个0 ???
    有符号的数二进制全是1 -1

    重要:计算机中保存的数据都是以补码形式存在
    为什么需要补码?
    1+2 二进制 原码 反码 补码
    3+(-3) 3-5 只有用补码进行计算时结果才正确
    原码:最高位表示符号位
    正数 原码 、反码、 补码一样
    负数 原码 最高为1 其它位是 其正数的原码
    反码 符号位不变 其它位按位取反
    补码 取反+1 且符号位不变
    负数不管以哪一种码制存在,最高位是1

    八个二进制位
    原码形式:
    0000 0011 0000 0011
    1000 0011 0000 0101


    1000 0110 = -6 1111 1110 不等于 -2
    反码形式:
    0000 0011 0000 0011
    1111 1100 0000 0101


     1111 1111 = 不是0 1111 1110 反码 1000 0001 =-1
    

    补码形式:
    0000 0011
    1111 1101

    10000 0000 最高位溢出 结果为0       
    
    1111 1110 补码 最高位是符号位 负数
       1111 1101 按位取反 1000 0010 = -2  
    

    C语言程序中如何保存数据?
    变量: 可以临时保存C语言中的数据

    (1)变量的定义
    数据类型 标识符;
    //为什么变量要有数据类型
    变量所标识的内存大小
    变量所存在数据的类型
    一个变量如果没有初始化(第一次赋值),那么变量里面将保存一个随机值(垃圾值)
    所以一般定义变量时都会进行初始化操作
    变量必须先定义(声明)才能使用
    在同一个作用域下面,同名的变量只能有一个
    同类型的变量可以一次性声明,中间用逗号隔开,然后每个变量独自初始化

    (2)变量名(标识符)规则
    a.由数字、字母、_(下划线)组成
    b.不能由数字开头
    c.不能和C语言的关键字冲突
    C89有32个关键字
    d.允许标识符无限长 但是C89只识别前31个字符 C99中有63个字符
    e.标识符区分大小写
    建议:
    (i) 标识符驼峰式/下划线方式
    nameOfStudent name_of_student
    驼峰式: 从第二个单词开始首字母大小,其余全部小写
    下划线: 单词之间用_连接
    (ii)见名知义
    int a = 10;
    int age = 18;
    (iii)见名知类型
    int iAge = 18;
    double dSalary = 323.325;
    C语言32个关键字:
    a.数据类型
    char short int long float double
    unsigned signed void
    enum struct union
    b.循环
    for while do goto break continue
    c.分支选择
    if else switch case default
    d.数据存储
    auto static extern const register volatile
    e.其它
    typedef sizeof return

    (3)变量的初始化
    变量初始化之后是一个确切的值
    局部变量和块变量在声明的时候是一个垃圾值,所以一般会选择初始为0或者其它有意义的值

    变量是一个左值(可以放在=左边)

    变量的本质是标识一块内存空间 操作变量其实是操作这一块内存空间

    (4)变量的操作
    变量 = 值; 往变量所标识的内存区域写入一个数据
    printf("%x",变量) 取得变量所标识内存区域的数值

    (5)变量的作用
    a.保存数据 方便计算

    格式输入输出
    格式输出:
    printf(格式字符串,列表)
    格式字符串 占位符 %
    %- m.n h|l 占位符
    -左对齐 省略默认右对齐
    m 域宽 总位数
    n 小数点后位数
    h 短整型
    l 长整型 lf 双精度浮点类型
    i/d 十进制整数 %i %d没有区别
    u 无符号整数
    f 单精度浮点数
    e 浮点类型科学计数法形式
    g 以简短形式显示浮点类型 省略多余的0
    x 十六进制
    o 八进制
    c 字符
    s 字符串
    p 输出地址(指针)
    格式输入
    scanf(格式字符串,地址列表)
    地址列表: 即对变量名进行&运算 请记住&
    %d %i
    %d 输入十进制的数据
    %i 可以输入任意进制的数据

    负数补码
    正数按位取反+1

    char类型
    ascii码表
    十进制 字符
    65 ‘A’
    97 ‘a’
    48 ‘0’

    进制:
    二进制
    八进制
    十进制
    十六进制
    在C语言程序中允许使用八进制、十进制、十六进制的数字
    十六进制: 0x 0X 例: 0x32af
    八进制: 0 例: 0773

    十进制的数据:
    25 234 -7 -15
    求二进制(补码)
    八进制 从右往左 三个二进制位为一个八进制位转换
    十六进制 从右往左 四个二进制位为一个八进制位转换

    十进制转二进制:
    除2求余
    234 24个0 1110 1010 从右往左 三个二进制位为一个八进制位转换
    011 101 010 000000000352 0x000000ea

    -15 24个1 1111 0001 037777777761 0xfffffff1

    二进制转十进制:
    0101 1011 = 累加和 基*2^权
    2^6 + 2^4 + 2^3 + 2^1 + 2^0

    1024 512 256 128 64 32 16 8 4 2 1
    1 1 1 0 1 0 1 0

    奇数 二进制末尾为1
    偶数 二进制末尾为0
    234-128=106-64=42-32=10-8=2-2=0

    0x37f6a = 316^4 + 716^3 + 1516^2 + 616^1 + 10;

    浮点数:
    IEEE
    float 4字节 32个二进制位
    1符号位 8个指数位 23尾数位
    13.25 ==> 1101.01
    处理成 1.10101 * 2^3 1.xxxx * 2^n
    0.75 ==> 0.11
    处理成 1.1 * 2^-1
    1.尾数位 * 2^指数位

        8个二进制位取值范围 [-128,127]
        +- 1.(23个1)*2^127
        = (2- 2^-23) * 2^127
        = 2^128 - 2^104
        = 3.4*10^38
    

    小数点后精确6位 6-7位

    浮点类型表示一个不精确的数值
    单精度浮上数怎么表示"零" 用一个取值范围
    (-0.0000001,0.0000001)
    double 8字节 64个二进制位
    1符号位 11指数位 52尾数位
    11 指数位 [-1024,1023]
    1.(52个1) * 2^1023
    = (2 - 2-52)*21023
    = 2^1024 - 2^971
    = 1.79*10^308
    小数点后精确12 15-16位

    double
    操作符(运算符)
    1.算术运算符

        • / %
          +,-,* 可能数据溢出
          / 除法
          注意:对于整数 只保留整数部分
          除数不能为0 浮点类型除外
          同类型数据在进行算术运算时结果也是同类型的
          混合运算
          char->short->int->long->float->double
          unsigned+signed ==> unsigned

    % 取余数
    只有整数才能进行取余运算
    %对于浮点类型数据 报错

    2.赋值运算符

    混合赋值 += -= *= /= %=
    int a = 10;
    float f = a = 3.14;
    int b = 10;
    f = (a=b) = 7; //Error
    3.自增减
    ++ –
    ++ 自增1
    x++; ++x; x = x+1;
    int y = ++x; //x = x+1; y = x; 先自增 后运算
    int y = x++; //y = x; x = x+1; 先运算 后自增
    – 自减1

    建议:
    (i)不要在一个表达式中对同一个变量进行多次+±-运算
    (ii) 最好不要对浮点类型进行+±-
    (iii) 最好不要在调用函数传递时用+±-

    指针+±-

    4.关系运算符

    = < <= == !=

    5.逻辑运算符
    && || !

    6.位运算符
    & | ^ ~ >> <<

    7.条件运算符 三目运算符
    ?:

    8.其它
    []
    ()
    ,
    .
    *
    &
    ->
    sizeof

    展开全文
  • 完整的标准C语言教材

    2011-09-25 10:29:47
    完整的标准C语言教材,适用于c语言初学者入门适用,也适用于作为一本数据手册查询。
  • 标准C语言头文件

    万次阅读 2015-03-24 22:50:15
    标准C语言头文件 ISO C标准定义的头文件(24项) 验证程序断言 支持复数算术运算 字符类型  出错码 浮点环境 浮点常量  整型格式转换 替代关系操作符宏 实现常量  局部类别 数学常量 非...

    标准C语言头文件

    ISO C标准定义的头文件(24项)

    <assert.h> 验证程序断言       <complex.h> 支持复数算术运算      <ctype.h> 字符类型

    <errno.h> 出错码             <fenv.h> 浮点环境                <float.h> 浮点常量

    <inttypes.h> 整型格式转换     <iso646.h> 替代关系操作符宏        <limits.h> 实现常量

    <locale.h> 局部类别          <math.h> 数学常量                <setjmp.h> 非局部goto

    <signal.h> 信号              <stdarg.h> 可变参数表            <stdbool.h> 布尔类型和值

    <stddef.h> 标准定义          <stdint.h> 整型                  <stdio.h> 标准I/O库

    <stdlib.h> 实用程序库函数     <string.h> 字符串操作            <tgmath.h> 通用类型数学宏

    <time.h> 时间和日期          <wchar.h> 宽字符支持             <wctype.h> 宽字符分类和映射支持

    POSIX标准定义的必须的头文件(26项)

    <dirent.h> 目录项            <fcntl.h> 文件控制               <fnmatch.h> 文件名匹配类型

    <glob.h> 路径名模式匹配类型    <grp.h> 组文件                   <netdb.h> 网络数据库操作

    <pwd.h> 口令文件             <regex.h> 正则表达式             <tar.h> tar归档值

    <termios.h> 终端I/O         <unistd.h> 符号常量              <utime.h> 文件时间

    <wordexp.h> 字扩展类型       <arpa/inet.h> Internet定义      <net/if.h> 套接字本地接口

    <netinet/in.h> Internet地址族 <netinet/tcp.h> 传输控制协议 <sys/mman.h> 内存管理声明

    <sys/select.h> select函数   <sys/socket.h> 套接字接口    <sys/stat.h> 文件状态

    <sys/times.h> 进程时间       <sys/types.h> 基本系统数据类型 <sys/un.h> UNIX域套接字定义

    <sys/utsname.h>系统名        <sys/wait.h> 进程控制

    POSIX标准定义的XSI扩展头文件(26项)

    <cpio.h> cpio归档值         <dlfcn.h> 动态链接               <fmtmsg.h> 消息显示结构

    <ftw.h> 文件树漫游           <iconv.h> 代码集转换实用程序       <langinfo.h> 语言信息常量

    <libgen.h> 模式匹配函数定义   <monetary.h> 货币类型            <ndbm.h> 数据库操作

    <nl_types.h> 消息类别        <poll.h> 轮询函数                <search.h> 搜索表

    <strings.h> 字符串操作       <syslog.h> 系统出错日志记录       <ucontext.h> 用户上下文

    <ulimit.h> 用户限制          <utmpx.h> 用户帐户数据库          <sys/ipc.h> IPC

    <sys/msg.h> 消息队列         <sys/resource.h> 资源操作    <sys/sem.h> 信号量

    <sys/shm.h> 共享存储         <sys/statvfs.h> 文件系统信息      <sys/time.h> 时间类型

    <sys/timeb.h> 附加的时间     <sys/uio.h> 矢量I/O操作

    POSIX标准定义的可选头文件(8项)

    <aio.h> 异步I/O             <mqueue.h> 消息队列              <pthread.h> 线程

    <sched.h> 执行调度           <semaphore.h> 信号量             <spawn.h> 实时spawn接口

    <stropts.h> XSI STREAMS接口 <trace.h> 时间跟踪


    标准 C++ 语言头文件(54个其中16个用于构建STL,3个为附加非必须) 

    <algorithm> STL通用算法     <bitset> STL位集容器             <cassert> 用于在程序运行时执行断言

    <cctype> 字符处理            <cerrno> 错误码                  <cfloat> 用于测试浮点类型属性
    <ciso646> ISO646变体字符集   <climits> 测试整数类型属性    <clocale> 本地化函数

    <cmath> 数学函数             <complex> 复数类                <csetjmp> 执行非内部的goto语句

    <csignal> 信号               <cstdarg> 访问参数数量变化的函数   <cstddef> 用于定义实用的类型和宏

    <cstdio> 输入/输出           <cstdlib> 杂项函数及内存分配       <cstring> 字符串

    <ctime> 时间                 <cwchar> 宽字符处理及输入/输出     <cwctype> 宽字符分类

    <deque> STL双端队列容器      <exception> 异常处理类            <fstream> 文件流    

    <functional> STL函数对象     <iomanip> 参数化输入/输出         <ios> 基本输入/输出支持

    <iosfwd> 输入/输出前置声明    <iostream> 数据流输入/输出        <istream> 基本输入流

    <iterator> 遍历序列的类       <limits> 各种数据类型最值常量      <list> STL线性列表容器

    <locale> 国际化支持           <map> STL映射容器                <memory> 专用内存分配器

    <new> 基本内存分配和释放       <numeric> 通用的数字操作          <ostream> 基本输出流

    <queue> STL 队列容器         <set> STL 集合容器               <sstream> 基于字符串的流

    <stack> STL 堆栈容器         <stdexcept> 标准异常类            <streambuf> iostream 的缓冲区类

    <string> 字符串类            <strstream> 非内存字符序列的流类   <typeinfo>  运行时类型标识

    <utility> STL 通用模板类      <valarray> 支持值数组的类和模版类  <vector> STL 动态数组容器

    标准C++附加的头文件(3个)非必须

    <hash_map>                  <hash_set>                      <slist>

    展开全文
  • 一个用标准c语言写的扫雷小游戏,是一个很好的例子用于联系c语言的基本语句和逻辑。
  • 标准C语言指南

    2016-03-14 10:55:43
    本书基于C语言的最新标准ISO/IEC 9899:2011,力求全面介绍这门计算机语言的各个方面:词法元素、类型、声明、表达式、语句等,全书内容按概念和术语分类组织,示例丰富,查阅方便,适合具有一定C语言基础的各类专业...
  • 标准C语言基础教程所有代码!配套标准C语言基础教程教材!
  • 标准C语言函数库

    2007-06-14 16:09:10
    标准C语言函数库..
  • 本书基于C语言的最新标准ISO/IEC 9899:2011-C11标准,力求全面地介绍这门计算机语言的各个方面:词法元素、类型、声明、表达式、语句等,全书内容按概念和术语分类组织,示例丰富,查阅方便,适合具有一定C语言基础...
  • 标准C语言xmlparse

    2007-11-08 15:20:05
    标准C语言XML文本解析程序, 精巧易用,单一程序.
  • 标准C语言实用全书

    2006-05-24 13:42:39
    标准C语言实用全书,对C语言的复杂性和核心特征进行了详细的论述。
  • 标准C语言实用全书,有点老,但是是绝对经典的讲述标准C语言的提高书籍
  • C语言函数大全下载语法着色版┆提供所有标准C语言函数用法
  • 标准C语言头文件 ISO C标准定义的头文件(24项) “assert.h” 验证程序断言 “complex.h” 支持复数算术运算 “ctype.h” 字符类型 “errno.h” 出错码 “fenv.h” 浮点环境 “float.h” 浮点常量 “inttypes...

    标准C语言头文件 ISO C标准定义的头文件(24项)

    • “assert.h” 验证程序断言
    • “complex.h” 支持复数算术运算
    • “ctype.h” 字符类型
    • “errno.h” 出错码
    • “fenv.h” 浮点环境
    • “float.h” 浮点常量
    • “inttypes.h” 整型格式转换
    • “iso646.h” 替代关系操作符宏
    • “limits.h” 实现常量
    • “locale.h” 局部类别
    • “math.h” 数学常量
    • “setjmp.h” 非局部goto
    • “signal.h” 信号
    • “stdarg.h” 可变参数表
    • “stdbool.h” 布尔类型和值
    • “stddef.h” 标准定义
    • “stdint.h” 整型
    • “stdio.h” 标准I/O库
    • “stdlib.h” 实用程序库函数
    • “string.h” 字符串操作
    • “tgmath.h” 通用类型数学宏
    • “time.h” 时间和日期
    • “wchar.h” 宽字符支持
    • “wctype.h” 宽字符分类和映射支持
    • POSIX标准定义的必须的头文件(26项)
    • “dirent.h” 目录项
    • “fcntl.h” 文件控制
    • “fnmatch.h” 文件名匹配类型
    • “glob.h” 路径名模式匹配类型
    • “grp.h” 组文件
    • “netdb.h” 网络数据库操作
    • “pwd.h” 口令文件
    • “regex.h” 正则表达式
    • “tar.h” tar归档值
    • “termios.h” 终端I/O
    • “unistd.h” 符号常量
    • “utime.h” 文件时间
    • “wordexp.h” 字扩展类型
    • “arpa/inet.h” Internet定义
    • “net/if.h” 套接字本地接口
    • “netinet/in.h” Internet地址族
    • “netinet/tcp.h” 传输控制协议
    • “sys/mman.h” 内存管理声明
    • “sys/select.h” select函数
    • “sys/socket.h” 套接字接口
    • “sys/stat.h” 文件状态
    • “sys/times.h” 进程时间
    • “sys/types.h” 基本系统数据类型
    • “sys/un.h” UNIX域套接字定义
    • “sys/utsname.h”系统名
    • “sys/wait.h” 进程控制

    POSIX标准定义的XSI扩展头文件(26项)

    • “cpio.h” cpio归档值
    • “dlfcn.h” 动态链接
    • “fmtmsg.h” 消息显示结构
    • “ftw.h” 文件树漫游
    • “iconv.h” 代码集转换实用程序
    • “langinfo.h” 语言信息常量
    • “libgen.h” 模式匹配函数定义
    • “monetary.h” 货币类型
    • “ndbm.h” 数据库操作
    • “nl_types.h” 消息类别
    • “poll.h” 轮询函数
    • “search.h” 搜索表
    • “strings.h” 字符串操作
    • “syslog.h” 系统出错日志记录
    • “ucontext.h” 用户上下文
    • “ulimit.h” 用户限制
    • “utmpx.h” 用户帐户数据库
    • “sys/ipc.h” IPC
    • “sys/msg.h” 消息队列
    • “sys/resource.h” 资源操作
    • “sys/sem.h” 信号量
    • “sys/shm.h” 共享存储
    • “sys/statvfs.h” 文件系统信息
    • “sys/time.h” 时间类型
    • “sys/timeb.h” 附加的时间
    • “sys/uio.h” 矢量I/O操作

    POSIX标准定义的可选头文件(8项)

    • “aio.h” 异步I/O
    • “mqueue.h” 消息队列
    • “pthread.h” 线程
    • “sched.h” 执行调度
    • “semaphore.h” 信号量
    • “spawn.h” 实时spawn接口
    • “stropts.h” XSI STREAMS接口
    • “trace.h” 时间跟踪
    展开全文
  • 树状显示二叉树(标准C语言实现)

    千次阅读 多人点赞 2019-02-28 18:25:53
    二叉搜索树的黑框树状显示(标准C语言实现) 最近在用C语言实现平衡二叉搜索树,用了半天时间实现了树的基本功能后,发现我的二叉树打印方法还是停留在简单的逐行打印,此时的效果图如下: 一行的每两个数值分别...

    二叉搜索树的黑框树状显示(标准C语言实现)

    最近在用C语言实现平衡二叉搜索树,用了半天时间实现了树的基本功能后,发现我的二叉树打印方法还是停留在简单的逐行打印,此时的效果图如下:
    在这里插入图片描述
    一行的每两个数值分别对应上一行一个数值的左右孩子,用星号表示空。无疑这种表示方法十分鸡肋,利用人工点数的方式确定节点的左右孩子,实在不方便调试和扩展功能,如果节点多了可能还会造成开发者白内障,危害极大。

    出于开发效率和个人身体健康考虑,我觉得我的程序应该可以有一种直观的二叉搜索树显示方式,比如树状打印就是很好的方式,百度浏览了一番找不到前辈们的代码,估计不怕麻烦用C语言写这个的人比较少。既然这样,那就自己动手,写一个二叉搜索树的树状显示函数,冲!

    ps:
    本程序用MacOS系统下的Xcode编译器开发,未使用windows下的API,整颗树状图都是用空格移动坐标进行逐行打印,具有不错的兼容性,男女老少皆可食用。

    正文分割线


    先上实现效果图:
    在这里插入图片描述

    接下来就是大概的实现方法:

    可以看到效果图中除了数值和括号主要用到的符号就是竖线和下划线,但是在写这个方法的初期我们可以先忽略下划线和竖线,我们可以首先实现数值打印,让节点的值在控制台中对应的坐标中显示,如图:
    在这里插入图片描述
    开始的这一步想了挺久,最后想到数值在中序遍历序列中的位置既可以用来确定数值的横坐标,如果观察上面的图应该也可以发现,数值的横坐标也是按照从小到达逐渐递增的,而纵坐标则可以通过树的深度来确定,想通这一点,实现上面图中的效果就不难了。

    typedef int ElemType;
    typedef struct node
    {
        ElemType key;
        struct node  *lchild, *rchild;
        int height;
    }BNode,*BTree;
    

    中序遍历二叉树并储存在数组中:

    /*定义全局变量用于确定数组下标,因为使用了递归遍历的方法,
    下标很难通过传参的方式确定,所以使用了全局变量,其实可以使用栈结构来储存但是懒于再写栈的代码了。
    现在的方法虽然有点影响代码的结构性不过暂时没想到其他方便的方法*/
    
    树的结构体:
    
    
    
    int a=0;//全局变量
    
    void saveInTraversal(BTree root,int *term)
    {
        if(!root)
            return;
        else
        {
            saveInTraversal(root->lchild,term);
            term[a++]=root->key;
            saveInTraversal(root->rchild,term);
        }
    }
    

    在中序遍历序列中查找某个数值的位置:

    /**
     *@brief 中序遍历序列中查找某个数值的位置
     *@param term 中序遍历序列数组
     *@param n 数组长度
     *@param x 需要搜索的数值
     */
    int findNum(int *term, int x, int n)
    {
        for(int i=0;i<n;i++)
            if(term[i]==x)
                return i+1;
        return -1;
    }
    

    获取节点深度:

    int deepth(BTree root)
    {
        if (!root)
        {
            return 0;
        }
        int left=deepth(root->lchild);
        int right=deepth(root->rchild);
        return left>=right ? left+1:right+1;
    }
    

    获取节点的子节点个数:

    int count(BTree T,int num)
    {
        if(!T)
            return num;
        else
        {
            num=count(T->lchild,num);
            num=count(T->rchild,num);
        }
        num++;
        return num;
    }
    

    显示函数(无下划线和竖线):

    
    #define MAX(a,b) ((a)>(b)?(a):(b))	//取两者最大值
    #define MAX_DIGITS 4	//二叉树树节点值的最大位数。比如树中最大的节点值为1000,则设为4,假设最大为10000,则应设为5,如果设置的该常量数字比节点最大值位数小,则会导致位置错乱
    #define MAX_NODE 100//二叉树树的最大节点树目
    
    
    void display(BTree root)
    {
        int absotiveDistance[2];//绝对距离,[1]表示上一个兄弟节点,[0]-[1]用于计算节点的相对距离
        int array[MAX_NODE]={0};//用于储存搜索二叉树的中序遍历序列
        int relativeDistance=0;//相对距离
        
    	//定义标志节点N,节点的子孩子为空时用于占位识别
        BTree N;
        N=(BTree)malloc(sizeof(BNode));
        N->key=-1;
        N->lchild=NULL;
        N->rchild=NULL;
        N->height=0;
    
        int deep=deepth(root);
        saveInTraversal(root, array);
    
    	//临时变量,用于层序遍历
        int k=0;
        int j=1;
        int n=1;
    
    	BTree term[MAX_NODE]={NULL};//指针数组,储存树节点,用于层序遍历
        term[0]=root;
        while(n!=deep+1)
        {
            absotiveDistance[0]=0;
            absotiveDistance[1]=0;
            if(term[k]->lchild!=NULL&&term[k]->lchild!=N)
                term[j++]=term[k]->lchild;
            else
                term[j++]=N;
            if(term[k]->rchild!=NULL&&term[k]->rchild!=N)
                term[j++]=term[k]->rchild;
            else
                term[j++]=N;
            k++;
            if(k==pow(2,n)-1)
            {
                for(int i=pow(2,n-1)-1;i<k;i++)
                {
                    absotiveDistance[0]=findNum(array, term[i]->key, count(root, 0))*MAX_DIGITS;
                    if(absotiveDistance[0]==-MAX_DIGITS)
                        continue;
                    relativeDistance=absotiveDistance[0]-absotiveDistance[1];
    
                    absotiveDistance[0]+=digits(term[i]->key)+2;
    
                    absotiveDistance[1]=absotiveDistance[0];
                    for(int m=0;m<relativeDistance;m++)
                    {
                        printf(" ");
                    }
                    if(term[i]!=N)
                    {
                        printf("(%d)",term[i]->key);
                    }
                }
                printf("\n");
                printf("\n");
                n++;
            }
        }
    }
    

    这里有必要解释一下我使用的层序遍历方法,因为别人看的话的确会难以理解。
    首先层序遍历是难以用递归去实现的,需要用一个节点指针数组去进行储存层序序列。
    (更新(2019.7.12):上面这里有误,评论区大佬已经用精简的层序遍历递归算法糊我脸上了,具体看评论区大神【可爱的LYF】的代码!!流下了不学无术的泪水)

    在这里插入图片描述
    完成了这一步之后,就实现了节点在特定的位置打印,不过为了更方便观看,还需要加上用下划线和竖线组成的“枝干”

    这里我只阐述一下我自己的实现思路

    因为没有用到坐标定位打印,所以只能逐层去打印,这样子的话一层的下划线长度和竖线位置都需要从上一层就确定好,即在打印一层的时候需要有预见性的打印对应左右孩子位置长度的下划线。

    此时可以定义两个变量,通过用findNum()获取左右孩子的位置,再计算相对位置,便可以实现预见性打印相应长度的下划线了,如图:
    在这里插入图片描述

    接下来就是竖线的打印。
    这里我们可以定义一个数组,用于储存竖线的位置。
    而竖线的位置的获取方法和下划线的相似,通过获取左右孩子的位置就可以确定了。

    最后贴上所有源码:

    ————————————————————————fun.c——————————————————————————————

    //
    //  fun.c
    //  AVL数
    //
    //  Created by 川十 on 2019/2/20.
    //  Copyright © 2019年 川十. All rights reserved.
    //
    
    #include "fun.h"
    #define MAX(a,b) ((a)>(b)?(a):(b))
    #define MAX_DIGITS 4
    #define MAX_NODE 100
    #define MAX_TMP 10000  //MAX_NODE^2
    int a=0;
    
    void display(BTree root)
    {
        int k=0;
        int j=1;
        int n=1;
        int deep=deepth(root);
        BTree N;
        N=(BTree)malloc(sizeof(BNode));
        N->key=0;
        N->lchild=NULL;
        N->rchild=NULL;
        N->height=0;
        BTree term[MAX_TMP]={NULL};
        term[0]=root;
        while(n!=deep+1)
        {
            if(term[k]->lchild!=NULL&&term[k]->lchild!=N)
                term[j++]=term[k]->lchild;
            else
                term[j++]=N;
            if(term[k]->rchild!=NULL&&term[k]->rchild!=N)
                term[j++]=term[k]->rchild;
            else
                term[j++]=N;
            k++;
            if(k==pow(2,n)-1)
            {
                for(int i=pow(2,n-1)-1;i<k;i++)
                {
                    if(term[i]!=N)
                        printf("%d ",term[i]->key);
                    else
                        printf("* ");
                }
                printf("\n");
                n++;
            }
        }
    }
    
    int deepth(BTree root)
    {
        if (!root)
        {
            return 0;
        }
        int left=deepth(root->lchild);
        int right=deepth(root->rchild);
        return left>=right ? left+1:right+1;
    }
    
    BTree creatTree(BTree root, int n)
    {
        srand((unsigned) time(NULL));
        root->rchild=NULL;
        root->lchild=NULL;
        root->height=0;
        root->key=abs(rand())%1000;
        int term[MAX_NODE]={0};
        int flag;
        term[0]=root->key;
        for(int i=1;i<n;i++)
        {
            flag=0;
            int num=abs(rand())%1000;
            for(int j=0;j<i;j++)
            {
                if(term[j]==num)
                {
                    flag=1;
                    i--;
                }
            }
            if(!flag)
            {
                root=insert(root, num);
                term[i]=num;
            }
        }
        
        return root;
    }
    
    
    BTree insert(BTree t,int x)
    {
        if(!t)
        {
            t=(BTree)malloc(sizeof(BNode));
            t->key=x;
            t->lchild=NULL;
            t->rchild=NULL;
            t->height=0;
        }
        else if(x<t->key)
        {
            t->lchild=insert(t->lchild,x);
            if(height(t->lchild)-height(t->rchild)==2)
            {
                if(x<t->lchild->key)
                    t=LL_rotation(t);
                else
                    t=LR_rotation(t);
            }
        }
        else if(x>t->key)
        {
            t->rchild=insert(t->rchild,x);
            if(height(t->rchild)-height(t->lchild)==2)
            {
                if(x>t->rchild->key)
                    t=RR_rotation(t);
                else
                    t=RL_rotation(t);
            }
        }
        else
        {
            printf("不允许插入相同节点!\n");
        }
        t->height=MAX(height(t->lchild),height(t->rchild))+1;
        return t;
    }
    
    BTree LL_rotation(BTree T)
    {
        BTree k2=T->lchild;
        T->lchild=k2->rchild;
        k2->rchild=T;
        T->height=MAX(height(T->rchild),height(T->lchild))+1;
        k2->height=MAX(height(T->rchild),height(T->lchild))+1;
        
        return k2;
    }
    BTree LR_rotation(BTree T)
    {
        T->lchild=RR_rotation(T->lchild);
        T=LL_rotation(T);
        return T;
    }
    BTree RR_rotation(BTree T)
    {
        BTree k2=T->rchild;
        T->rchild=k2->lchild;
        k2->lchild=T;
        T->height=MAX(height(T->rchild),height(T->lchild))+1;
        k2->height=MAX(height(T->rchild),height(T->lchild))+1;
        
        return k2;
    }
    BTree RL_rotation(BTree T)
    {
        T->rchild=LL_rotation(T->rchild);
        T=RR_rotation(T);
        return T;
    }
    
    
    int height(BTree T)
    {
        if(!T)
            return 0;
        else
            return T->height;
    }
    
    void preTraversal(BTree root)
    {
        if(!root)
            return;
        else
        {
            printf("%d ",root->key);
            preTraversal(root->lchild);
            preTraversal(root->rchild);
        }
    }
    
    void inTraversal(BTree root)
    {
        if(!root)
            return;
        inTraversal(root->lchild);
        printf("%d ",root->key);
        inTraversal(root->rchild);
    }
    
    void saveInTraversal(BTree root,int *term)
    {
        if(!root)
            return;
        else
        {
            saveInTraversal(root->lchild,term);
            term[a++]=root->key;
            saveInTraversal(root->rchild,term);
        }
    }
    
    int count(BTree T,int num)
    {
        if(!T)
            return num;
        else
        {
            num=count(T->lchild,num);
            num=count(T->rchild,num);
        }
        num++;
        return num;
    }
    
    void display2(BTree root)
    {
        int absotiveDistance[2];//绝对距离,[1]表示上一个兄弟节点,[0]-[1]用于计算节点的相对距离
        int array[MAX_NODE]={0};//用于储存搜索二叉树的中序遍历序列
        int relativeDistance=0;//相对距离
        int leftLineNum=0;//节点左边需打印的下划线符号个数
        int rightLineNum=0;//节点右边需打印的下划线符号个数
        int rightLineNum2=0;//零时变量,用于储存需打印节点的上一个兄弟节点右边打印了的下划线符号个数,便于计算需移动位数。(relativeDistance-rightLineNum2)
        int vertiLineArray[MAX_NODE]={0};//竖线位置存储
        int vertiLineNum=0;//用于记录下一行需打印的竖线个数
        
        
    
        
        
        //定义标志节点N,节点的子孩子为空时用于占位识别
        BTree N;
        N=(BTree)malloc(sizeof(BNode));
        N->key=-1;
        N->lchild=NULL;
        N->rchild=NULL;
        N->height=0;
        
        int deep=deepth(root);
        saveInTraversal(root, array);
        
        //临时变量,用于层序遍历
        int k=0;
        int j=1;
        int n=1;
        
        BTree term[MAX_TMP]={NULL};//指针数组,储存树节点,用于层序遍历
        term[0]=root;
        while(n!=deep+1)
        {
            absotiveDistance[0]=0;
            absotiveDistance[1]=0;
            if(term[k]->lchild!=NULL&&term[k]->lchild!=N)
                term[j++]=term[k]->lchild;
            else
                term[j++]=N;
            if(term[k]->rchild!=NULL&&term[k]->rchild!=N)
                term[j++]=term[k]->rchild;
            else
                term[j++]=N;
            k++;
            if(k==pow(2,n)-1)
            {
                rightLineNum2=0;
                vertiLineNum=0;
                for(int i=pow(2,n-1)-1;i<k;i++)
                {
                    leftLineNum=0;
                    rightLineNum=0;
                    absotiveDistance[0]=findNum(array, term[i]->key, count(root, 0))*MAX_DIGITS;
                    if(absotiveDistance[0]==-MAX_DIGITS)
                        continue;
                    relativeDistance=absotiveDistance[0]-absotiveDistance[1];
    
                    absotiveDistance[0]+=digits(term[i]->key)+2;
    
                    absotiveDistance[1]=absotiveDistance[0];
                    if(term[i]->lchild!=N&&term[i]->lchild!=NULL)
                    {
                        leftLineNum=(absotiveDistance[0]-findNum(array, term[i]->lchild->key, count(root, 0))*MAX_DIGITS)-digits(term[i]->key)-4;
                        vertiLineArray[vertiLineNum++]=findNum(array, term[i]->lchild->key, count(root, 0))*MAX_DIGITS+2;
                    }
                    if(term[i]->rchild!=N&&term[i]->rchild!=NULL)
                    {
                        rightLineNum=(findNum(array, term[i]->rchild->key, count(root, 0))*MAX_DIGITS-absotiveDistance[0])+2;
                        vertiLineArray[vertiLineNum++]=findNum(array, term[i]->rchild->key, count(root, 0))*MAX_DIGITS+1;
                    }
                    for(int m=0;m<(rightLineNum2==0?(relativeDistance-leftLineNum) : (relativeDistance-leftLineNum-rightLineNum2));m++)
                    {
                        printf(" ");
                    }
                    
                    for(int m=0;m<leftLineNum;m++)
                    {
                        printf("_");
                    }
                   
                    if(term[i]!=N)
                    {
                        printf("(%d)",term[i]->key);
                    }
                    
                    for(int m=0;m<rightLineNum;m++)
                        printf("_");
                     
                    rightLineNum2=rightLineNum;
                }
                printf("\n");
                if(vertiLineNum)
                {
                for(int m=0;m<vertiLineNum;m++)
                    {
                        for(int j=0;j<(m==0?vertiLineArray[m] : vertiLineArray[m]-vertiLineArray[m-1]);j++)
                            printf(" ");
                        printf("|");
                        vertiLineArray[m]++;
                    }
                }
                printf("\n");
                n++;
            }
        }
    }
    
    int findNum(int *term, int x, int n)
    {
        for(int i=0;i<n;i++)
            if(term[i]==x)
                return i+1;
        return -1;
    }
    
    int digits(int x)
    {
        int num=0;
        while(x!=0)
        {
            x/=10;
            num++;
        }
        return num;
    }
    
    
    

    ————————————————————————fun.h—————————————————————————————

    //
    //  fun.h
    //  AVL数
    //
    //  Created by 川十 on 2019/2/20.
    //  Copyright © 2019年 川十. All rights reserved.
    //
    
    #ifndef fun_h
    #define fun_h
    
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <math.h>
    #include <time.h>
    
    typedef int ElemType;
    typedef struct node
    {
        ElemType key;
        struct node  *lchild, *rchild;
        int height;
    }BNode,*BTree;
    
    void display(BTree root);
    void preTraversal(BTree root);
    void inTraversal(BTree root);
    void saveInTraversal(BTree root,int *term);
    int digits(int x);
    int findNum(int *term, int x, int n);
    int count(BTree T,int num);
    int deepth(BTree root);
    BTree insert(BTree t,int x);
    int height(BTree T);
    BTree creatTree(BTree root, int n);
    void display2(BTree T);
    BTree LL_rotation(BTree T);
    BTree LR_rotation(BTree T);
    BTree RR_rotation(BTree T);
    BTree RL_rotation(BTree T);
    
    #endif /* fun_h */
    

    ————————————————————————main.c————————————————————————————

    //
    //  main.c
    //  AVL数
    //
    //  Created by 川十 on 2019/2/20.
    //  Copyright © 2019年 川十. All rights reserved.
    //
    
    #include "fun.h"
    
    int main(int argc, const char * argv[]) {
        BTree T;
        T=(BTree)malloc(sizeof(BNode));
        T=creatTree(T, 20);
    //    printf("%d\n",deepth(T));
    //    printf("%d\n",count(T,0));
    //    preTraversal(T);
    //    inTraversal(T);
        printf("\n");
        display(T);
        printf("\n");
        display2(T);
    }
    

    输出:

    在这里插入图片描述

    展开全文
  • 1.消除任何使用标准c语言类型的函数,如long long与_Complex,或消除标准c语言中新增的函数(C89或C99). 2.删除限定符const、restrict与volatile 3.删除数组声明符括号内使用的static. 4.将类型void * 换成char * ...
  • 标准C语言中使用bool类型

    千次阅读 2016-01-27 15:35:47
    标准C语言中并没有关于bool的定义, 不过bool可以自己定义的 #define bool int #define false 0 #define true 1 有这三个宏那么就可以了
  • 标准C语言实用全书,不喜欢超星的格式,所以自己从超星格式转换为的pdf版,跟大家分享一下
  • 今天,我们就来分享一下用标准C语言实现素数判定的三种方法: 首先,什么是素数?素数又称质数,正整数中只能被1和它自身所整除的整数。这其中的关键信息便是“正整数”和“只能被1 和它自身所整除”。 法一: ...
  • 标准C语言实用全书,强推哦,标准C语言实用全书,强推哦
  • 标准C语言程序设计(第五版)部分习题答案,英文名字:progamming in ansi c
  • GNU C 对标准C语言的扩展 为了方便使用,GNU C在标准C语言的基础上进行了部分方便开发的扩展。这里讲解一些开发中可能会用到的,或者使用频率比较高的内容。 1 零长度数组和变量长度数组 GNU C 允许使用零长度数组:...
  • 关于标准C语言的预定义宏

    千次阅读 2016-01-08 21:50:36
    标准C语言预处理要求定义某些对象宏,每个预定义宏的名称一两个下划线字符开头和结尾,这些预定义宏不能被取消定义(#undef)或由编程人员重新定义。下面预定义宏表,被我抄了下来。__LINE__ 当前程序行的行号,表示...
  • 标准C语言编译器

    千次阅读 2018-09-03 13:45:51
    C语言内嵌Intel汇编,使用ICC编译器,Windows第三方商业应用基本都是这样,占有90%以上的市场份额。免费版有一些限制。ICC的bug数量实际上与GCC难分伯仲。ICC编译出的文件在AMD处理器上跑的特别慢,主要是厂商之间的...
  • 2011年12月8日,ISO正式公布C语言新的国际标准草案:ISO/IEC 9899:2011,即C11 这是最新的C语言参考手册
  • 标准C语言中包括一组三字符组,使C语言程序可以只用ISO 646-1083不变代码集编写,这是七比特ASCII代码集的子集,是许多非英语国家字符集公用的代码集。三字符组以两个连续问号开头,见上图。标准C语言还提供一些...
  • 本书基于C语言的最新标准ISO/IEC 9899:2011,力求全面地介绍这门计算机语言的各个方面:词法元素、类型、声明、表达式、语句等,全书内容按概念和术语分类组织,示例丰富,查阅方便,适合具有一定C语言基础的各类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,442
精华内容 10,576
关键字:

标准c语言

c语言 订阅