C语言

 

 

关于算法 

转载自：

https://blog.csdn.net/qq_32353771/article/details/54585798

https://blog.csdn.net/wangiijing/article/details/51485119  

 

/***********************************************************二级指针****************************************************************/

 

//二级指针学习


#include <stdio.h>//输入输出头文件。
#include <stdlib.h>//本程序需要用到malloc/free函数，引用该头文件。
int main()
{
    int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12}; //定义二维数组a，并赋值从1-12.
    int ** p = NULL;//定义二维指针。
    int i, j;
     
    p = (int **)malloc(sizeof(int *) *3);//要访问的数组有三行，所以申请三个一维指针变量。
    for(i = 0; i < 3; i ++)
    {
        p[i] = a[i];//将二维数组行地址赋值到对应的一维指针上。
    }
     
    for(i = 0; i < 3; i ++)
    {
        for(j = 0; j < 4; j ++)
            printf("%d ", p[i][j]); //用指针输出元素。p[i][j]这里也可以写作*(*(p+i) + j)。
        printf("\n"); //每行输出后加一个换行
    }
     
    free(p);//释放申请的内存。
     
    return 0;
}
/************************************************************指针函数****************************************************************/
//指针函数学习
//指针函数 本质是函数 ，返回一个地址
//类型说明符 *（函数名）（参数）
//-->float *fun();
//float *p;
//p = fun(a);


#include<iostream>
using namespace std;


int *add(int a,int b)
{
int c = a+b;
return &c;
}
int *sub(int a,int b)
{
int c = a-b;
return &c;
}
int main()
{
char *s = "ad sf";
int a =3,b =2;
int *p = add(a,b);
int *p1 = sub(a,b);
char *p2 = ss(s);
cout<<"add:"<<*p<<endl;
cout<<"sub:"<<*p1<<endl;
return 0;
}
/*********************************************************函数指针*******************************************************************/


//函数指针学习
//函数指针 指向函数的指针变量  本质是一个指针变量
//类型说明符 （*函数名）（参数）  
//-->int (*f) (int x); 声明一个函数指针
//f=func;  将func函数的首地址赋给指针f 


/*
直接定义函数指针作为返回参数
int (*fuc2(int))(int,int);//显示定义 
总结：fuc2是一个函数，形参为(int),返回一个指向int(int,int)的函数指针。
*/


#include<iostream>


using namespace std;


typedef int (*Fun)(int ,int);
Fun fun;//此时 ，为指向某种类型函数的函数指针类型，而不是具体指针 ，用它可以定义具体指针
int add(),sun();


int add(int a,int b)
{
return a+b;
}
 
 int sub(int a,int b)
{
return a-b;
}
int fun1(int (*f)(int,int),int a,int b)//函数指针做形参
{
int ret = add(a,b);
return ret;
}
int main()
{
int a =4, b =4;
int ret = fun1(fun,a,b);
cout<<ret<<endl;




fun = add;
int c = (*fun)(2,3);
cout<<"add:"<<c<<endl;


fun = sub;
int c1 = (*fun)(3,2);
cout<<"sub:"<<c1<<endl;
return 0;
}
 
include<stdio.h>
int max(int a,int b)
{
return a>b?a:b;
}
int min(int a,int b)
{
return a<b?a:b;
}

int fun(int (*p)(int,int),int a,int b)//p=max  a=6 b=8    1.函数调用时定义  2.实参传递给形参时赋值  3.函数体中调用
{
int ret = (*p)(a,b);
return ret;
}
int main()
{
int ret;
ret = fun(max,6,8);
printf("ret:%d\n",ret);

ret = fun(min,6,8);
printf("ret:%d\n",ret);
}
/***************************************************函数指针数组*********************************************************************/
#include<stdio.h>


void add(int a,int b)
{
printf("result:%d\n",a+b);
}
void sub(int a,int b)
{
printf("result:%d\n",a-b);
}
void mul(int a,int b)
{
printf("result:%d\n",a*b);
}
void my_div(int a,int b)
{
if(b==0)
{
puts("cant't be zero");
}
else
{
printf("result:%d\n",a/b);
}
}


int main()
{
int a,b,choose;
void (*p[4])(int,int)={add,sub,mul,my_div};

int i;
for(;;)
{
puts("please input your choose:1 add 2 sub  3 mul 4 div");
scanf("%d",&choose);
puts("input two oprator:");
scanf("%d%d",&a,&b);
p[choose-1](a,b);
}
}
/***************************************************函数指针做形参*********************************************************************/


#include<stdio.h>


void add(int a,int b)
{
printf("result:%d\n",a+b);
}
void sub(int a,int b)
{
printf("result:%d\n",a-b);
}
void mul(int a,int b)
{
printf("result:%d\n",a*b);
}
void my_div(int a,int b)
{
if(b==0)
{
puts("cant't be zero");
}
else
{
printf("result:%d\n",a/b);
}
}


void fun(void (*pf)(int,int),int a,int b)
{
(*pf)(a,b);
}

int main()
{

void (*pf)(int,int)=NULL;
char choose;
int a,b;
puts("input your choose: 1.+ 2.- 3.* 4./ ");
scanf("%c",&choose);

puts("please input two integer:");
scanf("%d%d",&a,&b);
switch(choose)
{
case '+':
fun(add,a,b);
break;
case '-':
fun(sub,a,b);
break;
case '*':
fun(mul,a,b);
break;
case '/':
fun(my_div,a,b);
break;

default:
puts("choose error");
break;

}
return 0; 


}
/***************************************************C++函数重载和重写*********************************************************************/
#include<iostream>
using namespace std;


class Base {
private:
virtual void display() 
{ 
cout<<"父类 display()"<<endl; 
}
void say()
{
cout<<"父类 say()"<<endl;
}
public:
void exec()
{
display();
say(); 
}
void f1(string a) 
{ 
cout<<"父类 f1(string)"<<endl;
}
//overload，两个f1函数在Base类的内部被重载
void f1(int a,string aa) 
{
cout<<"父类 重载 f1(int,string)"<<endl; 
} 
};


class DeriveA:public Base{
public:
//override，基类中display为虚函数，故此处为重写  被重写的必须是virtual类型的
void display() 
{ 
cout<<"子类重写父类 display()"<<endl; 
}
//redefining，f1函数在Base类中不为虚函数，故此处为重定义
void f1(int a,int b) 
{ 
cout<<"子类重定义父类  f1(int,int)"<<endl;
}
//redefining，同上
void say()
{ 
cout<<"子类重定义父类 say()"<<endl;
} 
};




int main()
{
int x;
int y;
string aa;
DeriveA a;
Base *b = &a;
b->f1(aa);
b->exec(); //display():version of DeriveA call(polymorphism) //say():version of Base called(allways )
//b里边的函数display被A类覆盖，但是say还是自己的。
a.exec(); //same result as last statement   
a.say();

}
/***************************************************冒泡排序*********************************************************************/
原理：假设n个数据排序   每次两个数进行比较 从数组的前两个元素开始   如果前边的数>后边的数 就交换 
      第一趟会求出一个最大值  并且放到最后边(从小到大)
  然后以此类推  经过n-1趟 就排好了


#include<stdio.h>
int main()
{
int i=0,j=0,tmp=0;   
int a[8]={90,78,95,65,82,97,61,68};


for(i=0;i<7;i++)//排了7趟
{
for(j=0;j<7-i;j++)
{
if(a[j]>a[j+1])
{
tmp  = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
}
}
}


for(i=0;i<8;i++)
{
printf("%d  ",a[i]);
}


}
/***************************************************斐波那契数列*********************************************************************/


输出Fibonacci数列的前20项 先正序输出 然后逆序输出结果 


  1 1 2  3   5  8  13  21 34  55 。。。 


  #include<stdio.h>
int main()
{
int a[20]={1,1};
int i;
for(i=2;i<20;i++)
{
a[i] = a[i-1]+a[i-2];
}

for(i=0;i<20;i++)
{
printf("%d ",a[i]);
}
putchar('\n');

for(i=19;i>=0;i--)
{
printf("%d ",a[i]);
}
}

/***************************************************素数（质数）*********************************************************************/
输出100-199中的全部素数 
素数：除了1和自己 不能被其他任何数整除的数 
数据%比他小的任意一个数!=0  --》素数
#include<stdio.h>
int main()
{
int i,j;

for(i=100;i<=199;i++)
{
//处理;//
for(j=2;j<i;j++)//j==i 说明是素数
{
if(i%j==0)
{
break;//说明此时的i不是素数
}
}
if(i==j)
{
printf("%d  ",i);
}
}

}
/***************************************************杨辉三角*********************************************************************/
输出杨辉三角型 输出10阶就可以 


1 0 0 0 0 0 0  
1 1 0 0 0 0 0 
1 2 1 0 0 0 0 
1 3 3 1 0 0 0 
1 4 6 4 1 0 0
1 5 10 10 5 1 0


#include<stdio.h>


int  main()
{
int a[10][10] = {{1},{1},{1},{1},{1},{1},{1},{1},{1},{1}};


int i,j;
for(i=1;i<10;i++)
{
for(j=1;j<10;j++)
{
a[i][j] = a[i-1][j]+a[i-1][j-1];
}
}


for(i=0;i<10;i++)
{
for(j=0;j<10;j++)
{
if(j<=i)
{
printf("%3d ",a[i][j]);
}
}
putchar('\n');
}
}
/***************************************************鞍点*********************************************************************/
判断数组中是否存在鞍点 （在该行最大 在该列最小）


1  2   6   4 
    5  6   7   8
    9  10  11  12


    6就是鞍点


#include<stdio.h>


int  main()
{
int a[3][4]={{1,2,6,4},{5,6,7,8},{9,10,11,12}};
int max = 0,min;
int i,j,k,line;
for(i=0;i<3;i++)
{

for(j=0;j<4;j++)
{
//找到行的最大值并用line记录其列的下标
if(max<a[i][j])
{
max = a[i][j];
line = j;//line 最大值所在的列
}
}

min = a[0][line];
for(k=1;k<3;k++)
{
//找列数为line的最小值
if(a[k][line]<min)
{
min = a[k][line];

}
}

if(max==min)
{
printf("鞍点:%d %d\n",i,line);
}
max = 0;
}
}
/***************************************************随机数*********************************************************************/
中国福彩35选7 
  随机生成1-35内不重复的7个数字 然后让用户自己输入一组号码 
中奖规则：
猜中：
7个500万 
6个100万
5个1万
4个5000 
3个500 
0,1,2 没中奖

6 3 1 8 4 9 12 
1 3 13 8 4 7 9

#include<stdio.h>


int main()
{
int num[7]={0};//保存随机数
int a[7]={0};
int count=0,i,j;
srand(time(0));


for(i=0;i<7;i++)// 生成7个随机数
{
num[i] = rand()%35+1;//产生随机数
for(j=0;j<i;j++)//保证随机数不重复
{
if(num[i]==num[j])//如果新产生的数与之前的重复 就在这个位置上重新出一个数
{
i--;
break;
}
}
}

puts("please input 7 numbers:");
for(i=0;i<7;i++)
{
scanf("%d",&a[i]);
}



for(i=0;i<7;i++)//用户输入
{
for(j=0;j<7;j++)//随机数
{
if(num[j]==a[i])
{
count++;
break;
}
}
}


switch(count)
{
case 7:
puts("五百万!!");
break;
case 6:
puts("一百万!!");
break;
case 5:
puts("一万!!");
break;
case 4:
puts("五千!!");
break;
case 3:
puts("五百!!");
break;
default:
puts("come on!");
break;
}

}


/************************************************线程读者与写者问题****************************************************************/


//读者与写者问题
#include <stdio.h>
#include <process.h>
#include <windows.h>
//设置控制台输出颜色
BOOL SetConsoleColor(WORD wAttributes)
{
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
if (hConsole == INVALID_HANDLE_VALUE)
return FALSE;

return SetConsoleTextAttribute(hConsole, wAttributes);
}
const int READER_NUM = 5;  //读者个数
//关键段和事件
CRITICAL_SECTION g_cs, g_cs_writer_count;
HANDLE g_hEventWriter, g_hEventNoReader;
int g_nReaderCount;
//读者线程输出函数(变参函数的实现)
void ReaderPrintf(char *pszFormat, ...)
{
va_list   pArgList;

va_start(pArgList, pszFormat);
EnterCriticalSection(&g_cs);
vfprintf(stdout, pszFormat, pArgList);
LeaveCriticalSection(&g_cs);
va_end(pArgList);
}
//读者线程函数
unsigned int __stdcall ReaderThreadFun(PVOID pM)
{
ReaderPrintf("     编号为%d的读者进入等待中...\n", GetCurrentThreadId());
//等待写者完成
WaitForSingleObject(g_hEventWriter, INFINITE);
 
//读者个数增加
EnterCriticalSection(&g_cs_writer_count);
g_nReaderCount++;
if (g_nReaderCount == 1)
ResetEvent(g_hEventNoReader);
LeaveCriticalSection(&g_cs_writer_count);
 
//读取文件
ReaderPrintf("编号为%d的读者开始读取文件...\n", GetCurrentThreadId());
 
Sleep(rand() % 100);
 
//结束阅读,读者个数减小,空位增加
ReaderPrintf(" 编号为%d的读者结束读取文件\n", GetCurrentThreadId());
 
//读者个数减少
EnterCriticalSection(&g_cs_writer_count);
g_nReaderCount--;
if (g_nReaderCount == 0)
SetEvent(g_hEventNoReader);
LeaveCriticalSection(&g_cs_writer_count);
 
return 0;
}
//写者线程输出函数
void WriterPrintf(char *pszStr)
{
EnterCriticalSection(&g_cs);
SetConsoleColor(FOREGROUND_GREEN);
printf("     %s\n", pszStr);
SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
LeaveCriticalSection(&g_cs);
}
//写者线程函数
unsigned int __stdcall WriterThreadFun(PVOID pM)
{
WriterPrintf("写者线程进入等待中...");
//等待读文件的读者为零
WaitForSingleObject(g_hEventNoReader, INFINITE);
//标记写者正在写文件
ResetEvent(g_hEventWriter);

//写文件
WriterPrintf("  写者开始写文件.....");
Sleep(rand() % 100);
WriterPrintf("  写者结束写文件");
 
//标记写者结束写文件
SetEvent(g_hEventWriter);
return 0;
}
int main()
{
printf("  读者写者问题\n");
printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");
 
//初始化事件和信号量
InitializeCriticalSection(&g_cs);
InitializeCriticalSection(&g_cs_writer_count);
 
//手动置位,初始已触发
g_hEventWriter = CreateEvent(NULL, TRUE, TRUE, NULL);
g_hEventNoReader  = CreateEvent(NULL, FALSE, TRUE, NULL);
g_nReaderCount = 0;
 
int i;
HANDLE hThread[READER_NUM + 1];
//先启动二个读者线程
for (i = 1; i <= 2; i++)
hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);
//启动写者线程
hThread[0] = (HANDLE)_beginthreadex(NULL, 0, WriterThreadFun, NULL, 0, NULL);
Sleep(50);
//最后启动其它读者结程
for ( ; i <= READER_NUM; i++)
hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);
WaitForMultipleObjects(READER_NUM + 1, hThread, TRUE, INFINITE);
for (i = 0; i < READER_NUM + 1; i++)
CloseHandle(hThread[i]);
 
//销毁事件和信号量
CloseHandle(g_hEventWriter);
CloseHandle(g_hEventNoReader);
DeleteCriticalSection(&g_cs);
DeleteCriticalSection(&g_cs_writer_count);
return 0;
}




/**************************************************获取物理屏幕大小******************************************************************/


#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <windows.h>
int main()
{
printf("    获取屏幕大小 物理大小\n");        
printf(" -- By MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");   

int nScreenWidth, nScreenHeight;
HDC hdcScreen = GetDC(NULL);   //获取屏幕的HDC
nScreenWidth = GetDeviceCaps(hdcScreen, HORZSIZE);
nScreenHeight = GetDeviceCaps(hdcScreen, VERTSIZE);

printf("屏幕大小（毫米） 宽：%d 高：%d\n", nScreenWidth, nScreenHeight);
printf("    下面将屏幕大小由毫米换算到英寸\n");
const double MILLIMETRE_TO_INCH = 0.03937;
double aa = nScreenHeight * nScreenHeight + nScreenWidth * nScreenWidth;
double fDiagonalLen = sqrt(aa);

printf("屏幕对角线长为：%.2lf毫米 约 %.2lf英寸\n", fDiagonalLen, fDiagonalLen * MILLIMETRE_TO_INCH);
getch();
return 0;
}


/*************************************************线程回调***********************************************************************/


//回调函数
#include <iostream>
#include <thread>
#include <mutex>
 
using namespace std;
 
mutex mtx;
 
class Test {
private:
    int a;
    int b;
public:
    Test(int a, int b) : a(a), b(b) {}
 
    void fun1() {
        lock_guard<mutex> lck(mtx);
        cout << a + b << endl;
    }
     
    void fun2() {
        lock_guard<mutex> lck(mtx);
        cout << a - b << endl;
    }
};
 
int main() {
    Test test(10, 3);
 
    auto f1 = bind(&Test::fun1, test);
    auto f2 = bind(&Test::fun2, test);
 
    thread t1(f1);
    thread t2(f2);
thread t;
    t1.join();
    t2.join();
 
    return 0;
}


/***************************************************字符串数字互转*********************************************************************/




//数组方法 atoi()
#include<stdio.h>
#include<string.h>
int main()
{
int i;
char str[]="123";
int b=0;//保存每位数 
int c=0;//十进制数
for(i=0;i<strlen(str);i++)
{
b = str[i]-'0';
c = c*10+b;//1*10+2   12*10+3  
 
}
printf("result:%d\n",c);
}


Function：为四舍五入的输出格式，对数字与字符串之间的相互转换的操作和输出数据
#include<stdio.h>
#include<iostream>
#include<time.h>
using namespace std;
typedef long long LL;




string 去除末尾零(string val1)
{  
const char *p=val1.data();
int ii=val1.length();
for (int i = val1.length()-1; i > 0; i--)
{  
if (p[i]!=48)
{  
ii=i;
goto LN1; 
}
 }
LN1:;  
return val1.replace(ii+1,val1.length(),"");
 }




string NumToString(double num,int pre)//数字转字符串，使用sprintf(char数组名，类型，数字变量名) 
{  
char str1[10]={0};
char str2[10]={0};
sprintf(str1,"%%.%dlf",pre); //将精度设为可变参数
sprintf(str2,str1,num);
//去除末尾零(str2);
return str2;     //返回最后（字符串）结果




//char str[10]="";
//sprintf(str,"%.0lf",num);
//return str;
}


double StringToNum(char *str1,int pre)//字符串转数字，使用sscanf()函数
{
double num;
//sscanf(str1,"%lf",&num);//double 形式输出
sscanf(str1,"%le",&num);//科学计数法形式输出
NumToString(num,pre);
//round(num,2);
return num;
}
int main()
{
clock_t start,finish;
double totaltime;
    start=clock();


//NumToString(123.9999999);
//StringToNum("12.1432E-2");


int pre = 0;  //pre为可变精度  为变量



StringToNum("12E8",pre); // 参数1 为要处理的数据 参数2 为输出精度

cout<<"Done!"<<endl;
finish=clock();
    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
    cout<<"\n此程序的运行时间为"<<totaltime<<"秒！"<<endl;
}


/*****************************************************递归1-100和*******************************************************************/


#include<stdio.h>


int get_sum(int num)
{
int result;
if(num==1)
{
return 1;
}
result = get_sum(num-1) + num;
return result;
}
int main()
{
printf("%d\n",get_sum(100));
return 0;
}
 

/*****************************************************strcmp*******************************************************************/
#include<stdio.h>


int fun(char *p,char *q)
{

while((*p&&*q)&&(*p==*q))
{
p++;
q++;
}
if(*p>*q)
{
return 1;
}
if(*p<*q)
{
return -1;
}
else
{
return 0;
}
}
int main()
{
int ret;
char str1[] = "acde";
char str2[] = "abce";
ret = fun(str1,str2);
printf("%d\n",ret);
return 0;
}
/*****************************************************strcpy*******************************************************************/
#include<stdio.h>
void fun(char *p,char *q)
{
while(*q)
{
*p = *q;
p++;
q++;
}
*p='\0';
}
int main()
{
char str1[100] = "hello";
char str2[]="world";
fun(str1,str2);
printf("%s\n",str1);
return 0;
}
/*****************************************************strcat*******************************************************************/
include<stdio.h>


void fun(char *p,char *q)
{
int i=0,j=0;
while(p[i]!='\0')
{
i++;
}
for(j = 0;q[j]!='\0';j++)
{
p[i] = q[j];
i++;
}
p[i]='\0';
}


int main()
{
char str1[] = "hello";
char str2[] = "world";
fun(str1,str2);
printf("%s\n",str1);
return 0;
}
/*****************************************************strlen*******************************************************************/
#include<stdio.h>


int fun(char *str)
{
int i = 0;
while(str[i]!='\0')
{
i++;
}
return i;
}
int main()
{
int len = 0;
char str[100]={'\0'};
puts("please input a string:");
scanf("%s",str);
len = fun(str);
printf("%d\n",len);
return 0;
}
/****************************************************水仙花数*******************************************************************/
#include<stdio.h>


int main()
{
int n;
int g,s,b;
for(n=100;n<1000;n++)
{
b = n/100;
s = n/10%10;
g = n %10;
if(n==g*g*g+s*s*s+b*b*b)
{
printf("%d ",n);
}
}
printf("\n");
return 0;
}
/******************************************************各种算法排序效率对比******************************************************************/
https://blog.csdn.net/qq_32353771/article/details/54585798
https://blog.csdn.net/wangiijing/article/details/51485119  
/********************************************************二叉树遍历****************************************************************/
#include<stdio.h>


typedef struct node_t
{
char data;//数据域
struct node_t *lchild;//指向左子节点的指针
struct node_t *rchild;//指向右子节点的指针
}tree_node_t;


//先序遍历  根 左 右
void first_order(tree_node_t *r)
{
if(r != NULL)
{
printf("%c ",r->data);
first_order(r->lchild);
first_order(r->rchild);
}
}
//中序遍历 左 根 右
void middle_order(tree_node_t *r)
{
if(r != NULL)
{
middle_order(r->lchild);
printf("%c ",r->data);
middle_order(r->rchild);
}
}
//后序遍历 左 右 根
void last_order(tree_node_t *r)
{
if(r != NULL)
{
last_order(r->lchild);
last_order(r->rchild);
printf("%c ",r->data);
}
}
int main()
{
tree_node_t A = {'A',NULL,NULL};
tree_node_t B = {'B',NULL,NULL};
tree_node_t C = {'C',NULL,NULL};
tree_node_t D = {'D',NULL,NULL};
tree_node_t E = {'E',NULL,NULL};
tree_node_t F = {'F',NULL,NULL};


A.lchild = &B;
A.rchild = &C;
B.lchild = &D;
B.rchild = &E;
C.lchild = &F;

first_order(&A);
printf("\n");
middle_order(&A);
printf("\n");
last_order(&A);
printf("\n");


return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef struct _TREE_NODE
{
int data;
struct _TREE_NODE* parent;
struct _TREE_NODE* left_child;
struct _TREE_NODE* right_child;
}TREE_NODE;
/*
根据上面的数据结构，
我们看到每一个数据节点都有三个指针，
分别是：指向父母的指针，
指向左孩子的指针，
指向右孩子的指针。
每一个节点都是通过指针相互连接的。
相连指针的关系都是父子关系。
那么排序二叉树又是什么意思呢？
其实很简单，只要在二叉树的基本定义上增加两个基本条件就可以了：
（1）所有左子树的节点数值都小于此节点的数值；
（2）所有右节点的数值都大于此节点的数值。
*/
//1.创建二叉树节点
TREE_NODE* create_tree_node(int data)
{
TREE_NODE* pTreeNode = NULL;
pTreeNode = (TREE_NODE*)malloc(sizeof(TREE_NODE));
assert(NULL != pTreeNode);
memset(pTreeNode,0,sizeof(TREE_NODE));
pTreeNode->data = data;
return pTreeNode;
}
/*
分析：我们看到，二叉树节点的创建和我们看到的链表节点、堆栈节点创建没有什么本质的区别。
首先需要为节点创建内存，然后对内存进行初始化处理。
最后将输入参数data输入到tree_node当中即可。
*/
//2.数据的查找
TREE_NODE* find_data_in_tree_node(const TREE_NODE* pTreeNode,int data)
{
if(NULL == pTreeNode)
{
return NULL;
}
if(data == pTreeNode->data)
return (TREE_NODE*)pTreeNode;
else if(data < pTreeNode->data)
return find_data_in_tree_node(pTreeNode->left_child,data);
else
return find_data_in_tree_node(pTreeNode->right_child,data);
}
/*
分析：我们的查找是按照递归迭代进行的。
因为整个二叉树是一个排序二叉树，
所以我们的数据只需要和每一个节点依次比较就可以了，
如果数值比节点数据小，那么向左继续遍历；
反之向右继续遍历。
如果遍历下去遇到了NULL指针，只能说明当前的数据在二叉树中还不存在。
*/
//3.数据统计
int count_node_number_in_tree(const TREE_NODE* pTreeNode)
{
if(NULL == pTreeNode)
return 0;
return 1+count_node_number_in_tree(pTreeNode->left_child)
+ count_node_number_in_tree(pTreeNode->right_child);
}
/*
分析：和上面查找数据一样，统计的工作也比较简单。
如果是节点指针，那么直接返回0即可，
否则就需要分别统计左节点树的节点个数、右节点树的节点个数，
这样所有的节点总数加起来就可以了。
*/
//4.按照从小到大的顺序打印节点的数据
void print_all_node_data(const TREE_NODE* pTreeNode)
{
if(pTreeNode)
{
print_all_node_data(pTreeNode->left_child);
printf("%d\n",pTreeNode->right_child);
print_all_node_data(pTreeNode->right_child);
}
}
/*
分析：因为二叉树本身的特殊性，
按顺序打印二叉树的函数本身也比较简单。
首先打印左子树的节点，
然后打印本节点的数值，
最后打印右子树节点的数值，
这样所有节点的数值就都可以打印出来了。
*/
//5.统计树的高度
int calculate_height_of_tree(const TREE_NODE* pTreeNode)
{
int left,right;
if(NULL == pTreeNode)
return 0;
left = calculate_height_of_tree(pTreeNode->left_child);
right = calculate_height_of_tree(pTreeNode->right_child);
return (left > right) ? (left + 1) : (right + 1);
}
/*
分析：树的高度其实是指所有叶子节点中，
从根节点到叶子节点的最大高度可以达到多少
。当然，程序中表示得已经很明白了，
如果节点为空，那么很遗憾，节点的高度为0；
反之如果左子树的高度大于右子树的高度，
那么整个二叉树的节点高度就是左子树的高度加上1；
如果右子树的高度大于左子树的高度
，那么整个二叉树的高度就是右子树的高度加上1。
计算树的高度在我们设计平衡二叉树的时候非常有用，
特别是测试的时候
*/
int main()
{

}


/************************************************************************************************************************/
/************************************************************************************************************************/
/************************************************************************************************************************/
/************************************************************************************************************************/
/************************************************************************************************************************/
/************************************************************************************************************************/