华为上机练习题

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