精华内容
下载资源
问答
  • (1)编写函数实现计算字符串a中字符的个数(注:不能直接用系统函数) 函数原型:int strlength(char a[]); (2)编写函数实现将a字符串中的字母字符拷贝到字符串b中。 函数原型:void strcopyf(char a[],char b[])...

    对一个字符串进行下列操作:

    (1)编写函数实现计算字符串a中字符的个数(注:不能直接用系统函数)

    函数原型:int strlength(char a[]);

    (2)编写函数实现将a字符串中的字母字符拷贝到字符串b中。

    函数原型:void strcopyf(char a[],char b[]);

    (3) 编写函数实现将字符串中数字字符提取出来转换成十进制整数输出(注:转换后整数不超出整型范围,字符串中不包含负号)。

    函数原型:int strtoint(char a[]);

    如输入字符串"ab56cd87",则输出十进制整数5687。

    (4)编写主函数测试题目(1)-(3)函数,a字符串在主函数中输入,(1)-(3)函数结果在主函数中输出。

    展开全文
  • 公共接口除包含构造函数、拷贝构造函数、析构函数外,还包含以下成员函数:创建一个Set,增加一个新元素到Set,从Set中删除一个元素,显示Set中元素,计算Set中元素个等 。为Set类重载+(并集)、-(差集)、*...
  • CentOS rsync小结

    2016-05-16 17:58:00
    CentOS rsync小结 ...试想一下,如果有千万个文件或目录你怎么样制定拷贝计划呢?每一个选项都会占用系统计算时间,每一个选项错误,都会延迟拷贝计划任务进度,所以做拷贝计划前很有必了解rsync每个选项,...

    前言

     

    与cp,scp不同的是rsync工具不但可以本地拷贝,还可以远程拷贝以及同步数据。

    rsync工具在做数据备份方便非常受欢迎。试想一下,如果有数千万个文件或目录你怎么样制定拷贝计划呢?每一个选项都会占用系统计算时间,每一个选项错误,都会延迟拷贝计划任务进度,所以做拷贝计划前很有必了解rsync每个选项,做个详细测试。

    记得参与过的PICC一个项目就牵扯到元数据同步,用的就是这个,当时对这个工具不熟悉,拷贝也是别人做的,当时目录+文件量是以亿计算的,所以这次一定得摸清楚,搞通了,后面再碰到类似问题,就不用提前做那么多测试了。有备无患么,就是这个理

    儿。

    常用项小结

     

    #拷贝installxxx文件到/tmp的目录命名为aa

    rsync -av install.log.syslog /tmp/aa

     

    #拷贝本地主机文件800.png到远程主机172的/tmp/目录

    rsync -av 800.png 192.168.36.172:/tmp/

     

    #拷贝远程主机172中的数据到本地/mnt/目录

    rsync -av root@192.168.36.172:/tmp/800.png /mnt/

     

    #拷贝本地aa/到cc/注意需要加/斜杠,不加不行哦。

    rsync -a aa/ cc/

     

    #--no-l,去除软连接,如果源目录中含有软连接,不拷贝哟。

    rsync -av --no-l /root/bb/ /root/cc/

     

    #-L,把源文件软连接指向的物理文件拷贝到目标目录中。

    rsync -avL /root/bb/ /root/cc/

     

    #-u,如果目标目录中文件比源文件中新,不会执行同步。

    rsync -avu /root/aa/ /root/bb/

     

    #-delete,如果目标目录bb/中有源目录aa/中没有的东东,会执行清除目标目录bb/中已有的数据。

    rsync -av --delete /root/aa/ /root/bb/

     

    #--exclude,用于过滤掉源中不需要拷贝的文件

    #--progress,用于观察拷贝进程

    rsync -av --progress --exclude="*.txt" /root/aa/ /root/bb/

    扩展

     

    本文参考:阿铭Linux

    除了常用的拷贝文件cp,scp,rsync之类的工具,删除之类的rm工具,还有一些用户组权限类也需要注意。

    #useradd添加用户

    #groupadd添加组

    #passwd改用户密码

    #chown,更改属主属组。

    #chmod,更改目录文件权限。

    #chgrep,更改默认属主属组。

    #umask,更改默认文件目录权限。

    参考:http://blog.itpub.net/23655288/viewspace-734212/

     

    posted on 2016-05-16 17:58 8年扛枪梦 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/appresearch/p/5498980.html

    展开全文
  • 一、Java基础 集合类: 1、HashMap的put方法的具体流程? 答:判断空间是否足够-&...答:当kv达到扩容的阈值,以2倍扩容,将原表中的对象重新计算位置,并拷贝到新的表。 3、HashMap是怎么解决哈希冲突的? 答:...

    一、Java基础

    • 集合类:

    1、HashMap的put方法的具体流程?

    答:判断空间是否足够->不够则扩容->判断key是否存在->存在则插入链表->链表数如果超过8->转为红黑树。

    2、HashMap的扩容操作是怎么实现的?

    答:当kv达到扩容的阈值,以2倍扩容,将原表中的对象重新计算位置,并拷贝到新的表。

    3、HashMap是怎么解决哈希冲突的?

    答:1、使用链表;2、两次hash,jdk1.8中使用高16位参与hash;3、使用红黑树加速链表搜索;

    4、HashMap为什么数组长度要保证为2的幂次方呢?

    答:length-1的二进制是1111...形式,二进制与操作效率非常快,且不浪费空间,因为0位做与运算还是0,同时也增加了碰撞几率。

    5、为什么HashMap中String、Integer这样的包装类适合作为Key?

    答:1)都是final类型,不可变;2)内部已经重写了equals()和hashCode();

    6、ConcurrentHashMap和Hashtable的区别?

    答:HashMap没有考虑同步,HashTable考虑同步,ConcurrentHashMap锁相较HashTable更细粒度。

    7、ConcurrentHashMap的具体实现知道吗?

    答:结合了HashMap和HashTable的优点,jdk1.7中采用了分段锁,jdk1.8中使用了CAS。

    弃用分段锁原因:加入多个分段锁浪费内存空间;生产环境中, map 在放入时竞争同一个锁的概率非常小,分段锁反而会造成更新等操作的长时间等待;为了提高 GC 的效率。

    8、Java集合的快速失败机制 “fail-fast”?

    答:当多线程同时操作并修改了集合结构,这个时候程序就会抛出ConcurrentModificationException异常,并产生fast-fail。解决方法是:1)在修改的部分加锁;2、使用CopyOnWriteArrayList代替ArrayList,也就是写时复制,将添加的元素写入拷贝的数组,然后用现在的数组替换老的数组。

    9、Array 和 ArrayList 有什么区别?

    答:1)Array还可以包含基本类型;2)Array是固定大小;3)ArrayList提供了一些方便的操作。

    10、HashSet是如何保证数据不可重复的?

    答:底层使用HashMap,把数据作为K值,HashMap中K值相同会覆盖,而HashSet则直接返回false。

    11、BlockingQueue是什么?

    答:基于Reentrantlock,主要用于实现生产者/消费者模式,入队时如果队列满会阻塞或直接返回false,出队如果队列为空会阻塞或直接返回null。

    12、HashMap多线程不安全的原因?

    答:1)1.8以下会有成环风险(之前是头插,1.8改成尾插);2)会导致插入丢失;

    13、ConcurrentHashMap如何保证线程安全?

    答:锁住一个node,使用Unsafe类中提供的compareAndSwap比较当前内存中的变量值和你指定的一个变量值是否相等,否则等待并协助扩容。

    14、ArrayList和LinkedList有什么区别?

    答:ArrayList是基于动态数组的,查询速度快,因为可以通过数组对象的大小计算直接查找到对应的对象,但是在中间插入以及删除效率低,因为要移动数组;LinkedList插入、删除快,因为只需要修改指针的指向,但是查询慢,因为要逐个遍历向后查。

    15、有没有有顺序的Map实现类?

    答:TreeMap是基于Comparator来实现,LinkedHashmap是基于链表的插入有序。

    16、HashMap 排序题。

    答:

    public static HashMap<Integer, User> sortHashMap(HashMap<Integer, User> map) { 
        // 首先拿到 map 的键值对集合
        Set<Entry<Integer, User>> entrySet = map.entrySet();
        // 将 set 集合转为 List 集合,为什么,为了使用工具类的排序方法
        List<Entry<Integer, User>> list = new ArrayList<Entry<Integer, User>>(entrySet); 
        // 使用 Collections 集合工具类对 list 进行排序,排序规则使用匿名内部类来实现
        Collections.sort(list, new Comparator<Entry<Integer, User>>() {
            @Override
            public int compare(Entry<Integer, User> o1, Entry<Integer, User> o2) {
                //按照要求根据 User 的 age 的倒序进行排
                return o2.getValue().getAge()-o1.getValue().getAge();
            }
        });
        //创建一个新的有序的 HashMap 子类的集合
        LinkedHashMap<Integer, User> linkedHashMap = new LinkedHashMap<Integer, User>(); 
        //将 List 中的数据存储在 LinkedHashMap 中
        for(Entry<Integer, User> entry : list){
            linkedHashMap.put(entry.getKey(), entry.getValue());
        }
        //返回结果
        return linkedHashMap;
    }

    17、红黑树

    红黑树具有以下五个特性:
    1)每个节点或者是黑色,或者是红色
    2)根节点是黑色
    3)每个叶子结点(NIL,这里的叶子结点不是传统的叶子结点,是指为空的叶子结点)是黑色。
    4)如果一个结点是红色的,则它的子结点必须是黑色的
    5)从一个结点到该结点的子孙结点的所有路径上包含相同数目的黑结点。
    红黑树是相对接近平衡的二叉树。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例,这个在高度上的理论上限允许红黑树在最坏情况下都是高效的,而不同于普通的二叉查找树。

    18、B+树

    1)有k个子树的中间节点包含有k个元素(B树中是k-1个元素),每个元素不保存数据,只用来索引,所有数据都保存在叶子节点。

    2)所有的叶子结点中包含了全部元素的信息,及指向含这些元素记录的指针,且叶子结点本身依关键字的大小自小而大顺序链接。

    3)所有的中间节点元素都同时存在于子节点,在子节点元素中是最大(或最小)元素。

    • 其它

    1、类的实例化顺序?

    答:父类>子类,静态代码块>非静态代码块>构造函数。

    2、抽象类和接口的区别?

    答:1)抽象类可以有构造方法(jdk8接口也可以)、成员变量、静态方法;2)一个类可以实现多个接口,但只能继承一个抽象类;

    3、IO模型有哪些?

    答:BIO:同步阻塞,对每个请求指派线程阻塞至处理完成,如果是线程池会导致上下文切换开销,如果是新建则会耗尽服务器资源;NIO:同步非阻塞,将多个IO阻塞复用到一个select阻塞上,selector断轮询注册在其上的Channel,如果channel就绪写缓冲区,然后再将缓冲区的数据交给线程;AIO:异步非阻塞,注册读写回调方法,异步调用。

    4、反射的原理,反射创建类实例的三种方式是什么?

    答:通过.class文件获取包含的java类信息;forName会初始化Class,执行类中静态变量的初始化;loadClass不会,只有在创建实例时才会;getClass()会对类进行静态、非静态的初始化;Class.class不会初始化。

    反射机制的价值:1、解耦代码,无需在代码中耦合对象或类信息,可以通过运行时动态传入,进提高代码复用率;2、编译时压根无法得知对象和类信息的情况。例子:

    package cn.yonyong.reflection.testdemo;
    
    interface Fruit { //水果接口
      public void eat() ; //吃水果
    }
    
    class Apple implements Fruit{ //定义苹果
      public void eat() {
        System.out.println("**吃苹果。"); 
      } 
    }
    
    class Orange implements Fruit{
      public void eat() {
        System.out.println("**吃橘子。"); 
      }
    }
    
    class Factory{
      public static Fruit getInstance(String className){
        Fruit fruit = null ;
        try{
          fruit = (Fruit) Class.forName(className).newInstance() ;
        }catch(Exception e ){
          e.printStackTrace() ;
        }
        return fruit ;
      }
    }
    
    public class FactoryDemo{
      public static void main(String args[]){
      //通过工厂类取得接口实例,传入完整的包.类名称
        Fruit f = Factory.getInstance("cn.yonyong.reflection.testdemo.Apple") ;
        if(f!=null){ //判断是否取得接口实例
          f.eat() ;
        }
      }
    }

    5、描述动态代理的几种实现方式,分别说出相应的优缺点。

    答:动态代理的目的是将非业务逻辑在运行时动态织入代码中,保持解耦。JDK动态代理是基于反射的,生成高效,执行低效,cglib采用底层的字节码技术,为代理类创建了一个子类,生成低效,执行高效。

    6、三种单例模式实现 :

    为什么枚举单例在 Java 中更好,因为代码简单,Enum 实例的创建在默认情况下是线程安全的,

    // 懒汉式 缺点:必须加锁
    public class Singleton {
        private static Singleton singleton;
        private Singleton() {}
        public static synchronized Singleton getInstance() {
            if(singleton != null) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
    
    
    // 饿汉式 缺点:初始化就加载
    public class Singleton {
        private static final Singleton SINGLETON = new Singleton(){
        private Singleton() {}
        public static Singleton getInstance() {
            return SINGLETON;
        }
    }
    
    // 登记式
    public class Singleton {
        private Singleton() {}
        public static Singleton getInstance() {
            return Holder.SINGLETON;
        }
        private static class Holder {
            private static final Singleton SINGLETON = new Singleton();
        }
    }

    7、error和exception的区别,CheckedException,RuntimeException的区别。

    答:Error表示程序无法处理的(如内存资源不足等)的异常,Exception是指程序设计问题引起的异常。RuntimeException通常暗示程序上的错误,不需要做try/catch,需要修改源码;而CheckedException是程序设计者已经知道会受到某些异常,必须被处理。

    8、请列出5个运行时异常。

    答:空指针(NullPointerException)、数组访问越界(IndexOutOfBoundsException)、缓冲区溢出(BufferOverflowException)、强制类型转换异常(ClassCastException)、数组存储异常(ArrayStoreException)。

    9、在自己的代码中,如果创建一个java.lang.String对象,这个对象是否可以被类加载器加载?

    答:不可以,双亲委派模式会保证父类加载器先加载类,BootStrap加载器会先加载jdk中的java.lang.String类。

    10、泛型的存在是用来解决什么问题?

    答:泛型好处是在编译时可以检查类型安全,并且所有强制转换都是隐式、自动的,提高代码复用性。

    11、有没可能 2个不相等的对象有同hashcode。

    答:没有重载之前使用的是对象在jvm堆上的地址,不会重复,重载由于算法问题,会导致相同。

    12、什么是序列化,为什么要定义serialversionUID变量。

    答:序列化用来将对象内容流化;原则上序列化后的数据当中的serialVersionUID与当前类当中的serialVersionUID一致,那么该对象才能被反序列化成功,不指定serialVersionUID的后果是,当你添加或修改类中的任何字段时,则已序列化类将无法恢复。

    13、进程和线程间通信。

    答:线程间通信:1)共享变量;2)wait/notify机制;(java.lang.Object)3)lock/condition机制(java5以后替代2)4)管道。

    进程间通信:1)管道;2)命名管道;3)信号量;4)消息队列;5)共享内存(内存映射文件);6)socket。

    14、强引用、软引用、弱引用、虚引用。

    答:对象引用存放在栈中,对象存放在堆中。强引用:必须将对象置为null才会被回收;软引用:内存不够时才会被回收;弱引用:垃圾回收一旦发现就会回收;虚引用:任何时候都会被回收,必须和引用队列一起用,可以判断引用队列是否加入虚引用了解对象是否要被回收。

    15.是否可以在static环境中访问非static变量?

    答:当类被Java虚拟机载入的时候,会对static变量进行初始化。如果你的代码尝试不用实例来访问非static的变量,编译器会报错,因为这些变量还没有被创建出来,还没有跟任何实例关联上。

    16、Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思?

    答:Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对,方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方法名,参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。

    17、String和StringBuilder、StringBuffer的区别?

    答:其中String是只读字符串,也就意味着String引用的字符串内容是不能被改变的。StringBuilder是Java 5中引入的,它和StringBuffer的方法完全相同,区别在于它是在单线程环境下使用的,因为它的所有方面都没有被synchronized修饰,因此它的效率也比StringBuffer要高。

    18、Java 中的可序列化接口和可外部接口之间的区别是什么?

    答:Externalizable 给我们提供 writeExternal() 和 readExternal() 方法, 这让我们灵活地控制 Java 序列化机制, 而不是依赖于 Java 的默认序列化。

    19、可序列化的方法有多少?如果没有方法,那么可序列化接口的用途是什么?

    答:它没有任何方法, 在 Java 中也称为标记接口。当类实现 java.io.Serializable 接口时, 它将在 Java 中变得可序列化, 并指示编译器使用 Java 序列化机制序列化此对象。

    20、序列化时,你希望某些成员不要序列化?你如何实现它?

    答:申明瞬态变量,或者由于静态变量属于类, 而不是对象, 因此它们不是对象状态的一部分, 因此在 Java 序列化过程中不会保存它们。

    21、如果一个类是可序列化的,而他的超类没有,那么当进行反序列化的时候,那些从超类继承的实例变量的值是什么?

    答:Java中的序列化处理实例变量只会在所有实现了Serializable接口的继承支路上展开。所以当一个类进行反序列化处理的时候,超类没有实现Serializable接口,那么从超类继承的实例变量会通过为实现序列化接口的超类的构造函数进行初始化。

    22、是否可以自定义序列化过程, 或者是否可以覆盖 Java 中的默认序列化过程?

    答:可以,重写ObjectOutputStream.writeObject(saveThisObject),  ObjectInputStream.readObject()方法,并要声明这些方法为私有方法, 以避免被继承、重写或重载。

    23、为什么要为你的对象提供自定义序列化?

    答:超类已经序列化,子类不要实现序列化。

    24、你能用Java覆盖静态方法吗?如果我在子类中创建相同的方法是编译时错误?

    答:不能;不是,这称为隐藏在Java中的方法,静态方法应该使用类名而不是使用对象来调用, 因为静态方法不能在Java中重写。

    25、java中实现多态的机制。

    答:本质上多态分两种:编译时多态(又称静态多态),运行时多态(又称动态多态);重载(overload)就是编译时多态的一个例子。我们通常所说的多态指的都是运行时多态,也就是编译时不确定究竟调用哪个具体方法,一直延迟到运行时才能确定。这也是为什么有时候多态方法又被称为延迟方法的原因。通常有两种实现方法:子类继承父类(extends)、类实现接口(implements)。

    26、字节流和字符流的区别。

    答:字节流读取的时候,读到一个字节就返回一个字节; 字符流使用了字节流读到一个或多个字节(中文对应的字节 数是两个,在 UTF-8 码表中是 3 个字节)时,先去查指定的编码表,将查到的字符返回。

    27、B+树。

    答:1)根节点至少有两个子女;中间节点最多k-1个,k个孩子;叶子节点k-1个元素

    2)卫星数据都放在叶子节点节点,叶子节点都在同一层,之间通过指针相连;

    3)除了叶子节点,其他节点只放索引数据;

    4)父节点存放的是子节点的几个最大/小值;

    优势:1)单一节点存放更多数据,树层级低,IO次数少;

    2)所有查询都要查询叶子节点,查询更稳定;

    3)叶子节点为有序列表,便于范围查询。

    28、epoll和poll的区别。

    答:epoll的优点:1)没有最大并发连接的限制;2)只有活跃可用的FD才会调用callback函数;3) 内存拷贝,利用mmap()文件映射内存加速与内核空间的消息传递;即epoll使用mmap减少复制开销。poll没有后面两点。

    29、HTTP有哪些问题,加密算法有哪些,针对不同加密方式可能产生的问题,及其HTTPS是如何保证安全传输的?

    答:对称加密:秘钥以明文方式传给客户,有在传输中被截获的安全问题;非对称加密:非对称加密的风险是截取公钥并伪造公钥发给客户端,客户端用中间人的公钥加密把私钥传给中间人后,中间人自己解密获取私钥,再把秘钥传给服务器;数字证书:数字签名(服务器信息+公钥做hash和CA私钥加密)+服务器信息+公钥,客户端使用CA公钥解密数字签名与原始信息hash后比较是否一致,以此保证安全。

    30、字符串在 JVM 中如何存放?

    答:使用常量字符串初始化的字符串对象,它的值存放在字符串常量池中;使用字符串构造方法创建的字符串对象,它的值存放在堆内存中。

    展开全文
  • 二叉树的基本用法总结

    千次阅读 2016-09-11 11:08:35
    下面列举了二叉树的一些常用方法,水平有限 代码写的质量不怎么地,...计算树的深度、叶子数、节点; 树的拷贝; 判断两个树是否相等; 判断是否是满树、完全树; #include #include #include #include #include usi

    下面列举了二叉树的一些常用方法,水平有限 代码写的质量不怎么地,基本功能是实现了的

    功能有:树的建立、删除;

    先序、后序、中序、层次遍历;

    节点的查找,节点的插入;

    兄弟的查找,父节点的查找;

    计算树的深度、叶子数、节点数;

    树的拷贝;

    判断两个树是否相等;

    判断是否是满树、完全树;

    #include<iostream>
    #include<stack>
    #include<stdlib.h>
    #include<math.h>
    #include<deque>
    using namespace std;
    
    typedef struct BTreeNode
    {
      char data;
      struct BTreeNode * LeftChild;
      struct BTreeNode * RightChild;
    }node,*root;
    
    void CreateTree(root &root_node)//创建树 指针的引用 #代表空节点  先序输入  如ABD##E##CF##G##(中间不要有空格)
    {
    	char c='#';
    	c=getchar();
    	if (c=='#')
    	{
    		root_node=NULL;
    		return ;
    	}
       //否则
        root_node=(root)malloc(sizeof(node));
    	root_node->data=c;
    	CreateTree(root_node->LeftChild);
    	CreateTree(root_node->RightChild);
    	return ;
    
    }
    
    void PreOrder(root root_node)//先序输出
    {
      if (root_node==NULL)
      {
    	  return;
      }
      else
      {
    	  cout<<root_node->data;
    	  PreOrder(root_node->LeftChild);
    	  PreOrder(root_node->RightChild);
      }
    }
    
    void InOrder(root root_node)//中序
    {
    	if (root_node==NULL)
    	{
    		return;
    	}
    	else
    	{
    		InOrder(root_node->LeftChild);
    		cout<<root_node->data;
    		InOrder(root_node->RightChild);
    	}
    
    }
    
    void PostOrder(root root_node)//后序
    {
      if (root_node==NULL)
      {
    	  return;
      }
      else
      {
    	  PostOrder(root_node->LeftChild);
    	  PostOrder(root_node->RightChild);
    	  cout<<root_node->data;
      }
    }
    
    void LevelOrder(root root_node)//层次遍历
    {
    	deque<root>node_list;
    	if (root_node==NULL)
    	{
    		return;
    	}
    	else
    		node_list.insert(node_list.begin(),root_node);
    
    	while(node_list.size()!=0)
    	{
    		root node_temp=node_list[0];
    		node_list.pop_front();
    		cout<<node_temp->data;
    
    		if (node_temp->LeftChild!=NULL)
    		{
    			node_list.push_back(node_temp->LeftChild);
    		}
    		if (node_temp->RightChild!=NULL)
    		{
    			node_list.push_back(node_temp->RightChild);
    		}
    
    	}
    	
    
    }
    
    bool IsEmpty(root root_node) //判空
    {
    	return ((root_node==NULL)?true:false);
    }
    
    void DestoryTree(root &root_node)//删除以root_node为根的树
    {
      if (root_node==NULL)
      {
    	  return;
      }
      else
      {
    	  DestoryTree(root_node->LeftChild);
    	  DestoryTree(root_node->RightChild);
    	  free(root_node);
    	  root_node=NULL;
      }
    }
    
    root GetParent(root root_node,root p)//找p的双亲  root_node为树根节点
    {
    	root root_q;
    	if (root_node==NULL || p==NULL)
    	{
    		root_q=NULL;
    		return root_q;
    	}
    
      if (root_node->LeftChild==p || root_node->RightChild==p)
      {
    	  return root_node;
      }
      else
      {
        root_q=GetParent(root_node->LeftChild,p);
    	if (root_q!=NULL)
    	{
    		return root_q;
    	}
    
    	root_q=GetParent(root_node->RightChild,p);
    	return root_q;
      }
    }
    
    root GetPoint(root root_node,char c)//在树root_node中找到节点值为c的节点 返回其指针
    {
    	root q;
       if(root_node==NULL)
    	   return NULL;
       if(root_node->data==c)
    	   return root_node;
       else
       {
    	   q=GetPoint(root_node->LeftChild,c);
    	   if(q!=NULL)
    		   return q;
    
    	   q=GetPoint(root_node->RightChild,c);
    		   return q;
       }
    }
    
    root GetLeftBrother(root root_node,root p)//找p的左侧兄弟
    {
    
    	if (root_node==NULL || p==NULL)
    	{
    		return NULL;
    	}
    	root pr_node=GetParent(root_node,p);
    	if (pr_node==NULL || p==pr_node->LeftChild)
    	{
    		return NULL;
    	}
    	else 
    	{
    		return pr_node->LeftChild;
    	}
    
    }
    
    root GetRightBrother(root root_node,root p)//找p的右侧兄弟
    {
    	if (root_node==NULL || p==NULL)
    	{
    		return NULL;
    	}
    	root pr_node=GetParent(root_node,p);
    	if (NULL==pr_node || p==pr_node->RightChild)
    	{
    		return NULL;
    	}
    	else
    		return pr_node->RightChild;
    
    }
    
    int GetDepth(root root_node)//计算树的深度  
    {
    	int n_left;
    	int n_right;
      if (root_node==NULL)
      {
    	  return 0;
      }
      else
      {
    	  n_left=GetDepth(root_node->LeftChild);
    	  n_right=GetDepth(root_node->RightChild);
    	  return (n_left>n_right?n_left:n_right)+1;
    
      }
    }
    
    int GetLeaves(root root_node)//计算叶子数
    {
    	int leaves;
    	int L_leaves;
    	int R_leaves;
    	if(root_node==NULL)
    		return 0;
    	if (root_node->LeftChild ==NULL && root_node->RightChild==NULL)
    	{
           return 1;
    	}
    	else
    	{
    		L_leaves=GetLeaves(root_node->LeftChild);
    		R_leaves=GetLeaves(root_node->RightChild);
    		leaves=L_leaves+R_leaves;
    		return leaves;
    	}
    }
    
    void CopyTree(root root_node1,root &root_node2)//拷贝树 root_node1拷贝到root_node2
    {
    	root newnode;
    	if (root_node1==NULL)
    	{
    		root_node2=NULL;
    		return;
    	}
    	root_node2=(root)malloc(sizeof(node));
    	root_node2->data=root_node1->data;
    	CopyTree(root_node1->LeftChild,root_node2->LeftChild);
    	CopyTree(root_node1->RightChild,root_node2->RightChild);
       
    }
    
    void InsertLeftChild(root &node_p,char c)//为节点node_p插入一个左儿子 值为c,node_p原来的的左儿子作为新节点的左儿子
    {
    	if (node_p==NULL)
    	{
    		return;
    	}
    
    	root left_child=node_p->LeftChild;
       root newnode=(root)malloc(sizeof(node));
       node_p->LeftChild=newnode;
       newnode->LeftChild=left_child;
       newnode->data=c;
       newnode->RightChild=NULL;
    }
    void InsertRightChild(root &node_p,char c)//为节点node_p插入一个右儿子 值为c,node_p原来的的右儿子作为新节点的右儿子
    {
    	if (node_p==NULL)
    	{
    		return;
    	}
    
    	root right_child=node_p->RightChild;
    	root newnode=(root)malloc(sizeof(node));
    	node_p->RightChild=newnode;
    	newnode->RightChild=right_child;
    	newnode->data=c;
    	newnode->LeftChild=NULL;
    }
    
    bool IsTreeEqual(root root_node1,root root_node2)//判断两个树是否相等
    {
       if (root_node1==NULL && root_node2==NULL)
       {
    	   return true;
       }
       if (root_node1==NULL && root_node2!=NULL)
       {
    	   return false;
       }
       if (root_node1!=NULL && root_node2==NULL)
       {
    	   return false;
       }
    
       if (root_node1->data==root_node2->data && IsTreeEqual(root_node1->LeftChild,root_node2->LeftChild)==true && IsTreeEqual(root_node1->RightChild,root_node2->RightChild)==true)
       {
    	   return true;
       }
       else 
    	   return false;
    
    }
    
    int GetNodeCount(root root_node)//计算树的节点数
    {
    	int L_count,R_count,ALL_count;
    	if (root_node==NULL)
    	{
    		return 0;
    	}
    	else
    	{
    		L_count=GetNodeCount(root_node->LeftChild);
    		R_count=GetNodeCount(root_node->RightChild);
            ALL_count=L_count+R_count+1;
    		return ALL_count;
    	}
    
    }
    
    bool IsCompleteTree(root root_node)//是否是完全树
    {
    	deque<root>node_list;
    	if (root_node==NULL)
    	{
    		return false;
    	}
    	else
    		node_list.insert(node_list.begin(),root_node);
    
    	int i=0;
    	root temp;
    	while(i<node_list.size())//所有节点全部进入队列  包括空节点
    	{
    		temp=node_list[i];
    		if (temp!=NULL)
    		{
    			node_list.push_back(temp->LeftChild);
    			node_list.push_back(temp->RightChild);
    		}
    		i++;
    	}
    
    	i=0;
    	while (i<node_list.size())//查找空节点后面是否会有非空节点  若有则说明不是完全树
    	{
    		if (node_list[i]==NULL)
    		{
    			int j=i;
    			while (j<node_list.size())//查找空节点后面是否会有非空节点
    			{
    				if (node_list[j]!=NULL)
    				{
    					return false;
    				}
    				j++;
    			}
    			return true;
    		}
    		else
    		{
    			i++;
    			continue;
    		}
    	}
       return false;
    } 
    
    
    
    bool IsFullTree(root root_node)//是否是满树
    {
       int count=GetNodeCount(root_node);//节点数
       int depth=GetDepth(root_node);//深度
       double a=2.0;
       int num=(int)(pow(a,double(depth)))-1;
       if (num==count)//节点数是否等于2^k-1
       {
    	   return true;
       }
       else
    	   return false;
    
    }
    
    
    void EatLine()//消除回车
    {
      while(getchar()!='\n')
    	{
    	}
    }
    
    
    void main()//用来测试
    {
        char c;
    	char d;
    	root root_node;
    	root root_node2=NULL;
    
    	CreateTree(root_node);
    	EatLine();
    
    	bool empty;
    	empty=IsEmpty(root_node);
    	if (empty==true)
    	{
    		cout<<"the tree is empty\n";
    	}
    	else
    		cout<<"the tree is not empty\n";
    
    	int depth=GetDepth(root_node);
    	cout<<"the depth of tree is "<<depth<<endl;
    
    	int leaves=GetLeaves(root_node);
    	cout<<"the COUNT of leaves is "<<leaves<<endl;
    
    	bool comlete=IsCompleteTree(root_node);
    	if (comlete==true)
    	{
    		cout<<"the tree is comlete\n";
    	}
    	else
    		cout<<"the tree is not comlete\n";
    
    	bool full=IsFullTree(root_node);
    	if (full==true)
    	{
    		cout<<"the tree is full\n";
    	}
    	else
    		cout<<"the tree is not full\n";
    
    	
    
    	cout<<"pre:\n";
    	PreOrder(root_node);
    	cout<<endl;
    	cout<<"In:\n";
    	InOrder(root_node);
    	cout<<endl;
    	cout<<"post:\n";
    	PostOrder(root_node);
    	cout<<endl;
    	cout<<"level:\n";
    	LevelOrder(root_node);
    	cout<<"\n"<<endl;
    
    	CopyTree(root_node,root_node2);
    	cout<<"copy tree in pre:\n";
    	PreOrder(root_node2);
    	cout<<endl;
    	cout<<"copy tree in In:\n";
    	InOrder(root_node2);
    	cout<<endl;
    	cout<<"copy tree in post:\n";
    	PostOrder(root_node2);
    	cout<<endl;
    	cout<<"copy tree in level:\n";
    	LevelOrder(root_node);
    	cout<<"\n"<<endl;
    
    	if(IsTreeEqual(root_node,root_node2)==true)
    	{
    		cout<<"the two tree is equal\n";
    	}
    	else
    		cout<<"the two tree is not equal\n";
    
    
    
    	cout<<"input the node and char wanted insert in tree root_node2(end of #)\n";//插入左儿子
    	while (1)
    	{
    		cout<<"input node :";//在哪个节点插入
    		c=getchar();
    		EatLine();
    
    		if(c=='#')
    			break;
    		cout<<"input char wangted insert :";//插入什么值
    		d=getchar();
    		EatLine();
    
    		if(d=='#')
    			break;
    
    		root temp=GetPoint(root_node2,c);
    		InsertLeftChild(temp,d);
    		cout<<"InsertLeftChild "<<d<<" behead of "<<c<<" in pre:\n";
    		PreOrder(root_node2);
    		cout<<"\n"<<endl;
    
    		int depth=GetDepth(root_node2);
    		cout<<"the depth of tree is "<<depth<<endl;
    
    		int leaves=GetLeaves(root_node2);
    		cout<<"the COUNT of leaves is "<<leaves<<endl;
    
    		if(IsTreeEqual(root_node,root_node2)==true)
    		{
    			cout<<"the two tree is equal\n";
    		}
    		else
    			cout<<"the two tree is not equal\n";
    
    
    		comlete=IsCompleteTree(root_node2);
    		if (comlete==true)
    		{
    			cout<<"the tree is comlete\n";
    		}
    		else
    			cout<<"the tree is not comlete\n";
     
    	}
    
    	cout<<"\n"<<endl;
    
    
    
    	cout<<"input the char wanted delete in tree root_node2(end of #)\n";//删除子树
    	while (1)
    	{
    		cout<<"input char wangted delete :";
    		d=getchar();
    		EatLine();
    
    		if(d=='#')
    			break;
    
    		root P_delete=GetPoint(root_node2,d);//找到要删除的节点的指针
    		root temp=P_delete;//备份这个指针
    		root p=GetParent(root_node2,P_delete);//找到此点的父节点
    		DestoryTree(P_delete);//删掉这个节点子树
    		if (p->LeftChild==temp)//在树中把这个节点指针赋值为空
    		{
    			p->LeftChild=NULL;
    		}
    		else
    			p->RightChild=NULL;
    
    		cout<<"after DestoryTree "<<d<<" in pre:\n";
    		PreOrder(root_node2);
    		cout<<"\n";
    
    		depth=GetDepth(root_node2);
    		cout<<"the depth of tree is "<<depth<<endl;
    
    		leaves=GetLeaves(root_node2);
    		cout<<"the COUNT of leaves is "<<leaves<<endl;
    
    		if(IsTreeEqual(root_node,root_node2)==true)
    		{
    			cout<<"the two tree is equal\n";
    		}
    		else
    			cout<<"the two tree is not equal\n"<<endl;
    
    		comlete=IsCompleteTree(root_node2);
    		if (comlete==true)
    		{
    			cout<<"the tree is comlete\n";
    		}
    		else
    			cout<<"the tree is not comlete\n";
    
    		bool full=IsFullTree(root_node2);
    		if (full==true)
    		{
    			cout<<"the tree is full\n";
    		}
    		else
    			cout<<"the tree is not full\n";
    	}
            
    
    
    	cout<<"input the char wanted find in tree root_node(end of #)\n";//查找节点
    	while((c=getchar())!='#')
    	{
    	 EatLine();
         root q_find=GetPoint(root_node,c);
    	 root parent=GetParent(root_node,q_find);
    	 if(parent!=NULL)
    		cout<<"parent of "<<c<<" is:"<<parent->data<<endl;
    	 else
    		cout<<"can't find parent"<<endl;
    	 
    	 root left_brother=GetLeftBrother(root_node,q_find);
    	 if (left_brother!=NULL)
    	 {
    		 cout<<"left brother of "<<c<<" is:"<<left_brother->data<<endl;
    	 }
    	 else
             cout<<"can't find left brother"<<endl;
    
    	 root right_brother=GetRightBrother(root_node,q_find);
    	 if (right_brother!=NULL)
    	 {
    		 cout<<"right brother of "<<c<<" is:"<<right_brother->data<<endl;
    	 }
    	 else
    		 cout<<"can't find right brother"<<endl;
    
    	}
    	
    
    	
    
    	system("pause");
    }


    展开全文
  • 数据传输过程中需要将浮点数拆分成多个整型或者其他类型的来进行传输,例如某控制器通过Modbus通信协议进行数据传输,但其寄存器只支持让你压short型的数据,你要在不损失精度的情况下,用2个short型数据去表示1个...
  • 4.3.0 深拷贝和浅拷贝区别。 4.3.1 数组和链表数据结构描述,各自的时间复杂度。 4.3.2 error和exception的区别,CheckedException,RuntimeException的区别。 4.3.3 请列出5个运行时异常。 4.3.4 在自己的代码...
  • 扩展用时根据网络速度不同而不同,最快仅需秒,最慢需要分钟,烦请耐心等待。 问题4:我从某些网站下载的就是增强版,为什么弹出更新c++对话框时显示c++ 2015 Redistributable Package的条目是灰色的并且不能...
  • RamDisk Plus7.0 带注册机 注册码

    热门讨论 2010-08-10 13:16:52
    因此,你可以从中拷贝、移动以及删除文件。与物理磁盘非常相似的是, 这个RAM磁盘可以被格式化,压缩以及共享,这样它可以被网络上的其它计算机访问。与RamDisk的不同之处在于, RamDisk Plus加入了当服务器关机时...
  • c++深拷贝与浅拷贝 拷贝构造函数和委托构造函数 c++面向对象 右值引用,move语义,完美转发 emplace_back和push_back区别 Eigen库了解嘛 如何实现一个c++的单例模式 内联函数和宏的区别 如何实现一个只在堆...
  • FAQ(持续更新)

    2021-01-08 12:27:51
    也无论计算线程多少,这两个队列将近倾向于同时执行完毕。这个规律可以扩展到任意队列数量以及任意启动顺序。 为什么使用redis client时无需先建立连接 首先看一下redis client任务的创建接口: ~~~...
  • Java语言中忽视的细节

    2011-09-04 11:24:00
    这看起来是绝对不可能的,一个数怎么可能不等于它自己呢?或许就真的是Java语言疯了,不信看下面的代码输出什么?  double i=0.0/0.0;  if(i==i){  System.out.println("Yes i==i");  }else{  System.out....
  • jsp编程技巧集锦

    2008-03-19 17:23:17
    JSP编程技巧集锦 <br>需要者请联系:e_mail:fzlotuscn@yahoo.com.cn QQ:595563946<br><br>目 录 <br>1. JSP编程中常用的js技术 2....文本拷贝 139.字符串转日期 140.计算今天距月底还有几天
  • 通过http包,只需要行代码,即可实现一个爬虫或者一个Web服务器,这在传统语言中是无法想象的。 2. 常用第三方包 包 地址 数据库操作 github.com/jinzhu/gorm github.com/go-xorm/xorm ...
  • 深入学习shell脚本艺术

    热门讨论 2011-02-22 04:01:01
    lore(这句不知道怎么译).你可以把本书作为教材,自学手册,或者你获得shell脚本技术的文档. 书中的练习和例子脚本中的注释将会与读者有更好的互动,但是最关键的前提是: 想真正学习脚本编程的唯一途径就是编写脚本. 这...
  • 而其他类型如int作为参数时,由于函数参数值实质上是实参的一份拷贝,被调函内部对形参的改变并不影响实参的值。 22、数据结构和算法: A:查找: (1)二分法查找; B:写出下列算法的时间复杂度和实现排序: (1)...
  • c++ 面试题 总结

    2009-09-16 08:44:40
    ==strcpy拷贝的结束标志是查找字符串中的\0 因此如果字符串中没有遇到\0的话 会一直复制,直到遇到\0,上面的123都因此产生越界的情况 建议使用 strncpy 和 memcpy ---------------------------------------------...
  • 面试题147 如何计算二叉树的结点 13.5 图 面试题148 图的实现方式有哪几种 面试题149 如何进行图的搜索?搜索算法有哪几种方式 13.6 排序 面试题150 什么是冒泡排序 面试题151 鸡尾酒排序(改进的冒泡排序) 面试...
  • 4. JavaScript 数据结构与算法之美 - 栈内存与堆内存 、浅拷贝与深拷贝 5. JavaScript 数据结构与算法之美 - 递归 6. JavaScript 数据结构与算法之美 - 非线性表(树、堆) 7. JavaScript 数据结构与算法之美 - 冒泡...
  • 在深度学习中指的是计算一次cost需要的输入数据个。 self.experience = namedtuple("Experience", field_names=["state", "action", "reward", "next_state", &...
  • - setTime 设置时间对象的毫秒,会改变日期 - getFullYear 获取时间对象的年(2015) - getMonth 获取时间对象的月(需要加1) - getDay 获取日期的星期几(0-6)星期...
  • C语言编程要点

    2017-09-18 00:10:37
    6.1. 串拷贝(strcpy)和内存拷贝(memcpy)有什么不同?它们适合于在哪种情况下使用? 93 6.2. 怎样删去字符串尾部的空格?。 94 6.3. 怎样删去字符串头部的空格? 95 6.4. 怎样使字符串右对齐? 97 6.5. 怎样将字符串打印成...
  • 面试题23:计算学生不及格的人数打印他们的性别、姓名和成绩 面试题24:结构体内存对齐问题 3.6 C和C++的区别 面试题25:关键字static在C和C++中的区别 面试题26:C语言的结构体和C++的有什么区别 面试题27:C中的...
  • 10.6 16位和32位的是怎样存储的? 第11章 调试 11.1 如果我运行的程序挂起了,应该怎么办? 11.2 如何检测内存漏洞(leak)? 11.3 调试程序的最好方法是什么? 11.4 怎样调试TSR程序? 11.5 怎样获得...
  • C++程序员面试宝典

    热门讨论 2013-04-01 13:36:19
    面试题118 C++支持参数个不确定的函数吗 130 面试题119 什么是内联函数 131 11.2 函数参数的传递 132 面试题120 引用形参和非引用形参有什么区别 132 面试题121 使用引用形参有什么问题 133 面试题122 指针形参与...
  • LINUX 20招

    2008-04-25 19:30:56
    1.计算文件和目录 下面的语句可以帮你计算有多少个文件和多少个目录 # ls -l * |grep "^-"|wc -l ---- to count files # ls -l * |grep "^d"|wc -l ----- to count dir 还可以将以上的语句变成...

空空如也

空空如也

1 2 3 4 5 6
收藏数 112
精华内容 44
关键字:

拷贝数怎么计算