华为上机练习题

// 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;
}