华为上机练习题_assert(null!=system)-CSDN博客

[cpp]view plaincopy 
   
 // StringFun.cpp : 定义控制台应用程序的入口点。  
 //  
   
 #include "stdafx.h"  
 #include <iostream>  
 #include <assert.h>  
 #include <string>  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <memory.h>  
   
 using namespace std;  
   
 /*删除子串，只要是原串中有相同的子串就删掉，不管有多少个，返回子串个数*/  
 int Del_SubString(const char *src,const char *sub,char *des)  
 {  
     assert(NULL!=src && NULL!=sub && NULL!=des);  
     int cnt=0;  
     int length_sub = strlen(sub);  
     int length_src = strlen(src);  
     char *temp = new char[length_sub+1];  
     memset(temp,0,length_sub+1);  
   
     while (*src!='\0' && src<=src+length_src)  
     {   
         memcpy(temp,src,length_sub);  
         if (strcmp(temp,sub)==0)  
         {  
             ++cnt;  
             src+=length_sub;  
         }   
         else  
         {  
             *des = *src;  
             ++des;  
             ++src;  
         }  
     }  
     delete[] temp;  
     return cnt;  
 }  
 /***************************************************************************************************/  
 /*约瑟夫环问题：设有编号为1，2，……，n的n(n>0)个人围成一个圈,从第1个人开始报数，报到m时停止报数， 
 报m的人出圈，再从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……，如此下去，直到所有人 
 全部出圈为止。当任意给定n和m后，设计算法求n个人出圈的次序。 
 /***************************************************************************************************/  
 typedef struct _Node   
 {  
     int num;  
     _Node *next;  
 }Node;  
   
 Node *CreatList(int n)  
 {  
     Node *pHead = new Node;  
     pHead->num=1;  
     Node *pCur = pHead;  
     for (int i=2;i<=n;++i)  
     {  
         Node *pTemp = new Node;  
         pTemp->num = i;  
         pCur->next = pTemp;  
         pCur = pTemp;  
     }  
     pCur->next = pHead;  
     return pHead;  
 }  
   
 void JosephLoop(Node *pHead,int start,int interval,int n)  
 {  
     Node *pCur = pHead;  
     Node *pPre = NULL;  
     Node *pPos = NULL;  
     int cnt = n;  
     while (pCur->num!=start)  
         pCur = pCur->next;//找到开始位置      
     while (cnt>0)  
     {  
         for (int i=1;i<interval;++i)  
             pCur = pCur->next;//找到第interval个的前一个  
         pPre = pCur;  
         pPos = pCur->next;    //第interval个的位置  
         cout<<pPos->num<<" ";  
         pPre->next = pPos->next;  
         delete pPos;  
         --cnt;  
         pCur = pCur->next;  
     }  
     cout<<endl;  
 }  
 void JosephLoop2(int *array,int interval,int length)  
 {  
     int cnt   = length;//当前数组长度  
     int i;  
     int ivalchange = interval;//当前间隔  
     int start = 0;            //开始位置  
     int pos = 0;              //当前位置  
     while (cnt>1)  
     {  
         pos = (start+ivalchange-1)%cnt;//interval位置  
         cout<<array[pos]<<" ";  
         ivalchange = array[pos];  
         for (i=pos;i<cnt-1;++i)  
             array[i]=array[i+1];//将pos到cnt-1的数据前移  
         --cnt;  
         start = pos%cnt;  
     }  
     cout<<array[0]<<endl;  
 }  
 /*********************************************************************************/  
 /*对一个数组，将数组中偶数从大到小排序，奇数从小到大排序,奇数和偶数交叉着放且输出 
 数组第一位放奇数  若奇数和偶数不等长，则把剩下的直接放到数组中。*/  
   
 void Insert_S2B_Sort(int *array,int length)  
 {  
     assert(NULL!=array && length>0);  
     int i,j;  
     int temp;  
     for (i=1;i<length;++i)  
     {  
         if (array[i]<array[i-1])//需要插入  
         {  
             temp = array[i];  
             for(j=i-1;j>=0&&array[j]>temp;--j)  
                 array[j+1]=array[j];  
             array[j+1]=temp;  
         }  
     }  
 }  
 void MyArrayOrder(int *src,int *des,int length)  
 {  
     assert(NULL!=src && NULL!=des && length>0);  
     int *ou_array = new int[length];  
     int *ji_array = new int[length];  
     int i=0,j=0,low,high;  
     int ji_length=0,ou_length=0;  
     Insert_S2B_Sort(src,length);//用插入排序进行从小到大排序  
     for (low=0,high=length-1;low<length&&high>=0;++low,--high)  
     {  
         if (src[low]%2 == 1)  
         {  
             ji_array[i++]=src[low];  
             ++ji_length;              //筛选出奇数数组和长度  
         }  
         if(src[high]%2 == 0)  
         {  
             ou_array[j++]=src[high];  
             ++ou_length;              //帅选出偶数数组和长度  
         }  
     }  
     //进行组合  
     if (ji_length>ou_length)  
     {  
         for(i=0,j=0;i<length&&j<ou_length;i+=2,++j)  
         {  
             des[i]   = ji_array[j];  
             des[i+1] = ou_array[j];  
         }  
         for(int l=0;l<ji_length-ou_length;++l)  
             des[i+l]=ji_array[j+l];  
     }   
     else  
     {  
         for(i=0,j=0;i<length&&j<ji_length;i+=2,++j)  
         {  
             des[i]   = ji_array[j];  
             des[i+1] = ou_array[j];  
         }  
         for(int l=0;l<ou_length-ji_length;++l)  
             des[i+l]=ou_array[j+l];  
     }  
     delete[] ji_array;  
     delete[] ou_array;  
 }  
   
 /**********************************************************************************/  
 /*操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级 < 50， 
 用户任务的优先级 >= 50且 <= 255。优先级大于255的为非法任务，应予以剔除。现有一任务队列task[]， 
 长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。函数scheduler实现如下功能， 
 将task[] 中的任务按照系统任务、用户任务依次存放到 system_task[] 数组和 user_task[] 数组中 
 （数组中元素的值是任务在task[] 数组中的下标），并且优先级高的任务排在前面，数组元素为-1表示结束。  
 例如：task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99}    system_task[] = {0, 3, 1, 7, -1}     
 user_task[] = {4, 8, 2, 6, -1} 
 函数接口    void scheduler(int task[], int n, int system_task[], int user_task[]) 
 /***********************************************************************************/  
 void scheduler(int *task,int *system_task,int *user_task,int length)  
 {  
     assert(NULL!=task && NULL!=system_task && NULL!=user_task && length>0);  
     int i,j,temp,temp_num,pos=0,end=length-1;  
     int sys_length = 0,user_length = 0;  
     int *array_num = new int[length];  
     for (i = 0; i < length; ++i)  
         array_num[i]=i;  
   
     for (i=1;i<length;++i)  
     {  
         temp = task[i];  
         temp_num = array_num[i];  
         if(task[i]<task[i-1])  
         {  
             for(j=i-1;j>=0&&task[j]>temp;--j)  
             {  
                 task[j+1]=task[j];  
                 array_num[j+1]=array_num[j];  
             }  
             task[j+1]=temp;  
             array_num[j+1]=temp_num;  
         }  
     }  
     while (task[pos]<50)  
         ++pos;           //找到>=50的第一个位置  
     --pos;                 
     while(task[end]>255)  
         --end;          //找到<=255的位置  
     for (i=0;i<=pos;++i)  
     {  
         system_task[i]=array_num[i];  
         ++sys_length;  
     }  
     system_task[i] = -1;  
     ++sys_length;  
     for(j=0;i<=end;++i)  
     {  
         user_task[j++]=array_num[i];  
         ++user_length;  
     }  
     user_task[j] = -1;  
     ++user_length;  
     for(i=0;i<sys_length;++i)  
         cout<<system_task[i]<<" ";  
     cout<<endl;  
     for(i=0;i<user_length;++i)  
         cout<<user_task[i]<<" ";  
     cout<<endl;  
     delete[] array_num;  
 }  
   
 /****************************************************************************************************************/  
 /*给定一个数组input[] ，如果数组长度n为奇数，则将数组中最大的元素放到 output[] 数组最中间的位置，如果数组长度n为偶数， 
 则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边， 
 按照一左一右的顺序，依次存放剩下的数。  
 例如：input[] = {3, 6, 1, 9, 7}       output[] = {3, 7, 9, 6, 1}; 
       input[] = {3, 6, 1, 9, 7, 8}    output[] = {1, 6, 8, 9, 7, 3}*/  
   
 void array_sort(int *input,int *output,int length)  
 {  
     assert(NULL!=input && NULL!=output && length>0);  
     int mid = length/2;  
     int left = mid-1;  
     int rigth = mid+1;  
     int i = length-1;  
     Insert_S2B_Sort(input,length);  
     output[mid]= input[i--];  
     while (i>=0)  
     {     
         if(left>=0)  
             output[left--]  = input[i--];  
         if(rigth<length)  
             output[rigth++] = input[i--];  
     }  
   
 }  
   
 /*通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符， 
 将非首次出现的字符过滤掉。比如字符串“abacacde”过滤结果为“abcde”。*/  
 void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr)  
 {  
     assert(NULL!=pInputStr && NULL!=pOutputStr && lInputLen>0);  
     bool array_flag[26]={0};  
     while (lInputLen>0)  
     {  
         if (!array_flag[*pInputStr-'a'])  
         {  
             array_flag[*pInputStr-'a']=true;  
             *pOutputStr++ = *pInputStr++;  
         }   
         else   
         {  
             ++pInputStr;  
         }  
         --lInputLen;  
     }  
     *pOutputStr='\0';  
 }  
   
 /*通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。 
 压缩规则： 
 1、仅压缩连续重复出现的字符。比如字符串"abcbc"由于无连续重复字符，压缩后的字符串还是"abcbc"。 
 2、压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz"压缩后就成为"3x6yz"。*/  
 void IntToChar(int num,char *pOutPut)  
 {  
     int shan  = num;  
     int yushu = 0;  
     char *pLow = pOutPut;  
     char *pHigh;  
     while (shan!=0)  
     {  
         yushu = shan%10;  
         shan  = shan/10;  
         *pOutPut++ = yushu + '0';  
     }  
     *pOutPut = '\0';  
     pHigh = pOutPut -1;  
     while (pLow<pHigh)  
     {  
         *pLow = *pLow^*pHigh;  
         *pHigh = *pLow^*pHigh;  
         *pLow = *pLow^*pHigh;  
         ++pLow;  
         --pHigh;  
     }  
 }  
 void stringZip(const char *pInputStr, char *pOutputStr)  
 {  
     char CharCur ;  
     char CharNext ;  
     char InttoStr[9];  
     char *temp = InttoStr;  
     int cnt = 1;      //计数  
     while (*pInputStr!='\0')  
     {  
         CharCur  = *pInputStr;  
         CharNext = *(pInputStr+1);  
         if(CharCur!=CharNext)  
         {  
             if (cnt>1)  
             {  
                 IntToChar(cnt,temp);  
                 while (*temp!='\0')  
                 {  
                     *pOutputStr++ = *temp++;  
                 }      
                 temp = InttoStr;  
                 cnt = 1;  
             }  
             *pOutputStr++ = CharCur;  
             ++pInputStr;  
         }  
         else  
         {  
             ++cnt;  
             ++pInputStr;  
         }  
     }  
     *pOutputStr = '\0';  
 }  
   
 /*A,B两个数据，A递增数组，B递减数组。找出A、B两个数组中交集的第K大个元素。*/  
 int GetKNumber(int *arrayA,int *arrayB,int lengthA,int lengthB,int k)  
 {  
     assert(NULL!=arrayA && NULL!=arrayB && lengthA>0 && lengthB>0);  
     int high = lengthA-1;  
     int low = 0;  
     int cnt=0;  
     while (high>=0 && low<lengthB)  
     {  
         if(arrayA[high]>arrayB[low])  
             --high;  
         else if(arrayA[high]<arrayB[low])  
             ++low;  
         else  
         {  
             ++cnt;  
             if(cnt == k)  
                 return arrayA[high];  
             --high;  
             ++low;  
         }  
     }  
     return -1;//没找到  
 }  
   
   
 /**********************************************************************************/  
 /*字符滤除函数：滤除输入字符串中相同的字符 
 /***********************************************************************************/  
 void CharFliter(char *pInput,char *pOutput,int *Outlength)  
 {  
     bool flag_array[256]={false};  
     int i=0;  
     *Outlength = 0;  
     while (i<1000)  
     {  
         if (!flag_array[*pInput-'\0'])  
         {  
             flag_array[*pInput-'\0'] = true;  
             *pOutput++ = *pInput++;  
             ++(*Outlength);  
         }   
         else  
         {  
             ++pInput;  
         }  
         ++i;  
     }  
 }  
   
 /**********************************************************************************/  
 /*字符串滤除函数：滤除给定输入字符串中相同的单词，单词以空格或者逗号隔开。 
 /***********************************************************************************/  
 void StrFliter(char *pInput,char *pOutput,int *OutLength)  
 {  
     char *input = pInput;  
     char *pChar[256];  
     *OutLength=0;  
     char *temp;  
     char *temp2;  
     int i = 1,j,k;  
     pChar[0] = input;  
     while (*input!='\0')  
     {  
         if(*input==' ')  
         {  
             pChar[i++] = input+1;  
         }  
         if(*input==',')  
         {  
             *input = ' ';  
             pChar[i++] = input+1;  
         }  
         ++input;  
     }  
     *input = ' ';  
     for (j=0;j<i-1;++j)  
     {  
         temp = pChar[j];  
         if(temp!=NULL)  
         {  
             for (k=j+1;k<i;++k)  
             {  
                 temp2 = pChar[k];  
                 temp = pChar[j];  
                 if(temp2!=NULL)  
                 {  
                     while (*temp!=' '&& *temp2!=' ')  
                     {  
                         if(*temp!=*temp2)  
                             break;  
                         ++temp;  
                         ++temp2;  
                     }  
                     if(*temp ==' '&& *temp2 ==' ')  
                         pChar[k]=NULL;  
                 }  
                   
             }  
         }  
           
     }  
   
     for (j=0;j<i;)  
     {  
         temp = pChar[j];  
         if (pChar[j]!=NULL)  
         {  
             while (*temp!=' ')  
             {  
                 *pOutput++ = *temp++;  
                 ++(*OutLength);  
             }  
             *pOutput++ = ' ';  
             ++(*OutLength);  
             ++j;  
         }   
         else  
         {  
             ++j;  
         }  
     }  
 }  
   
   
 int _tmain(int argc, _TCHAR* argv[])  
 {  
     char des[100] = {'\0'};  
     int cnt = Del_SubString("123abc12de1234fg1hi213j123k","123",des);  
     cout<<"cnt = "<<cnt<<endl;  
     cout<<"des : "<<des<<endl;  
   
     Node *pHead = CreatList(17);  
     JosephLoop(pHead,3,5,17);  
   
     int array[]={3,1,2,4,8,0,3,6};  
     int length = sizeof(array)/sizeof(array[0]);  
     JosephLoop2(array,7,length);  
   
     int src[]={2,3,14,6,2,15,12,14,4,11};  
     int des1[100];  
     int length_src = sizeof(src)/sizeof(src[0]);  
     MyArrayOrder(src,des1,length_src);  
     for (int i=0;i<length_src;++i)  
     {  
         cout<<des1[i]<<" ";  
     }  
     cout<<endl;  
   
     int task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99,114,170,20,11,17};  
     int length_task = sizeof(task)/sizeof(task[0]);  
     int system_task[100];  
     int user_task[100];  
     scheduler(task,system_task,user_task,length_task);  
   
     int input[] = {3, 6, 1, 9, 7, 8};  
     int output[20];  
     int length_input = sizeof(input)/sizeof(input[0]);  
     array_sort(input,output,length_input);  
     for (int i=0;i<length_input;++i)  
     {  
         cout<<output[i]<<" ";  
     }  
     cout<<endl;  
   
     char *InputStr = "abacacde";  
     long Ilength = strlen(InputStr);  
     char OutputStr[255];  
     stringFilter(InputStr, Ilength, OutputStr);  
     cout<<OutputStr<<endl;  
   
     char *InputStr2 = "abbbddcppppiiigggppppppiiiiiiiiiggggggbbddcggggggggg";  
     int Ilength2 = strlen(InputStr2);  
     char OutputStr2[255]={'a'};  
     stringZip(InputStr2, Ilength2, OutputStr2);  
     cout<<OutputStr2<<endl;  
   
     int arrayA[]={3,4,5,6,7,8,9};  
     int arrayB[]={12,10,9,8,7,1};  
     int lengthA = sizeof(arrayA)/sizeof(arrayA[0]);  
     int lengthB = sizeof(arrayB)/sizeof(arrayB[0]);  
     int NumK = GetKNumber(arrayA,arrayB,lengthA,lengthB,4);  
     cout<<NumK<<endl;  
   
     char inputchar[1000]={'\0'};  
     char outputchar[1000];  
     cin.getline(inputchar,1000);  
     int Outlength = 0;  
     //CharFliter(inputchar,outputchar,&Outlength);  
     StrFliter(inputchar,outputchar,&Outlength);  
     for(int i=0;i<Outlength;++i)  
         cout<<outputchar[i];  
     cout<<endl;  
     system("pause");  
     return 0;  
 }  
 
  转自：http://blog.csdn.net/yangmingjinqq/article/details/25104461 
 