devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

经典C++笔试题目--100(编程练习(比C要难)(91-100))_c++很难的题

作者：你好赵伟 | 2024-07-19 18:07:50

赞

踩

c++很难的题


编程练习(比C要难)(91-100)

91、请编写一个 C 函数，该函数给出一个字节中被置 1 的位的个数。 

【参考答案】 
  1. unsigned   int   TestAsOne0(char   log)  {
  2.         int   i;             
  3. 	unsigned   int   num=0,   val;             
  4. 	for(i=0;   i<8;   i++)    {                     
  5. 		val   =   log   >>   i;     //移位                  
  6. 		val   &=   0x01;     //与1相与                  
  7. 		if(val)                             
  8. 			num++;             
  9. 	}           
  10.  
  11.  	return   num;    
  12.  }


92、编写一个函数，函数接收一个字符串,是由十六进制数组成的一组字符串,函数的功能是把接到的这组字符串转换成十进制数字.并将十进制数字返回。

【参考答案】 
  1. BOOL   HexToDec(   LPCTSTR   shex,int&   idec   )     {
  2.          int   i,mid;        
  3. 	 int   len   =   lstrlen(   shex   );         
  4. 	if(   len>8   )             
  5. 		return   FALSE;         
  6. 	mid   =   0;  
  7. 	 idec   =   0;        
  8. 	 for(   i=0;i<len;i++   )     {            
  9. 		 if(   shex[i]>='0'&&shex[i]<='9'   )                 
  10. 			mid   =   shex[i]-'0';             
  11. 		else   if(   shex[i]>='a'&&shex[i]<='f'   )                 
  12. 			mid   =   shex[i]   -'a'   +10;            
  13. 		 else   if(   shex[i]>='A'&&shex[i]<='F'   )                
  14. 			 mid   =   shex[i]   -'A'   +10;            
  15. 		 else                 
  16. 			return   FALSE;                 
  17. 		mid   <<=   ((len-i-1)<<2);   // 移位表示变为2的n次方倍
  18.           	idec   =idc+mid;            
  19. 	 }        
  20.  
  21. 	 return   TRUE;     
  22. }


93、输入一个字符串，将其逆序后输出 。

【参考答案】 
  1. void main(){  	
  2. 	char a[50];memset(a,0,sizeof(a));  	
  3. 	int i=0,j;  	
  4. 	char t;  	
  5. 	cin.getline(a,50,'\n');  	
  6. 	for(i=0,j=strlen(a)-1;i<strlen(a)/2;i++,j--)  {  		
  7. 		t=a[i];  		
  8. 		a[i]=a[j];  		
  9. 		a[j]=t;  	
  10. 	}  	
  11.  
  12. 	cout<<a<<endl;   
  13. }


94、编写一个算法frequency，统计在一个输入字符串中各个不同字符出现的频度。用适当的测试数据来验证这个算法。

【参考答案】 
  1. void frequency( String& s, char& A[ ], int& C[ ], int &k ) 
  2. {
  3. 	int i, j, len = s.length( );
  4. 	if ( !len ) { cout << "The string is empty. " << endl;  k = 0;  return; }
  5. 	else 
  6. 	{  
  7. 		A[0] = s[0];  C[0] = 1;  k = 1;  	/*语句s[i]是串的重载操作*/
  8.    		for ( i = 1; i < len; i++ ) C[i] = 0;  			/*初始化*/
  9. 		for ( i = 1; i < len; i++ ) 
  10. 		{	 		/*检测串中所有字符*/
  11. 			j = 0;   while ( j < k && A[j] != s[i] ) j++; /*检查s[i]是否已在A[ ]中*/ 
  12. 			if ( j == k ) 
  13. 			{ A[k] = s[i]; C[k]++; k++ }		/*s[i]从未检测过*/
  14. 			else C[j]++;			/*s[i]已经检测过*/ 
  15. 		}
  16. 	}
  17. }


95、假设以数组Q[m]存放循环队列中的元素, 同时以rear和length分别指示环形队列中的队尾位置和队列中所含元素的个数。试给出该循环队列的队空条件和队满条件, 并写出相应的插入(enqueue)和删除(dlqueue)元素的操作。

【参考答案】循环队列类定义 
  1. #include <assert.h>
  2. template <class Type> class Queue {	//循环队列的类定义
  3. public: 
  4. 	Queue ( int=10 );
  5. 	~Queue ( ) { delete [ ] elements; }
  6. 	void EnQueue ( Type & item );
  7. 	Type DeQueue ( );
  8. 	Type GetFront ( );
  9. 	void MakeEmpty ( ) { length = 0; }		//置空队列
  10. 	int IsEmpty ( ) const { return length == 0; }	//判队列空否
  11. 	int IsFull ( ) const { return length == maxSize; }	//判队列满否
  12. private:	
  13. 	int rear, length;				//队尾指针和队列长度
  14. 	Type *elements;				//存放队列元素的数组
  15. 	int maxSize;				//队列最大可容纳元素个数
  16. }；
  1. template <class Type>
  2. Queue<Type>:: Queue ( int sz ) : rear (maxSize-1), length (0), maxSize (sz) 
  3. {//建立一个最大具有maxSize个元素的空队列。
  4. <span style="white-space:pre">	</span>elements = new Type[maxSize];<span style="white-space:pre">		</span>//创建队列空间
  5. <span style="white-space:pre">		</span>   assert ( elements != 0 );<span style="white-space:pre">		</span>//断言: 动态存储分配成功与否
  6. }
  7. template<class Type> 
  8. void Queue<Type> :: EnQueue ( Type &item ) 
  9. {
  10. <span style="white-space:pre">	</span>assert ( ! IsFull ( ) );<span style="white-space:pre">			</span>//判队列是否不满，满则出错处理
  11. <span style="white-space:pre">	</span>length++;<span style="white-space:pre">				</span>//长度加1
  12. <span style="white-space:pre">	</span>rear = ( rear +1) % maxSize;<span style="white-space:pre">		</span>//队尾位置进1
  13. <span style="white-space:pre">	</span>elements[rear] = item;<span style="white-space:pre">			</span>//进队列
  14. }
  15. template<class Type> 
  16. Type Queue<Type> :: DeQueue ( ) 
  17. {
  18. <span style="white-space:pre">	</span>assert ( ! IsEmpty ( ) ); <span style="white-space:pre">			</span>//判断队列是否不空，空则出错处理
  19. <span style="white-space:pre">	</span>length--;<span style="white-space:pre">				</span>//队列长度减1
  20. <span style="white-space:pre">	</span>return elements[(rear-length+maxSize) % maxSize];<span style="white-space:pre">	</span>//返回原队头元素值
  21. }
  22. template<class Type> 
  23. Type Queue<Type> :: GetFront ( ) 
  24. {
  25. <span style="white-space:pre">	</span>assert ( ! IsEmpty ( ) );
  26. <span style="white-space:pre">	</span>return elements[(rear-length+1+maxSize) % maxSize];<span style="white-space:pre">	</span>//返回队头元素值
  27. }
  28.


96、已知A[n]为整数数组，试写出实现下列运算的递归算法：

(1) 求数组A中的最大整数。
(2) 求n个整数的和。
(3) 求n个整数的平均值。

【参考答案】 
  1. #include <iostream.h> 
  2. class RecurveArray 
  3. {					//数组类声明 
  4. private: 	int *Elements;		//数组指针 	
  5. 		int ArraySize;		//数组尺寸
  6. 		int CurrentSize;		//当前已有数组元素个数 
  7. public :
  8. 		RecurveArray ( int MaxSize =10 ) :
  9. 		ArraySize ( MaxSize ), Elements ( new int[MaxSize] ){ } 
  10. 		~RecurveArray ( ) { delete [ ] Elements; } 
  11. 		void InputArray();		//输入数组的内容 
  12. 		int MaxKey ( int n );		//求最大值 
  13. 		int Sum ( int n );		//求数组元素之和
  14. 		float Average ( int n );	//求数组元素的平均值
  15. };
  16.  
  17.  
  18. void RecurveArray :: InputArray ( )
  19. {					//输入数组的内容
  20. 		cout << "Input the number of Array: \n";
  21. 		for ( int i = 0; i < ArraySize; i++ ) cin >> Elements[i];
  22. }
  23.  
  24. int RecurveArray :: MaxKey ( int n ) 
  25. {			//递归求最大值
  26. 		if ( n == 1 ) return Elements[0];
  27. 		int temp = MaxKey ( n - 1 );
  28. 		if ( Elements[n-1] > temp ) return Elements[n-1];
  29. 		else return temp;
  30. }
  31. int RecurveArray :: Sum ( int n ) {			//递归求数组之和
  32. 		if ( n == 1) return Elements[0];
  33. 		else return Elements[n-1] + Sum (n-1);
  34. }
  35. float RecurveArray :: Average ( int n ) {			//递归求数组的平均值
  36. 		if ( n == 1) return (float) Elements[0];
  37. 		else return ( (float) Elements[n-1] + ( n - 1) * Average ( n - 1 ) ) / n;
  38. }
  39. int main ( int argc,  char* argv [ ] ) { 	
  40. 			int size = -1;
  41. 			cout << "No. of the Elements : ";
  42. 			while ( size < 1 ) cin >> size;
  43. 			RecurveArray ra ( size );
  44. 			ra.InputArray();	
  45. 			cout<< "\nThe max is:  " << ra.MaxKey ( ra.MaxSize ) << endl;
  46. 			cout<< "\nThe sum is:  " << ra.Sum ( ra.MaxSize ) << endl;
  47. 			cout<< "\nthe avr is:  " << ra.Average ( ra.MaxSize ) << endl;
  48. 			return 0;
  49. }



97、已知f为单链表的表头指针, 链表中存储的都是整型数据，试写出实现下列运算的递归算法：

(1) 求链表中的最大整数。
(2) 求链表的结点个数。
(3) 求所有整数的平均值。

【标准答案】 

  1. #include <iostream.h>		//定义在头文件"RecurveList.h"中
  2. class List;		
  3. class ListNode {					//链表结点类
  4. friend class List;
  5. private:
  6. 		int data;			//结点数据
  7. 		ListNode *link;		//结点指针
  8. 		ListNode ( const int item ) : data(item), link(NULL) { }	//构造函数
  9. };
  10. class List {			//链表类
  11. private:
  12. 		ListNode *first, current;
  13. 		int Max ( ListNode *f );
  14. 		int Num ( ListNode *f );
  15. 		float Avg ( ListNode *f,  int& n );
  16. public:
  17. 		List ( ) : first(NULL), current (NULL) { }		//构造函数
  18. 		~List ( ){ }					//析构函数
  19. 		ListNode* NewNode ( const int item );	//创建链表结点, 其值为item
  20. 		void NewList ( const int retvalue );	//建立链表, 以输入retvalue结束
  21. 		void PrintList ( );			//输出链表所有结点数据
  22. 		int GetMax ( ) { return Max ( first ); }		//求链表所有数据的最大值
  23. 		int GetNum ( ) { return Num ( first ); }		//求链表中数据个数
  24. 		float GetAvg ( ) { return Avg ( first ); }		//求链表所有数据的平均值
  25. };	
  26.  
  27. ListNode* List :: NewNode ( const int item ) {			//创建新链表结点
  28. 		ListNode *newnode = new ListNode (item);
  29. 		return newnode;
  30. }
  31. void List :: NewList ( const int retvalue ) {		//建立链表, 以输入retvalue结束
  32. 		first = NULL;  int value;  ListNode *q;
  33. 		cout << "Input your data:\n";		//提示
  34. 		cin >> value;			//输入
  35. 		while ( value != retvalue ) 
  36. {			//输入有效
  37. 			q = NewNode ( value );	//建立包含value的新结点
  38. 			if ( first == NULL ) first = current = q;//空表时, 新结点成为链表第一个结点
  39. 			else { current->link = q;  current = q; }	//非空表时, 新结点链入链尾
  40. 			cin >> value;			//再输入
  41. 		}
  42. 		current->link = NULL;			//链尾封闭
  43. }
  44. void List :: PrintList ( ) 
  45. {							//输出链表
  46. 		cout << "\nThe List is : \n";
  47. 		ListNode *p = first;
  48. 		while ( p != NULL ) { 	cout << p->data << '  ';  p = p->link; 	}
  49. 		cout << ‘\n’; 
  50. }
  51.  
  52. 	int List :: Max ( ListNode *f ) 
  53. 	{				//递归算法 : 求链表中的最大值
  54. 		if ( f ->link == NULL ) return f ->data;	//递归结束条件
  55. 		int temp = Max ( f ->link );		//在当前结点的后继链表中求最大值
  56. 		if ( f ->data > temp ) 
  57. 			return f ->data;	//如果当前结点的值还要大, 返回当前检点值
  58. 		else return temp;		//否则返回后继链表中的最大值
  59. 	}
  60. 	int List :: Num ( ListNode *f ) 
  61. 	{				//递归算法 : 求链表中结点个数
  62. 		if ( f == NULL ) return 0;	//空表, 返回0
  63. 		return 1+ Num ( f ->link );		//否则, 返回后继链表结点个数加1
  64. 	}
  65. 	float List :: Avg ( ListNode *f , int& n ) 
  66. 	{				//递归算法 : 求链表中所有元素的平均值
  67. 		if ( f ->link == NULL ) 		//链表中只有一个结点, 递归结束条件
  68. 		{ 
  69. 			n = 1;  return ( float ) (f ->data ); 
  70. 		}
  71. 		else 
  72. 		{ float Sum = Avg ( f ->link, n ) * n;  n++;  return ( f ->data + Sum ) / n; }
  73. 	}
  74.  
  75. #include "RecurveList.h"			//定义在主文件中
  76. int main ( int argc, char* argv[ ] ) 
  77. {
  78. 		List test;   int finished;
  79. 		cout << “输入建表结束标志数据 ：”;
  80. 		cin >> finished;			//输入建表结束标志数据 
  81. 		test.NewList ( finished );		//建立链表
  82. 		test.PrintList ( );			//打印链表
  83. 		cout << "\nThe Max is : " << test.GetMax ( );
  84. 		cout << "\nThe Num is : " << test.GetNum ( );
  85. 		cout << "\nThe Ave is : " << test.GetAve () << '\n';
  86. 		printf ( "Hello World!\n" );
  87. 		return 0;
  88. }


98、字符串的替换操作replace (String &s, String &t, String &v)是指：

若t是s的子串，则用串v替换串t在串s中的所有出现；若t不是s的子串，则串s不变。例如，若串s为“aabbabcbaabaaacbab”，串t为“bab”，串v为“abdc”，则执行replace操作后，串s中的结果为“aababdccbaabaaacabdc”。试利用字符串的基本运算实现这个替换操作。 
  1. 【参考答案】
  2. String & String :: Replace ( String & t, String &v)
  3. { 	  
  4. 	if ( ( int id = Find ( t ) ) == -1 ) 	//没有找到，当前字符串不改，返回
  5. 	{ cout << “The (replace) operation failed.” << endl;  return *this; }   
  6. 	String temp( ch );//用当前串建立一个空的临时字符串   
  7. 	ch[0] = '\0';  curLen = 0;	//当前串作为结果串，初始为空
  8.   	int j, k = 0, l;		//存放结果串的指针		 	 
  9. 	 while ( id != -1 ) { 		 
  10. 		for ( j = 0; j < id; j++) ch[k++] = temp.ch[j];	
  11. 		 curLen += id + v.curLen;		//修改结果串连接后的长度
  12. 		 if ( curLen <= maxLen ) l = v.curLen; //确定替换串v传送字符数l
  13. 		 else { l = curLen - maxLen;  curLen = maxLen; }
  14. 		 for ( j = 0; j < l; j++ ) ch[k++] = v.ch[j];
  15. 				//连接替换串v到结果串ch后面
  16. 	 	 if ( curLen == maxLen ) break;	//字符串超出范围
  17. 		 for ( j = id + t.curLen; j < temp.curLen; j++ ) 
  18. 			temp.ch[j- id - t.curLen] = temp.ch[j];	//删改原来的字符串  	temp.curLen -= ( id + t.curLen );
  19. 		id = temp.Find ( t ); 	  }
  20.   		return *this;
  21. }



99、试编写一个求解Josephus问题的函数。用整数序列1, 2, 3, ……, n表示顺序围坐在圆桌周围的人，并采用数组表示作为求解过程中使用的数据结构。然后使用n = 9, s = 1, m = 5，以及n = 9, s = 1, m = 0，或者n = 9, s = 1, m = 10作为输入数据，检查你的程序的正确性和健壮性。

  1. 【参考答案】
  2. void Josephus( int A[ ], int n, s, m ){
  3. 	int i, j, k, tmp;
  4. 	if ( m == 0 ) {
  5. 		cout << "m = 0是无效的参数！" << endl; 
  6. 		return;
  7. 	}
  8. 	for ( i = 0; i < n; i++ ) A[i] = i + 1;		/*初始化，执行n次*/
  9. 	i = s - 1;				/*报名起始位置*/
  10. 	for ( k = n; k > 1; i-- ) {			/*逐个出局，执行n-1次*/
  11. 		if ( i == k ) i = 0;
  12. 			i = ( i + m - 1 ) % k;		/*寻找出局位置*/
  13. 		if ( i != k-1 ) {
  14.    			tmp = A[i];		/*出局者交换到第k-1位置*/
  15. 			for ( j = i; j < k-1; j++ ) A[j] = A[j+1];
  16. 			 A[k-1] = tmp;
  17. 		}
  18. 	}
  19. 		for ( k = 0; k < n / 2; k++ ) {		/*全部逆置, 得到出局序列*/
  20. 			tmp = A[k]; A[k] = A[n-k+1]; A[n-k+1] = tmp;
  21. 		}
  22. 	}
  23.


100、编写类 String 的构造函数、析构函数和赋值函数已知类 String 的原型为： 

  1. class String 
  2. 	 { 
  3. 	   public: 
  4. 	  String(const char *str = NULL); // 普通构造函数 
  5. 	  String(const String &other);     // 拷贝构造函数 
  6. 	  ~ String(void);         // 析构函数 
  7. 	  String & operate =(const String &other); // 赋值函数 
  8. 	   private: 
  9. 	  char   *m_data;    // 用于保存字符串 
  10. 	 };
请编写 String 的上述 4 个函数。
【标准答案】  
  1. 	// String 的析构函数 
  2. 	 String::~String(void) 
  3. 	{ 
  4. 	 delete [] m_data;                       
  5. 	// 由于 m_data 是内部数据类型，也可以写成 delete m_data;
  6. 	 } 
  7. 	// String 的普通构造函数              
  8. 	 String::String(const char *str) 
  9. 	{ 
  10. 	 if(str==NULL)                           
  11. 	 { 
  12. 	  m_data = new char[1];    // 若能加 NULL 判断则更好 
  13. 	  *m_data = ‘\0’;                       
  14. 	 }                                         
  15. 	 else 
  16. 	 { 
  17. 	  int length = strlen(str);            
  18. 	  m_data = new char[length+1];      
  19. 	  strcpy(m_data, str);                 
  20. 	 } 
  21. 	} 
  22. 	// 拷贝构造函数 
  23. 	 String::String(const String &other)  
  24. 	 {  
  25. 	 int length = strlen(other.m_data);   
  26. 	 m_data = new char[length+1];      // 若能加 NULL 判断则更好   
  27. 	 strcpy(m_data, other.m_data);          
  28. 	} 
  29. 	// 赋值函数 
  30. 	 String & String::operate =(const String &other)  
  31. 	{  
  32. 	 	if(this == &other) 
  33. 	 	return *this; 
  34. 		delete [] m_data; 
  35. 		int length = strlen(other.m_data);  
  36. 		m_data = new char[length+1];     
  37. 		strcpy(m_data, other.m_data); 
  38. 		return *this; 
  39. 	} 
  40.  
  41.













声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号