C++编程

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

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

【参考答案】

[cpp]  view plain  copy

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

【参考答案】

[cpp]  view plain  copy

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、输入一个字符串，将其逆序后输出 。

【参考答案】

[cpp]  view plain  copy

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，统计在一个输入字符串中各个不同字符出现的频度。用适当的测试数据来验证这个算法。

【参考答案】

[cpp]  view plain  copy

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)元素的操作。

【参考答案】循环队列类定义

[cpp]  view plain  copy

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. }；  

[cpp]  view plain  copy

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. }  

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

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

【参考答案】

[cpp]  view plain  copy

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) 求所有整数的平均值。

【标准答案】

[cpp]  view plain  copy

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”。试利用字符串的基本运算实现这个替换操作。

[cpp]  view plain  copy

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作为输入数据，检查你的程序的正确性和健壮性。

[cpp]  view plain  copy

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.     }  

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

[cpp]  view plain  copy

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 个函数。

【标准答案】 

[cpp]  view plain  copy

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. }