世界知名素描美术作品:c++举几个比较难的例子

还有好几个~但是太大了，这里放不下.....

# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <time.h>
# include <windows.h>
# include <winbase.h>

# define MAXSIZE 1024*5
# define TRUE 1
# define FALSE 0

typedef int BOOL;

typedef struct StudentData
{
int num; /* 关键字 */
}Data;

typedef struct LinkList
{
int Length;
Data Record[MAXSIZE];
}LinkList;

int RandArray[MAXSIZE];

//开始界面
void banner()
{
printf("*********************\n");
printf(" 排序算法演示 V1.0\n");
printf(" 由 何晓杰 制作\n");
printf(" 请按回车键进入\n");
printf("*********************");
getchar();
system("cls.exe");//调用清屏EXE文件
}

//生成随机数序列
void RandomNum()
{
int i;
srand((int)time( NULL ));
for(i=0; i<MAXSIZE; i++)
RandArray[i]=(int)rand();
return;
}

//初始化链表

void InitLinkList(LinkList* L)
{
int i;
memset(L,0,sizeof(LinkList));
RandomNum();
for(i=0; i<MAXSIZE; i++)
L->Record[i].num=RandArray[i];
L->Length=i;
}

bool LT(int i, int j,int* CmpNum)
{
(*CmpNum)++;
if (i<j) return TRUE;
return FALSE;
}

void Display(LinkList* L)
{
FILE* f;
int i;
if((f=fopen("SortRes.txt","w"))==NULL)
{
printf("can't open file\n");
exit(0);
}
for (i=0; i<L->Length; i++)
fprintf(f,"%d\n",L->Record[i].num);
fclose(f);
}

//西尔排序
void ShellInsert(LinkList* L,int dk, int* CmpNum, int* ChgNum)
{
int i, j;
Data Temp;
for(i=dk; i<L->Length;i++)
{
if( LT(L->Record[i].num, L->Record[i-dk].num, CmpNum) )
{
memcpy(&Temp,&L->Record[i],sizeof(Data));
for(j=i-dk; j>=0 && LT(Temp.num, L->Record[j].num, CmpNum) ; j-=dk)
{
(*ChgNum)++;
memcpy(&L->Record[j+dk],&L->Record[j],sizeof(Data));
}
memcpy(&L->Record[j+dk],&Temp,sizeof(Data));
}
}
}

void ShellSort(LinkList* L, int dlta[], int t,int* CmpNum, int* ChgNum)
{
int k;
for (k=0; k<t; k++)
ShellInsert(L,dlta[k],CmpNum,ChgNum);
}

//快速排序
int Partition (LinkList* L, int low, int high, int* CmpNum, int* ChgNum)
{
Data Temp;
int PivotKey;
memcpy(&Temp,&L->Record[low],sizeof(Data));
PivotKey=L->Record[low].num;
while (low < high)
{
while (low<high && L->Record[high].num >= PivotKey)
{
high--;
(*CmpNum)++;
}
(*ChgNum)++;
memcpy(&L->Record[low],&L->Record[high],sizeof(Data));
while (low<high && L->Record[low].num <= PivotKey)
{
low++;
(*CmpNum)++;
}
(*ChgNum)++;
memcpy(&L->Record[high],&L->Record[low],sizeof(Data));
}
memcpy(&L->Record[low],&Temp,sizeof(Data));
return low;
}

void QSort (LinkList* L, int low, int high, int* CmpNum, int* ChgNum)
{
int PivotLoc=0;
if (low < high)
{
PivotLoc=Partition(L,low,high,CmpNum,ChgNum);
QSort(L,low,PivotLoc-1,CmpNum,ChgNum);
QSort(L,PivotLoc+1,high,CmpNum,ChgNum);
}
}

void QuickSort (LinkList* L, int* CmpNum, int* ChgNum)
{
QSort(L,0,L->Length-1,CmpNum,ChgNum);
}

//堆排序
void HeapAdjust (LinkList* L,int s, int m, int* CmpNum, int* ChgNum)
{
Data Temp;
int j=0;
s++;
memcpy(&Temp,&L->Record[s-1],sizeof(Data));
for (j=2*s; j<=m ; j*=2)
{
if(j<m && LT(L->Record[j-1].num,L->Record[j].num,CmpNum)) ++j;
if(!LT(Temp.num,L->Record[j-1].num,CmpNum)) break;
(*ChgNum)++;
memcpy(&L->Record[s-1],&L->Record[j-1],sizeof(Data));
s=j;
}
memcpy(&L->Record[s-1],&Temp,sizeof(Data));
}

void HeapSort (LinkList* L, int* CmpNum, int* ChgNum)
{
int i=0;
Data Temp;
for (i=L->Length/2-1; i>=0; i--)
HeapAdjust(L,i,L->Length,CmpNum,ChgNum);
for (i=L->Length; i>1; i--)
{
memcpy(&Temp,&L->Record[0],sizeof(Data));
(*ChgNum)++;
memcpy(&L->Record[0],&L->Record[i-1],sizeof(Data));
memcpy(&L->Record[i-1],&Temp,sizeof(Data));
HeapAdjust(L,0,i-1,CmpNum,ChgNum);
}
}

//冒泡排序
void BubbleSort(LinkList* L, int* CmpNum, int* ChgNum)
{
int i,j;
Data temp;
for (i=0; i<MAXSIZE-1;i++)
{
for(j=0; j<MAXSIZE-i-1;j++)
{
if(!LT(L->Record[j].num,L->Record[j+1].num,CmpNum))
{
(*ChgNum)++;
memcpy(&temp,&L->Record[j],sizeof(Data));
memcpy(&L->Record[j],&L->Record[j+1],sizeof(Data));
memcpy(&L->Record[j+1],&temp,sizeof(Data));
}
}
}
}

//选择排序
int SelectMinKey(LinkList* L,int k,int* CmpNum)
{
int Min=k;
for ( ; k<L->Length; k++)
{
if(!LT(L->Record[Min].num,L->Record[k].num,CmpNum))
Min=k;
}
return Min;
}

void SelSort(LinkList* L, int* CmpNum, int* ChgNum)
{
int i, j;
Data temp;
for(i=0; i<L->Length; i++)
{
j=SelectMinKey(L,i,CmpNum);
if(i!=j)
{
(*ChgNum)++;
memcpy(&temp,&L->Record[i],sizeof(Data));
memcpy(&L->Record[i],&L->Record[j],sizeof(Data));
memcpy(&L->Record[j],&temp,sizeof(Data));
}
}
}

void SelectSort()
{
printf("0. 插入排序\n");
printf("1. 西尔排序\n");
printf("2. 快速排序\n");
printf("3. 堆排序\n");
printf("4. 冒泡排序\n");
printf("5. 选择排序\n");
printf("6. 以上所有排序方式\n");
printf("7. 退出程序\n\n");
printf("请选择操作序号:");
}

void AllAbove(LinkList* L,int* CmpNum, int* ChgNum)
{
int TempTime,i;
int SpendTime;
int dlta[3]={7,3,1};
int Indata[1]={1};

TempTime=(int)GetTickCount();
ShellSort(L,Indata,1,&CmpNum[0],&ChgNum[0]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n插入排序:");
printf("\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[0],ChgNum[0],SpendTime);

for(i=0; i<MAXSIZE; i++)
L->Record[i].num=RandArray[i]; //随机数列复位
TempTime=(int)GetTickCount();
ShellSort(L, dlta, 3,&CmpNum[1],&ChgNum[1]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n西尔排序:");
printf("\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[1],ChgNum[1],SpendTime);

for(i=0; i<MAXSIZE; i++)
L->Record[i].num=RandArray[i]; //随机数列复位
TempTime=(int)GetTickCount();
QuickSort(L,&CmpNum[2],&ChgNum[2]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n快速排序:");
printf("\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[2],ChgNum[2],SpendTime);

for(i=0; i<MAXSIZE; i++)
L->Record[i].num=RandArray[i]; //随机数列复位
TempTime=(int)GetTickCount();
HeapSort(L,&CmpNum[3],&ChgNum[3]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n堆排序:");
printf("\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[3],ChgNum[3],SpendTime);

for(i=0; i<MAXSIZE; i++)
L->Record[i].num=RandArray[i]; //随机数列复位
TempTime=(int)GetTickCount();
BubbleSort(L,&CmpNum[4],&ChgNum[4]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n冒泡排序:");
printf("\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[4],ChgNum[4],SpendTime);

for(i=0; i<MAXSIZE; i++)
L->Record[i].num=RandArray[i]; //随机数列复位
TempTime=(int)GetTickCount();
SelSort(L,&CmpNum[5],&ChgNum[5]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n选择排序:");
printf("\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[5],ChgNum[5],SpendTime);
}

void main()
{
int select=0;
int dlta[3]={7,3,1};
int Indata[1]={1};
int CmpNum[6],ChgNum[6];
int SpendTime=0;
int TempTime;
LinkList L;
InitLinkList(&L);
memset(CmpNum,0,sizeof(CmpNum));
memset(ChgNum,0,sizeof(ChgNum));
banner();
SelectSort();
scanf("%d",&select);
switch (select)
{
case 0:
TempTime=(int)GetTickCount();
ShellSort(&L,Indata,1,&CmpNum[select],&ChgNum[select]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n插入排序:");
printf("\n\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[select],ChgNum[select],SpendTime);
break;
case 1:
TempTime=(int)GetTickCount();
ShellSort(&L, dlta, 3,&CmpNum[select],&ChgNum[select]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n西尔排序:");
printf("\n\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[select],ChgNum[select],SpendTime);
break;
case 2:
TempTime=(int)GetTickCount();
QuickSort(&L,&CmpNum[select],&ChgNum[select]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n快速排序:");
printf("\n\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[select],ChgNum[select],SpendTime);
break;
case 3:
TempTime=(int)GetTickCount();
HeapSort(&L,&CmpNum[select],&ChgNum[select]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n堆排序:");
printf("\n\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[select],ChgNum[select],SpendTime);
break;
case 4:
TempTime=(int)GetTickCount();
BubbleSort(&L,&CmpNum[select],&ChgNum[select]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n冒泡排序:");
printf("\n\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[select],ChgNum[select],SpendTime);
break;
case 5:
TempTime=(int)GetTickCount();
SelSort(&L,&CmpNum[select],&ChgNum[select]);
SpendTime=(int)GetTickCount()-TempTime;
printf("\n选择排序:");
printf("\n\n比较数字=%d\t变换数字=%d\t消耗时间=%dms\n",CmpNum[select],ChgNum[select],SpendTime);
break;
case 6:
AllAbove(&L,CmpNum,ChgNum);
break;
case 7:
break;
default:
printf("\n输入错误!");
}

Display(&L);
printf("\n\n测试结束，请按回车键结束\n");
getchar();
getchar();
}

计算二十四点及输出表达式：
输入四个正整数，判断该四个数能否通过+-*/四则运算
得到24，如果能，则输出计算表达式。

×××××××××××××