scmuzi18的博客

C/C++中的关键字C/C++中的关键字如下： 注：上表中为C++98/03中的63个关键字，其中红色标注为C语言中的32个关键字。C++11中有73个关键字，新增加的10个为：alignas、alignof、char16_t、char32_t、constexpr、decltype、noexpect、nullptr、static_assert、thread_loca

满二叉树：如下图除叶子节点外每个结点都达到饱和(左右孩子都存在) 完全二叉树：与满二叉树的前N个结点的结构相同的二叉树。 当找到第一个不饱和结点时，有如下情况： 1、该不饱和结点的左右孩子都存在，此时肯定是完全二叉树 2、该不饱和结点只有左孩子，也是完全二叉树 3、该不饱和结点只有右孩子，不是完全二叉树 4、该不饱和结点无孩子 bool IsCompleteTree()

基本思想： 1、选取矩阵右上角的数字； 2、如果选取得数字等于要查找的数字，查找结束； 3、如果选取的数字大于要查找的数字，所在的列col–； 4、如果选取的数字小于要查找的数字，所在的行row++。bool Find(int *arr, int rows, int cols, int n){ bool flag = false; if (arr!=NULL&&ro

//求二叉树镜像 void Binary_mirror() { _Binary_mirror(_root); } void _Binary_mirror(Node<T>* root) { if (root) { std::swap(root->_left,root->_right);

判断一个节点是否在一棵二叉树中 //给一个数找是否在二叉树中，找到返回所在节点 Node<T>* find(const T& data) { return _find(_root, data); } //判断一个节点是否在一棵二叉树中 bool IsNodeintree(const Node<T>* node) {

题目：替换字符串中的空格为$$$。要求时间复杂度为O(N) 例如：将”talk is cheap show me the code”替换。 基本思想： 栗子：we are family 参考代码：void ReplaceBlank(char string[], int length){ //length为字符串的总容量 if (string == NULL || leng

栈的特性：先进后出 队列的特性：先进先出 两个栈实现一个队列 实现过程如图： 参考代码：template<class T>class Cqueue{public: Cqueue() {} ~Cqueue() {} void add(const T &node); T delete1();private: stack<T> s1

C#中，被关键字sealed修饰的类不可被继承。 Java中，被关键字final修饰的类不可被继承。C++中，子类会自动调用父类的构造函数，也会自动调用父类的析构函数，为了让此类不被继承，可以将该类的构造函数和析构函数设置为私有的。如下：设计一个类不能被继承//设计一个类不能被继承class A{private: A() { cout << "A()" <<

题目：不用标志位，最多只能用两个指针，如何判断一个单链表是否带环？ 分析：定义两个指针slow和fast，slow每次递增一步，fast每次递增两步，如果两者相遇（相等），代表该链表带环，否则没环。 具体实现： .h#define _CRT_SECURE_NO_WARNINGS#include<iostream>#include<stdio.h>#include<stdlib.h>us

题目：复制一个复杂链表。复杂链表就是在链表中的每个结点除了有一个 _next指针指向下一个结点外，还有一个_sbiling指针指向NULL或链表中的任意一个结点。 复杂链表的复制分为以下三步。 1、根据原始链表的每个结点N创建对应的结点N’，并把N’链接在N后面。 void CloneNode(Node* head){ Node* node = head; while (n

//C++中的继承与多态//C++中的多态可以通过虚函数来实现class A{public: //基类函数为虚函数，必须加关键字virtul virtual void fun() { cout << "A:fun()" << endl; } int a;};class B :public A{public: //子类里的v

解法一：int num(int *arr, int n){ if(arr==NULL||n<=0) return 0; //找数组中最大的元素max int max=arr[0]; for(int i=1;i<n;i++) { if(arr[i]>=max) max=arr[i]; } //重新定义一个大小为max+1的数组ar

1、该二叉树为二叉搜索树。 二叉搜索树：如果左子树存在，其结点都比父结点小，如果右子树存在，其结点都比父结点大。故从根结点开始与两个输入结点比较： 如果当前结点大于这两个结点时，那么这两个结点的最近公共祖先一定在当前结点的左子树中； 如果当前结点小于这两个结点时，那么这两个结点的最近公共祖先一定在当前结点的右子树中。参考代码：Node<T>* _GetlastcommonNode(Node<T

void Rebuild(T pre[], size_t presize, T in[], size_t insize) { size_t idx = 0; _Rebuild(_root,pre,idx,presize,in,insize,0,insize); }void _Rebuild(Node<T>*& root, T pre[], size_t

归并排序 基本思想 一、递归//归并void merge(int *arr,int * tmp,int left,int mid,int right){ int begin1=left; int end1=mid; int begin2=mid+1; int end2=right; int idx=left; while(begin1<=end1&&begin2<

选择排序void select_sort(int *arr,int size){ int tmp=0; for(int i=0;i<size-1;i++) { for(int j=i+1;j<size;j++) { if(arr[j]<arr[i]) { tmp=arr[j]; arr[j]=arr

插入排序： void insert_sort(int *arr,int len){ for(int i=1;i<len;i++) { int tmp=arr[i]; int j=i-1; while(j>=0&&tmp<arr[j]) { arr[j+1]=arr[j]; j--; } arr[j+1]=tmp;

冒泡排序void Bubblesort(int *arr, int len){ for (int i = 0; i < len - 1; i++) { for (int j = 0; j < len - 1 - i; j++) { int temp = 0; if (arr[j]>arr[j + 1])

题目：输入两个递增有序的链表，合并这两个链表后，使新链表中的结点 也是递增有序的。//递归方式实现两个有序链表的合并struct ListNode{ int _value; ListNode* _next; ListNode(int value) :_value(value) {}};ListNode* merge(ListNode* phea

题目：求1+2+…+n的和，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）//1、递归int add(int n, int &sum){//n为0的时候即退出 n && add(n - 1, sum); return (sum += n);}void test1(){ int sum = 0;

模拟实现memcpy#include #include #include #include void* my_memcpy(void* dest, const void* src,size_t count){ void *ret = dest; assert(dest); assert(src); while(count) {  *(char

#include#includevoid Select_sort(int m[],int size){int i;int k;int t;int j;for(i=0;i{k=i;for(j=i+1;j{if(m[j]k=j;}if(k!=i){t=m[i];m[i]=m[k];m[k]=t;}}}int

关于C++中的构造函数、拷贝构造函数、析构函数以及赋值运算符重载的总结

多态：向不同的对象发送同一个消息，不同的对象在接收时产生不同的行为(方法)。在C++中，就是：不同功能的函数可以用同一函数名，这样就可以实现用一个函数名调用不同内容的函数。例：学校校长通知：9.1日开学。不同的对象会做出不同的反应：教师需备好课；学生需按时到校上课；家长需备好学费 。由于事先对各种人的任务已做了规定，因此，在得到同一个消息时，各种人都知道怎么做。这就是多

类中成员函数被重载的特征： 1、相同的作用域（同一个类中）； 2、函数名字相同； 3、参数不同； 4、virtual关键字可有可无。 覆盖是指派生类函数覆盖基类函数，特征是： 1、不同的作用域（基类和派生类）； 2、函数名字相同； 3、参数相同； 4、基类函数必须有virtual关键字。 隐藏指派生类函数屏蔽了与其同名的基类函数，特征是： 1、如果派生类的函数与基类的函数同名，

C系统的函数库中提供了了程序动态申请和释放内存存储块的库函数，下面将分别介绍。        1、malloc   函数             a、该函数的原型：void *malloc(size_t size);             b、该函数只有一个参数，且形参size是无符号整型，该参数代表申请空间的字节数。             c、返回值：如果内存池中的可用内

函数调用时，调用者依次把参数压栈，然后调用函数，函数被调用以后，在栈中取得数据，并进行计算。函数计算结束以后，或者调用者，或者函数本身修改堆栈，使堆栈恢复原装。       由于计算机不知道怎么给函数传递参数（一个函数调用需要多少个、什么样的参数，也没有硬件可以保存这些参数），为此引入栈的概念，以支持参数传递。       栈是一种先进后出的数据结构，栈有一个存储区、一个栈顶指针。栈顶指针

关于C++中的This指针   在每一个成员函数中都包含一个特殊的指针，这个指针的名字是固定的，称为This。   它是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。   例：成员函数volume的定义是 int Box::volume() {

#include#include#includeint my_strlen1(const char *str){   int count=0;   assert(str!=NULL);   while(*str++)   {  count++;   }   return count;}int my_strlen2(const char *str)

指针：指针指向一块内存，它的内容是所指内存的地址。 引用：引用是某块内存的别名。 指针与引用的区别如下： 1、引用必须初始化，指针可以不用初始化。 编译报错如图: 2、在sizeof中含义不同，引用表示引用类型的大小，指针始终是地址所占的字节数。int main(){ int c1 = 10; int &c2 = c1; int *p = &c1; /*

构造函数的作用：创建并初始化对象，即为对象成员变量赋初始值。 特点： 1、构造函数名与类名相同。 2、构造函数没有返回值。 3、构造函数不可以被直接调用。 4、定义了类没有定义构造函数时C++会提供默认构造函数，默认构造函数是无参构造函数，仅负责创建对象。 5、一个类可以有多个构造函数。 6、构造函数不可以是虚函数。原因：虚函数通过基类指针或引用来调用派生类的成员，调用前对象必须存在，

#define _CRT_SECURE_NO_WARNINGS#include<stdio.h>#include<stdlib.h>#include<iostream>using namespace std;const int MINNUM = -32767;int find(int array[],int size){ if (size < 0 || size == 0)

静态多态 静态多态就是在系统编译期间就可以确定程序执行到这里将要执行哪个函数。对于相关的对象类型，直接实现它们各自的定义，不需要共有基类，甚至可以没有任何关系，必须存在必需的同名成员函数。 优点：1、由于静多态是在编译期完成的，因此效率较高，编译器也可以进行优化； 2、静态多态通过模板编程为C++带来了泛型设计的概念，比如强大的STL库。缺点：由于是模板来实现静态多态，因此模板的不足也就是静多

#define _CRT_SECURE_NO_WARNINGS#include<iostream>#include<stdio.h>#include<stdlib.h>#include<assert.h>using namespace std;const int Max = 10;struct SeqListNode{ int data[Max]; size_t _s

C++继承中你不知道的事一、继承（inheritance）是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在原有类特性的基础上进行扩展，增加功能。例：  二、继承定义格式： 三、继承关系和访问限定符3种继承关系：public(公有继承)、protected(保护继承)、pr

以下代码运行环境为64位系统下的VS2013 C++中的异常情况： 语法错误（编译错误）：比如变量未定义、括号不匹配、关键字拼写错误等等编译器在编译时能发现的错误，这类错误可以及时被编译器发现，而且可以及时知道出错的位置及原因，方便改正。 运行时错误：比如数组下标越界、系统内存不足等等。这类错误不易被程序员发现，它能通过编译且能进入运行，但运行时会出错，导致程序崩溃。 为了有效

以下代码运行环境为64位平台下的VS2013 结构体的大小： 例：typedef struct fun{ int a; char b; double c; short d;};int main(){ int ret = sizeof(Fun); cout << "ret= " << ret <<"\n"<< endl; system

final: 修饰符（关键字）。 1、 如果一个类被声明为final，意味着它不能在派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为abstract（抽象的）又被声明为final。 2、将变量或方法声明为final，可以保证它们在使用过程中不会被改变。 3、 被声明为final的变量必须在声明时给定初值，而在以后的引用

首先，判断这两个链表各自是否带环。故存在下面三种情况： 1、两个链表都没带环，此时两个链表可能相交。 2、一个带环，一个不带环，则不可能相交。 3、两个都带环，判断第一个链表fast与slow相遇的结点是否在第二个链表的环中，如果在，则相交（相交时，环是两个链表公有的）两个链表都没环，解法如下：//判断两个无环单链表是否相交，如果两个无环但链表相交，则两个链表的最后一个结点一定相等。bool