输出各位倒数和为1的所有三位正整数。

没有输入数据。

由小到大输出数据，输出数据占一行，每两个数之间有一空隔，最后一个数据输出之后不要回车换行也不要有空隔。

各位倒数和为2的样例：
221 212 122

输入一个整数n，输出2的n次方。

总是溢出，输100直接为0，大佬帮帮

#include<iostream>
#include<string>
#include<vector>
using namespace std;
int main(int argc, char** argv)
{
	struct Sale_data {
		string isbn() const { return this->bookNo; }
		Sale_data& combine(const Sale_data& rhs)
		{
			units_sold += rhs.units_sold;
			revenue += rhs.revenue;
			return *this;
		}
		string bookNo;
		unsigned units_sold = 0;
		double revenue = 0.0;
		
		
	};

	Sale_data total;
	if (cin >> total.bookNo >> total.units_sold >> total.revenue)
	{
		Sale_data trans;
		while (cin >> trans.bookNo >> trans.units_sold >> trans.revenue)
		{
			if (total.isbn() == trans.isbn())
			{
				total.combine(trans);
			}
			else
			{
				cout << total.bookNo << " "<<total.units_sold <<" "<< total.revenue << endl;
				total = trans;
			}
		}
		cout << total.bookNo <<" "<< total.units_sold <<" "<< total.revenue << endl;
	}
	else
	{
		cerr << "No Data" << endl;
		return -1;
	}
	return 0;

}

为啥最后一条记录不能输出？

题目六在DATA1开始的内存单元里存放有字符串‘0123456789'使用串存储指令将该字符串变成10个相同的数字，并通过显示器输出。

radstudio 的C++builder 

FMX跨平台支不支持linux,我右键add linux platform没有任何效果

一 学习背景（2020 11 24）

1 学历背景:小 初 高 九年义务教育顺利上来 高二走专科机械工程 因为不喜欢 什么也没学，今年9月专科接本科计算机科学与技术学科全日制2年时间成功 进入物联网工程专业

2 专业背景:可以理解为虽然上了大学但是和初中水准不相上下（所有学科，英语好点但无系统，就是可以做对题但不能完整解释）

生物 物理 化学 英语 数学 政治 计算机 地理 统一停留在初中水准及以下

会一点的: C语言 & 英语 & 数学（步入高中了）

现学学科:传感器 & 高等数学 & 英语 & 政治 & Python & 操作系统 & MySQL

二 目的（1是热爱 2是想考研）

1 关于学校:想去双一流大学（一般招生1-10人），截至到2021年12月中旬 约400天）

需要学的学科:操作系统 & 计算机网络 & 计算机组成原理 & 政治 & 数学 & 英语 & 程序设计（不知道是c还是c++还是其他）

2 关于热爱:喜欢的学科:C语言（特别喜欢） & C++ & 微机原理 & 数理化（特别喜欢） & 生物 & 地理（特别喜欢） & 英语 & 金融（具体是投资，特别喜欢）& 网络安全 & 数据库 &  数据结构 & 算法 & 操作系统 & Vim文本（不知道算不算一个学科，就是不用键盘那种）

关于以后发展:会一辈子走现在喜欢的这些学科，对于将来如何工作的解释；可能会一直学习到研究生，教授然后再出来凭借着金融+计算机开个公司或者到时候再说 但是大学2年+研究生3年+博士（不知道几年）这期间一直学习是一定的。

三 关于迷茫

我的问题就是 我该如何确立学习计划呢（学科很多，但我不着急 因为我会把它们分配到如上所说7，8年中的）

希望可以不是在认为我是在装高手 只希望可以给我一套你们的逻辑说服我或者令我参考择优选择

四 关于优劣势

优势:1 自制力方面不用考虑 2 心理方面不用考虑 我心里足够

劣势:1 400天考研 内容:数学 英语 计算机基础综合（网络 组成原理等）政治 

        2 基础太差

希望大家不带偏见 有什么说什么 我都能接受

用C语言编程

学生成绩统计

从键盘输入一个班（全班人数在15~20之间）学生某门课的成绩，当输入成绩为负值时，输入结束，分别实现下列功能：

（1）录入每个学生的学号（学号：2016001~2016020）和考试成绩；

（2）计算课程的总分和平均分；

如题 最近在做一个项目 要用网关从一台windos系统的电脑里下载一个文件 要求用代码实现

#include <stdio.h>
#include <stdint.h>
#include "eecs388_lib.h"

volatile int intr_count;

#define MAX_INTERRUPTS 16
void (*interrupt_handler[MAX_INTERRUPTS])();
void (*exception_handler[MAX_INTERRUPTS])();

void handle_trap(void) __attribute((interrupt));
void handle_trap()
{
    unsigned long mcause = read_csr(mcause);
    if (mcause & MCAUSE_INT) {
        printf("interrupt. cause=%d, count=%d\n",
            mcause & MCAUSE_CAUSE, (int)intr_count);
        // mask interrupt bit and branch to handler
        interrupt_handler[mcause & MCAUSE_CAUSE] ();
    } else {
        printf("exception=%d\n", mcause & MCAUSE_CAUSE);
        // synchronous exception, branch to handler
        exception_handler[mcause & MCAUSE_CAUSE]();
    }
}

void timer_handler()
{
    intr_count++;

    // YOUR CODE HERE
    set_cycles(get_cycles()+2000*32768/1000);
}

void enable_timer_interrupt()
{
    write_csr(mie, read_csr(mie) | (1 << MIE_MTIE_BIT));
}

void enable_interrupt()
{
    // YOUR CODE HERE
    write_csr(mstatus, read_csr(mstatus)|(1<<MSTATUS_MIE_BIT));
}

void disable_interrupt()
{
    // YOUR CODE HERE
    write_csr(mstatus,read_csr(mstatus)&~(1<<MIE_MTIE_BIT) );
}

void register_trap_handler(void *func)
{
    write_csr(mtvec, ((unsigned long)func));
}

int main (void)
{
    int led_idx = 0;
    int led_gpio[] = {BLUE_LED, GREEN_LED};
    for (int i = 0; i < 2; i++)
        gpio_mode(led_gpio[i], OUTPUT);

    // install timer interrupt handler
    interrupt_handler[7] = timer_handler;

    // write handle_trap address to mtvec
    register_trap_handler(handle_trap);

    // enable timer interrupt
    enable_timer_interrupt();

    // cause timer interrupt
    set_cycles(0);

    // enable global interrupt
    enable_interrupt();

    // main loop.
    int val = 0;
    char angle = 0;
    int prev_intr_count = intr_count;
    while(1) {
        disable_interrupt();
        if (prev_intr_count != intr_count) {
            // toggle led on/off on a new interrupt
            val ^= 1;
            gpio_write(led_gpio[led_idx], val);
            prev_intr_count = intr_count;
          }
          If (intr_count >= 2)

          {

                if (angle >- 10||angle <10)
                {
                  gpio_write(led_gpio[led_idx], OFF);
                }

                    else if(angle <- 10)
                     {
                        printf("count=%d. reset\n", (int)intr_count);
                          intr_count = 0;
                        gpio_write(led_gpio[led_idx], ON);
                        led_idx = (led_idx + 1) % 2;
                    }
                     else if (angle >10)
                     {
                        printf("count=%d. reset\n", (int)intr_count);
                          intr_count = 0;
                        gpio_write(led_gpio[led_idx], ON);
                        led_idx = (led_idx + 1) % 2;
                    }
                }
              }
        enable_interrupt();
    }
    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include "eecs388_lib.h"

volatile int intr_count;

#define MAX_INTERRUPTS 16
void (*interrupt_handler[MAX_INTERRUPTS])();
void (*exception_handler[MAX_INTERRUPTS])();

void handle_trap(void) __attribute((interrupt));
void handle_trap()
{
    unsigned long mcause = read_csr(mcause);
    if (mcause & MCAUSE_INT) {
        printf("interrupt. cause=%d, count=%d\n",
            mcause & MCAUSE_CAUSE, (int)intr_count);
        // mask interrupt bit and branch to handler
        interrupt_handler[mcause & MCAUSE_CAUSE] ();
    } else {
        printf("exception=%d\n", mcause & MCAUSE_CAUSE);
        // synchronous exception, branch to handler
        exception_handler[mcause & MCAUSE_CAUSE]();
    }
}

void timer_handler()
{
    intr_count++;

    // YOUR CODE HERE
    set_cycles(get_cycles()+2000*32768/1000);
}

void enable_timer_interrupt()
{
    write_csr(mie, read_csr(mie) | (1 << MIE_MTIE_BIT));
}

void enable_interrupt()
{
    // YOUR CODE HERE
    write_csr(mstatus, read_csr(mstatus)|(1<<MSTATUS_MIE_BIT));
}

void disable_interrupt()
{
    // YOUR CODE HERE
    write_csr(mstatus,read_csr(mstatus)&~(1<<MIE_MTIE_BIT) );
}

void register_trap_handler(void *func)
{
    write_csr(mtvec, ((unsigned long)func));
}

int main (void)
{
    int led_idx = 0;
    int led_gpio[] = {BLUE_LED, GREEN_LED};
    for (int i = 0; i < 2; i++)
        gpio_mode(led_gpio[i], OUTPUT);

    // install timer interrupt handler
    interrupt_handler[7] = timer_handler;

    // write handle_trap address to mtvec
    register_trap_handler(handle_trap);

    // enable timer interrupt
    enable_timer_interrupt();

    // cause timer interrupt
    set_cycles(0);

    // enable global interrupt
    enable_interrupt();

    // main loop.
    int val = 0;
    char angle = 0;
    int prev_intr_count = intr_count;
    while(1) {
        disable_interrupt();
        if (prev_intr_count != intr_count) {
            // toggle led on/off on a new interrupt
            val ^= 1;
            gpio_write(led_gpio[led_idx], val);
            prev_intr_count = intr_count;
          }
          If (intr_count >= 2)

          {

                if (angle >- 10||angle <10)
                {
                  gpio_write(led_gpio[led_idx], OFF);
                }

                    else if(angle <- 10)
                     {
                        printf("count=%d. reset\n", (int)intr_count);
                          intr_count = 0;
                        gpio_write(led_gpio[led_idx], ON);
                        led_idx = (led_idx + 1) % 2;
                    }
                     else if (angle >10)
                     {
                        printf("count=%d. reset\n", (int)intr_count);
                          intr_count = 0;
                        gpio_write(led_gpio[led_idx], ON);
                        led_idx = (led_idx + 1) % 2;
                    }
                }
              }
        enable_interrupt();
    }
    return 0;
}

输入2个时间，求时间差。
#include<stdio.h>
int main () 
{
int a,b,c,d,h,k;
   printf("请输入两个时间");
   scanf("%d:%d:%d:%d",&a,&c,&b,&d);
  if(a<=b,c<=d)
 {
     h=b-a;
     k=d-c;
  printf("%d:%d",h,k);
 }
  else if (a<=b,c>=d)
 {
    h=b-a-1;
    k=60+d-c;
 printf("%d:%d",h,k);
 }
 else if(a>=b,c<=d)
 {
   h=a-b-1;
   k=60+c-d;
 printf("%d:%d",h,k);
}
else
{
   h=a-b;
   k=c-d;
 printf("%d:%d",h,k); 
} 
return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

int a[4][4];
void RotateLeft(int(&inout)[4][4])
{
	for (int y = 0; y <4; y++){
		for (int x = 0; x < 4; x++){
			a[y][x] = inout[x][4-1-y];
		}
	}
	for (int y = 0; y < 4; y++) {
		for (int x = 0; x < 4; x++) {
			inout[y][x] =a[y][x];
		}
	}
}

void Output(int(&a)[4][4])
{	
	for (int y = 0; y < 4; ++y){
		for (int x = 0; x < 4; ++x){	
			printf("%3d", a[y][x]);
		}
		puts("");
	}
}

int main()
{
	int a[4][4] =
	{
		{  0,  1,  2,  3},
		{  4,  5,  6,  7},
		{  8,  9, 10, 11},
		{ 12, 13, 14, 15},
	};
	Output(a);
	for (int i = 0; i < 4; i++){
		puts("== Rotate left ==");
		RotateLeft(a);
		Output(a);
	}
}

安装根证书后在注册表的相关位置会有对应的注册表项，
例如指纹为D3FBFAA8A67FC9A2EADBF86AEB5D07A9D6AF322E的证书对应的注册表项为HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\SystemCertificates\ROOT\Certificates\D3FBFAA8A67FC9A2EADBF86AEB5D07A9D6AF322E

现在我想使用windows证书函数完成根证书的安装并获得注册表Blob值项，但是使用windows函数安装证书和使用certlm.msc安装证书得到的Blob值项并不相同，(前面数位不相同，证书的注册表头？？)

我想问一下，Blob值项的前面数位代表什么？为什么使用windows函数安装根证书得到的Blob值项和手动安装根证书得到的Blob值项不相同？？

多条件分页显示全部订单信息，条件：条件不得少于：  1、状态（未发货、已发货、已收货）  2、时间段  3、商品名称  4、订单编号  5、收货人电话号码  6、收货人姓名，有大佬会吗？在线等？

code::blocks的编译器可以运行,但是运行C语言得到的结果都是错的,但是输出的格式都有,该换行的换行,就是答案不对,怎么办?求大佬,挺急着用code::blocks的

#include <stdio.h>
int main ()
{
    int letter=0 , number=0, others=0, space=0;
    char ch;
    scanf("%c",&ch);
    while (ch != '\n'){
  
    if (ch>='a' && ch<='z' || ch>='A' && ch<='Z')
       letter++;

    else if (ch >='0' && ch <='9')
        number++;

    else if (ch == ' ')
        space++;

    else
        others++;
}
    printf("%d%d%d%d",letter , number, others, space);
    return 0;

 }
 

我的win32项目里面setfocus(hwnd)并不能将我自己写的窗口切换成焦点。请问是什么原因？

这是我的回调函数

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
    PAINTSTRUCT ps;
    HDC hdc;
    switch (message)
    {

    case WM_CREATE: {
        SetTimer(hwnd, TIME1, 8000, NULL);
        break;
    }
    case WM_TIMER: {
        MessageBox(hwnd, TEXT(""), TEXT("提示！"), MB_OK);
        SetFocus(hwnd);
    }
    case WM_PAINT: {
        hdc=BeginPaint(hwnd, &ps);

        TextOut(hdc, 20, 10, TEXT("你好，艾灵！"), wcslen(TEXT("你好，艾灵！")));

        EndPaint(hwnd, &ps);
        break;
    }
    case WM_CLOSE: {
        break;
    }
    case WM_SYSCOMMAND: {
        break;
    }
    case WM_DESTROY: {
        PostQuitMessage(0);
        break; }
    }
    return DefWindowProc(hwnd, message, wParam, lParam);
}
 

#include <stdio.h>
int main ()
{
    int letter=0 , number=0, others=0, space=0;
    char ch;
    scanf("%c",&ch);
    while (ch!='\n'){
    
    
    if (ch>='a' && ch<='z' || ch>='A' && ch<='Z')
       letter++;
    else if (ch>='0'&&ch<='9')
        number++;
    else if (ch==' ')
        space++;
    else
        others++;
}
    printf("%d%d%d%d",letter , number, others, space);
    return 0;

 }

#include<stdio.h>

#include<stdlib.h>

#define MAXSIZE 20

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

typedef int Status;

typedef char TElemType;

//顺序存储

typedef char SqTree[MAXSIZE];

//顺序存储建立

Status CreatSqTree(SqTree *S){

    printf("输入内容\n");

    scanf("%s",&(*S));

    printf("建立成功\n");

    return OK;

}

//链式存储

typedef struct TNode {

    TElemType data;

    struct  TNode *lchild, *rchild;

}TNode,*BinTree;

//链式二叉树的建立

int CreatTree(BinTree *T)

{

    TElemType ch;

    scanf("%c",&ch);

    if (ch == '#')

        (*T) = NULL;

    else

    {

        (*T) = (TNode *)malloc(sizeof(TNode));

        (*T)->data = ch;

        CreatTree(&(*T)->lchild);//创建左子树

        CreatTree(&(*T)->rchild);//创建右子树

    }

    return 0;

}

//递归先序遍历

void PreOrder(BinTree *T)     

{

    if ((*T)!=NULL)

    {

        printf("%c", (*T)->data);

        PreOrder(&(*T)->lchild);

        PreOrder(&(*T)->rchild);

    }

}

int main()

{

    SqTree S;

    CreatSqTree(&S);

    printf("%s",S);

    BinTree T;

    printf("输入内容\n");

    CreatTree(&T);

    printf("先序排列为：\n");

    PreOrder(&T);

    return 0;

}

10 + 9 * ((8 + 7) % 6) + 5 * 4 % 3 * 2 + 3 

1 + 2 + (3 + 4) * ((5 * 6 % 7 / 8) - 9) * 10

输出结果分别为 44    -627

#define N 10

如上，假如我定义了一个宏定义N，其值为10，想实现以下功能：在printf函数中使用N就可以打印出10.

如何做到？

最近在学着写个带有左侧菜单栏的 APP，用 Android Studio 建了一个 navigation drawer activity，在源码基础上改了改。 大概长这样

然后有个需求是，点其中一个菜单项，先跳转到一个弹窗在几个类型中选一下，然后再展示一个对应的 fragment 。为了这个在中间加的步骤，所以我把其中一个菜单项和他对应的 fragment 解绑了，然后给那个 item 绑了一个新 activity 作为 dialog，选择完成后再 finish 掉，并回调到原来的 activity，展示新 fragment 。

如图，点一下用作选择的按钮，结果如下：

这时候出了两问题：

一 .我是直接通过用 FragmentTransaction replace 了原本的 fragment，但是这里出现了 fragment 重叠的现象。 源码是不会出现重叠问题的，它好像也不是用这种动态加载的方式搞的，但是它的那些工具类让我实在搞不懂。

二.

我 finish 掉作为 dialog 的新 activity 后，回调到原本 activity，它虽然已经更换了 fragment，但是左侧的菜单项依然处于打开状态，还需要再点击屏幕其他地方，把它关掉，就感觉多此一举了。有啥办法直接回到主页面时不展示左侧菜单项。难道要搞个模仿屏幕点击事件吗？

希望有人能替我解决一下疑惑，不胜感激

10 + 9 * ((8 + 7) % 6) + 5 * 4 % 3 * 2 + 3 

1 + 2 + (3 + 4) * ((5 * 6 % 7 / 8) - 9) * 10

输出结果分别为 44    -627

如题，请大神看看我这段代码哪错了

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <string.h>

#define SUITS 4

#define FACES 13

#define CARDS 52

//函数原型

void shuffle(unsigned int wDeck[][FACES]);// 洗牌修改wDeck

void deal (unsigned int wDeck[][FACES], char *ptr[] , const char *wFace[],const char *wSuit[]);

void judge (char *ptr[]);

// 处理没有修改数组

int main ()

{

    // initialize deck array

    unsigned int deck [SUITS] [FACES] = {0};

    char *ptr[5];

    srand(time(NULL));  // seed random-number generator

    shuffle(deck); // shuffle the deck

    //initialize suit array

    const char *suit[SUITS] = {"Hearts","Diamonds","Clubs","Spades"};

    //initialize face array

    const char *face [FACES] = {"Ace", "Deuse", "Three","Four","Five","Six","Seven","Eight","Nine","Ten","Jack","Queen","King"};

    deal (deck, ptr, face, suit);// deal the deck

    judge (ptr);

}

// shuffle cards in deck

void shuffle(unsigned int wDeck[] [FACES])

{

    //for each of the cards, choose slot of deck randomly

    for (size_t card = 1;card <= CARDS; ++card) {

        size_t row;

        size_t column;

        // choose new random location until unoccupied slot found

        do {

            row = rand() % SUITS;

            column = rand() % FACES;

        } while(wDeck [row] [column] != 0);

        // place card number in chosen slot of deck

        wDeck [row] [column] = card;

    }

}

//deal cards in deck

void deal (unsigned int wDeck[][FACES], char *ptr[] , const char *wFace[], const char *wSuit[] )

{

    // deal each of the cards

    for(size_t card= 1; card <= 5; ++card) {

        //loop through rows of wDeck

        for(size_t row = 0; row < SUITS; ++row) {

            // loop thought columns of wDeck for current row

            for (size_t column = 0, i=0; column < FACES; ++column) {

                if(wDeck[row] [column] == card) {

                    *ptr[i]=*wFace[column];

                    i++;

                    printf("%5s of %-8s%c", wFace[column], wSuit[row], card % 2 == 0 ? '\n' : '\t');

                    //2-column format

                    }

             }

         }

     }

}

void judge ( char *ptr[]  )

{

    int num = 0;//记录对数

    for(int i = 0; i < 5; i++)

    {

       for(int j = i+1;j < 5; j++)

        {

            if(ptr[i] == ptr[j])

            {

                num++;

                break;

            }

        }

    }

    printf("手牌有%d个对子\n",num);

}

//* * * * * * * * * * * * * * * * * * * * * * * *
//*PROGRAM          :哈希表的综合操作           *
//*CONTENT          :Insert,Search,Deltet       *
//* * * * * * * * * * * * * * * * * * * * * * * *
#include <dos.h>
#include <conio.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 12 //哈希表的最大容量，与所采//用的哈希函数有关
enum BOOL{False,True};
enum HAVEORNOT{NULLKEY,HAVEKEY,DELKEY}; 
    //哈希表元素的三种状态，没有记录、有记录、//有过记录但已被删除
typedef struct         //定义哈希表的结构
{int  elem[MAXSIZE];   //数据元素体
 HAVEORNOT elemflag[MAXSIZE]; //元素状态标//志，没有记录、有记录、有过记录但已被删除
 int count;  //哈希表中当前元素的个数 
}HashTable;
typedef struct
{int keynum;     //记录的数据域，只有关键字一项
}Record;
void InitialHash(HashTable&); //初始化哈希表
void PrintHash(HashTable);    //显示哈希表中的所//有元素
BOOL SearchHash(HashTable,int,int&); //在哈希表 //中查找元素
BOOL InsertHash(HashTable&,Record);     //在哈//希表中插入元素
BOOL DeleteHash(HashTable&,Record);     //在哈//希表中删除元素
int  Hash(int);  //哈希函数
void main()
{HashTable H;  //声明哈希表H
 char ch,j='y'; 
 int position;
 Record R;
 BOOL temp;
 textbackground(3);  //设定屏幕颜色
 textcolor(15);
 clrscr();
 //-------------------------程序说明-------------------------------
 printf("This program will show how to operate to a HashTable.\n");
 printf("You can display all elems,search a elem,\ninsert a elem,delete a elem.\n");
 //----------------------------------------------------------------
 InitialHash(H);
 while(j!='n')
    {printf("1.display\n");
     printf("2.search\n");
     printf("3.insert\n");
     printf("4.delete\n");
     printf("5.exit\n");
     scanf(" %c",&ch); //输入操作选项
     switch(ch)
      {case '1':if(H.count) PrintHash(H);  //哈希表//不空
		else printf("The HashTable has no elem!\n");
		break;
       case '2':if(!H.count) printf("The HashTable has no elem!\n"); //哈希表空
		else
		   {printf("Please input the keynum(int) of the elem to search:");
		    scanf("%d",&R.keynum); //输入待查//记录的关键字
		    temp=SearchHash(H,R.keynum,position); 
          //temp=True:记录查找成功, //temp=False:没有找到待查记录
		    if(temp) printf("The position of the elem is %d\n",position);
		    else printf("The elem isn't exist!\n");  
		   }
		break;
       case '3':if(H.count==MAXSIZE)   //哈希表//已满
		   {printf("The HashTable is full!\n");
		    break;
		   }
		printf("Please input the elem(int) to insert:");
		scanf("%d",&R.keynum);  //输入要插入//的记录
		temp=InsertHash(H,R); 
                  //temp=True:记录插入成功；//temp=False:已存在关键字相同的记录
		if(temp) printf("Sucess to insert the elem!\n");
		else printf("Fail to insert the elem.The same elem has been exist!\n");
		break;
       case '4':printf("Please input the keynum of the elem(int) to delet:");
		scanf("%d",&R.keynum); //输入要删除记//录的关键字
		temp=DeleteHash(H,R); 
                   //temp=True:记录删除成功；//temp=False:待删记录不存在 
		if(temp) printf("Sucess to delete the elem!\n");
		else printf("The elem isn't exist in the HashTable!\n");
		break;
       default: j='n';
    }
 }
 printf("The program is over!\nPress any key to shut off the window!\n");
 getchar();getchar();
}
void InitialHash(HashTable &H)
{//哈希表初始化
 int i;
 H.count=0;
 for(i=0;i<MAXSIZE;i++) H.elemflag[i]=NULLKEY;
}
void PrintHash(HashTable H)
{//显示哈希表所有元素及其所在位置
 int i;
 for(i=0;i<MAXSIZE;i++) //显示哈希表中记录所在//位置
    if(H.elemflag[i]==HAVEKEY) //只显示标志为HAVEKEY(存放有记录)的元素
       printf("%-4d",i);
 printf("\n");
 for(i=0;i<MAXSIZE;i++) //显示哈希表中记录值
    if(H.elemflag[i]==HAVEKEY)
       printf("%-4d",H.elem[i]);
 printf("\ncount:%d\n",H.count); //显示哈希表当前 //记录数
}
BOOL SearchHash(HashTable H,int k,int &p)
{//在开放定址哈希表H中查找关键字为k的数据元//素，若查找成功，以p指示
 //待查数据元素在表中的位置，并返回True；否则，//以p指示插入位置，并返回False
 int p1;
 p1=p=Hash(k); //求得哈希地址
 while(H.elemflag[p]==HAVEKEY&&k!=H.elem[p])  
      //该位置中填有记录并且关键字不相等
   {p++;  //冲突处理方法：线性探测再散列
    if(p>=MAXSIZE) p=p%MAXSIZE; //循环搜索
    if(p==p1) return False;  //整个表已搜索完，没//有找到待查元素
   }
 if(k==H.elem[p]&&H.elemflag[p]==HAVEKEY)  //查找成功，p指示待查元素位置
    return True; 
 else return False; //查找不成功
}
BOOL InsertHash(HashTable &H,Record e)
{//查找不成功时插入元素e到开放定址哈希表H  //中，并返回True，否则返回False
 int p;
 if(SearchHash(H,e.keynum,p)) //表中已有与e有相//同关键字的元素
    return False;
 else
   {H.elemflag[p]=HAVEKEY;  //设置标志为HAVEKEY，表示该位置已有记录
    H.elem[p]=e.keynum;     //插入记录
    H.count++;          //哈希表当前长度加一 
    return True;
   }
}
BOOL DeleteHash(HashTable &H,Record e)
{//在查找成功时删除待删元素e，并返回True，否//则返回False
 int p;
 if(!SearchHash(H,e.keynum,p)) //表中不存在待删 //元素
   return False;
 else
   {H.elemflag[p]=DELKEY; //设置标志为//DELKEY，表明该元素已被删除
    H.count--;    //哈希表当前长度减一
    return True;
   }
}
int Hash(int kn)
{//哈希函数：H(key)=key MOD 11
 return (kn%11);
}

输入有两个数字n和h。第一个数n是十进制的整数，数不超过int类型的范围；第二个数h是16或8

如果h是16，输出n的十六进制；如果是8，输出n的八进制形式。

咋写  救救孩子