#include<iostream> using namespace std; #include<cmath> #include<iomanip> //虚函数 /*class ClassA { public: ClassA() { cout<<"A类构造函数被调用"<<endl; } ~ClassA() { cout<<"A类析构函数被调用"<<endl; } virtual void getnum()=0; //{ // cout<<"A类虚函数被调用"<<endl; //} private: int num; char *str; double dnum; }; class ClassB:public ClassA { public: ClassB() { cout<<"B类构造函数被调用"<<endl; } ~ClassB() { cout<<"B类析构函数被调用"<<endl; } virtual void getnum() { cout<<"B类虚函数被调用"<<endl; } private: char Bstr[10]; }; void main() { ClassA *pc; ClassB B; pc=&B; pc->getnum(); getchar(); }*/ /* 上一程序的缩略版 class ClassA { public: virtual void getnum() { cout<<"A类虚函数被调用"<<endl; } }; class ClassB:public ClassA { public: virtual void getnum() { cout<<"B类虚函数被调用"<<endl; } }; void main() { ClassA *pc; ClassB B; pc=&B; pc->getnum(); getchar(); }*/ /* 通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符， 将非首次出现的字符过滤掉。 比如字符串“abacacde”过滤结果为“abcde”。 */ void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr) { //const char *TempStr=pInputStr; int count1=0; int count2=0; int i=0; while(count1<=lInputLen) { for(i=0;i<=count2;) { if(*(pInputStr+count1)!=*(pOutputStr+i))//判断是否有重复字符 i++; else break; } if(i>count2) { *(pOutputStr+count2)=*(pInputStr+count1); count2++; } count1++; } } /*通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩， 并输出压缩后的字符串。 压缩规则： 1. 仅压缩连续重复出现的字符。比如字符串"abcbc"由于无连续重复字符，压缩后的字符串还是"abcbc". 2. 压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz"压缩后就成为"3x6yz"*/ void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr) { int i=0; int j=0; int k=0; for(i=0;i<lInputLen;i=j) { for(j=i+1;j<lInputLen;j++) if(*(pInputStr+j)!=*(pInputStr+i)) break; if(j!=i+1) *(pOutputStr+k++)=char(j-i+'0'); *(pOutputStr+k++)=*(pInputStr+i); } } /* 题目描述（50分）： 通过键盘输入100以内正整数的加、减运算式，请编写一个程序输出运算结果字符串。 输入字符串的格式为：“操作数1 运算符 操作数2”，“操作数”与“运算符”之间以一个空格隔开。 补充说明： 1. 操作数为正整数，不需要考虑计算结果溢出的情况。 2. 若输入算式格式错误，输出结果为“0”。 要求实现函数： void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr); 【输入】 pInputStr： 输入字符串 lInputLen： 输入字符串长度 【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长； 【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出 示例 输入：“4 + 7” 输出：“11” 输入：“4 - 7” 输出：“-3” 输入：“9 ++ 7” 输出：“0” 注：格式错误 */ bool Isnumber(char c) { if(c<='9'&&c>='0'){ return true; }else{ return false; } } void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr) { int ops1=0; int ops2=0; int num=0; char Coptr; int i=0; int j=0; int isvailed=0; while(Isnumber(pInputStr[i])) { ops1=ops1*10+(int)(pInputStr[i]-'0'); i++; } //cout<<ops1<<endl; if(i==0) isvailed=1; while(pInputStr[i++]==' '); //cout<<i<<endl; j=i-1; Coptr=pInputStr[j];//获取操作符 //cout<<Coptr<<endl; while(pInputStr[j++]==' '); j=i+1; while(Isnumber(pInputStr[j])) { ops2=ops2*10+(int)(pInputStr[j]-'0'); j++; } if(j==(i+1)) isvailed=1; if(isvailed==1) *pOutputStr='0'; else { switch(Coptr) { case '+': num=ops1+ops2; break; case '-': num=ops1-ops2; break; case '*': num=ops1*ops2; break; case '/': num=ops1/ops2; break; default: *pOutputStr='0'; break; } } if(num==0) *pOutputStr='0'; int scale=100; if(num<0) { *pOutputStr++='-'; num=-num; } for(int k=0;k<3;k++) { if(num/scale) { *pOutputStr++=char(num/scale+'0'); } num=num%scale; if(num==0) { *pOutputStr++=char('0'); break; } scale/=10; } } /*1 字串转换 问题描述： 将输入的字符串（字符串仅包含小写字母‘a’到‘z’），按照如下规则，循环转换后输出：a->b,b->c,…,y->z,z->a； 若输入的字符串连续出现两个字母相同时，后一个字母需要连续转换2次。例如：aa 转换为 bc，zz 转换为 ab； 当连续相同字母超过两个时，第三个出现的字母按第一次出现算。 要求实现函数： void convert(char *input,char* output) 【输入】 char *input , 输入的字符串 【输出】 char *output ，输出的字符串 【返回】 无 示例 输入：char*input="abcd" 输出：char*output="bcde" 输入：char*input="abbbcd" 输出：char*output="bcdcde" 3*/ void convert(char *input,char* output) { int i=0; int j=0; int k=0; int temp=1; while(input[j++]!=' ') { if(input[i-1]!=input[i]) output[k++]=input[i++]+1; else { temp++; if(temp==3) output[k++]=input[i++]+1; else output[k++]=input[i++]+2; } } } /*2 字符串处理转换 问题描述： 在给定字符串中找出单词（ “单词”由大写字母和小写字母字符构成，其他非字母字符视为单词的间隔， 如空格、问号、数字等等；另外单个字母不算单词）；找到单词后，按照长度进行降序排序， （排序时如果长度相同，则按出现的顺序进行排列），然后输出到一个新的字符串中； 如果某个单词重复出现多次，则只输出一次；如果整个输入的字符串中没有找到单词，请输出空串。 输出的单词之间使用一个“空格”隔开，最后一个单词后不加空格。 要求实现函数： void my_word(charinput[], char output[]) 【输入】 char input[], 输入的字符串 【输出】 char output[]，输出的字符串 【返回】 无 示例 输入：charinput[]="some local buses, some1234123drivers" ， 输出：charoutput[]="drivers local buses some" 输入：charinput[]="%A^123 t 3453i*()" ， 输出：charoutput[]=""*/ void my_word(char input[], char output[]) { int i=0; int j=0; int len=0; int k=0; int s=0; int m=0; while(input[len++]!=' '); cout<<len<<endl; char *tstr=new char[len]; while(input[j]!=' ') { s=0; for(i=j;i<len-1;) { if((input[i]>='a'&&input[i]<='z')||(input[i]>='A'&&input[i]<='Z')) { tstr[s++]=input[i++]; } else { i++; break; } } if (s>1) { for(k=0;k<s;k++) output[m++]=tstr[k]; output[m++]=' '; } j=i; } //cout<<j<<endl; delete [] tstr; } /*【功能】：判断给定的一个数iNumber是否是一个素数 【输入】：一个整型数 iNumber 【输出】：0：不是素数 1：是素数 */ int isPrimNumber(int iNumber) { if(iNumber == 1) return 0; if(iNumber == 2) return 1; for(int i = 2; i <= sqrt((double)iNumber); ++ i) { if(iNumber % i == 0) return 0; } return 1; } /* 【功能】：找出一个数组iArray[]中大于等于平均值的元素个数 【输入】：数组iArray, 数组的元素个数nSize 【输出】：大于等于平均值的元素个数cnt */ int func(int iArray[],int nSize) { int i=0; int num=0; double Array=0; int cnt=0; for(i=0;i<nSize;i++) num+=iArray[i]; Array=num*1.0/nSize; for(i=0;i<nSize;i++) if(iArray[i]>=Array) cnt++; return cnt; } /* 【功能】：判断一个数是否回文数，如果1221，232， 3; 【输入】：一个整型数iNumber 【输出】：0: iNumber不是回文数 1：iNumber是回文数 */ int isPlalindromeNumber(int iNumber) { int src = iNumber; int des = 0; while(src) { des = des * 10 + src % 10; src /= 10; } if(des != iNumber) return 0; return 1; } /* 【功能】：求解出特定数iNumber之内的所有素数,将这些素数存入一个数组primNumber[]中 【输入】：特定的数iNumber */ void getPrim(int iNumber) { int primNumber[100]={2,3,5}; int trial=5; int count=3; do { int found=0; trial+=2; for(int i=0;i<count;i++) { found=(trial%(primNumber[i]))==0; if(found) break; } if(!found) primNumber[count++]=trial; }while(trial<iNumber); int n=0; for(int i=0;i<count;i++) { cout<<setw(10)<<*(primNumber+i); n++; if(n==5) { n=0; cout<<endl; } } } int func(int x) { int countx =0; while(x) { countx ++; x = x&(x-1); } return countx; } /***********************************三种简单排序方法************************************************** 直接插入排序 稳定 冒泡排序 稳定 直接选择排序 不稳定 时间复杂度均为O(n方) 空间复杂度O(1) 稳定算法：两个相等的关键字若排序前后位置不变则稳定 直接插入排序，也是分成两个序列，待排序列和已排好序列，每次从待排序列里去一个数，将其插入到已排好序列中 显然，只要最后的一个数每排好，所有已排好序列数的位置都有可能会变动。 先把当前待拍元素保存起来，用j来循环已排好序列，找到插入位置，这个寻找过程就是不断移动元素的过程 input[j + 1] = input[j]; input[j] = temp; 直接插入排序适合原始数据基本有序且长度较小的情况下 */ void InsertionSort(int input[],int len) { int i,j,temp; for (i = 1; i < len; i++) { temp = input[i]; /* 操作当前元素，先保存在其它变量中 */ for (j = i - 1;j>-1&&input[j] > temp ; j--) /* 从当前元素的上一个元素开始查找合适的位置 */ { input[j + 1] = input[j]; /* 一边找一边移动元素 */ input[j] = temp; } } } /*直接选择算法的思想是将数列分成两部分，一部分是待排序列，一部分是已经拍好的序列 显然，一开始已经排好的序列只有第一个元素，每次从待排序列里选一个最小的跟已经排好的序列最大的交换 对于已排好序列是不会发生改变的除了最后一个元素。 直接选择算法时间复杂度为O(n方)，空间复杂度O(1)。他是一个不稳定的算法 */ void SelectSort(int input[],int len) { int i=0;//第一层循环,i永远表示已排好序列的最后一个元素 int j=0;//第二层循环，j永远表示待排序列的第一个元素 int temp=0;//中间变量 for(i=0;i<len;i++) for(j=i+1;j<len;j++) if(input[i]>input[j]) { temp=input[j]; input[j]=input[i]; input[i]=temp; } } /* 冒泡排序 每轮沉淀一个最大的数到最后，在最好的情况下冒泡排序和直接插入排序是最快的。 */ void BubleSort(int input[],int len) { int i=0;//第一层循环 int j=0;//第二层循环 int temp=0;//中间变量 for(int i=0;i<len;i++) { for(int j=0;j<len-i-1;j++) { if(input[j]>input[j+1]) { temp=input[j]; input[j]=input[j+1]; input[j+1]=temp; } } } } /*快速排序 快速排序适合原始数据杂乱无章,n较大且对稳定性没有要求的情况，平均情况下，快速排序最快，时间复杂度 O(nlogn),空间复杂度为O(logn) */ int partition(int input[],int low,int high) { int pivotey=input[low]; low=low+1; while(low<high) { while(low<high&&input[high>=pivotey])--high; input[low]=input[high]; while(low<high&&input[low]<=pivotey)++low; input[high]=input[low]; } input[low]=pivotey; return low; } void Qsort(int input[],int low,int high) { int pivoloc=0; if(low<high) { pivoloc=partition(input,low,high); Qsort(input,low,pivoloc-1); Qsort(input,pivoloc+1,high); } } //编程实现字符串到整数的转换函数 int parseInt(char *str,int radix) { int i=0; int j=0; //首先判断他是不是一个合法的整数 int len=strlen(str); while(i<len) if((*(str+i)>=48)&&(*(str+i)<=57)||(*(str+i)>=65)&&(*(str+i)<=90)||(*(str+i)>=97)&&(*(str+i)<=122)) i++; else break; try { if(i<len||len==0) throw "整数不合法"; } catch(const char aMessage()) { cout<<endl<<aMessage<<endl; } //字符转换 int temp=0; int num=0; j=len; int k=0; cout<<str<<endl; while(j>=0) { if((*(str+k)>=65)&&(*(str+k)<=90)) temp=*(str+k)-54; if((*(str+k)>=97)&&(*(str+k)<=122)) temp=*(str+k)-86; if((*(str+k)>=48)&&(*(str+k)<=57)) temp=*(str+k)-48; num+=(int)temp*pow((double)radix,(int)j-1); j--; k++; } try { if(!(num>=-32768||num<=32767)) throw "整数越界"; } catch(const char aMessage()) { cout<<endl<<aMessage<<endl; } return num; } //笼子里有鸡和兔子，共100条腿，问鸡有多少，兔子有多少，有多少可能性 int lag(int num) { int chken=0; int rubb=0; int k=0; int snum=0; while(chken<=(num/2)) { k=(num-chken*2)%4; rubb=(num-chken*2)/4; if(k==0) { cout<<"鸡的数目为"<<chken<<" "<<" 鸭的数目为"<<rubb<<endl; snum++; } chken++; } cout<<"总可能性为"<<snum<<endl; return 1; } //********单链表的的问题*********************** //定义一个链表节点 //单向链表节点 struct node { int data; node *next; }Node; //双向链表节点 struct dnode { int data; dnode *left; dnode *right; }Dnode; //创建并初始化单链表 struct node * Initlist(int n) { node *head; head=(node*)malloc(sizeof(node)); head->next=NULL; head->data=0; node *p=head; int data=0; int i=0; while(i<n) { node *L; L=(node*)malloc(sizeof(node)); cin>>data; p->next=L; L->data=data; p=L; i++; } p->next=NULL; return head; } //单链表输出 void puts(struct node *head) { node * p=NULL; for(p=head->next;p!=NULL;p=p->next) cout<<p->data<<" "; cout<<endl; } //单链表就地逆置 //思路很简单就是 用三个变量，P用来循环节点，r用来控制最后一个节点被连接上，q是最重要的中间节点。 void Reverselist(struct node *head) { node *p=head->next; node *q=NULL; node *r=NULL; while(p) { r=q; q=p; p=p->next; q->next=r; } head->next=q; } //带尾指针的循环单链表，有很多好处，其中之一就是找最后一个元素的时候不需要遍历整个链表，但凡涉及到不需要遍历的 //尽量考虑尾指针单链表的情况。 //两个链表A，B有序，合并成一个依然有序的单链表C，注意不要增加空间复杂度 int mubble(node *ListA,node *ListB) { node *p=NULL; p=ListA->next; node *q=NULL; q=ListB->next; node *c=NULL; while(p->next!=NULL&&q!=NULL) { while(p->data<=q->data&p!=NULL) { c=p; if(p->next!=NULL) p=p->next; } c->next=q; while(q->data<=p->data&&q!=NULL) { c=q; if(q->next!=NULL) q=q->next; } c->next=p; } c->next=q; return 1; } //编写string类的构造函数、析构函数、赋值 class String { public: String(const char *str=NULL); String(const String &other); ~String(); String & operator =( const String &other); private: char *data; }; String::String(const String &other) { int len=strlen(other.data); data=new char(len+1); strcpy(data,other.data); } String::~String() { delete [] data; } String & String::operator =( const String &other) { if(this == &other) return *this; delete [] data; int length = strlen(other.data); data = new char[length+1]; strcpy(data, other.data); return *this; } void main() { // char instr[]="ppddsdpp"; // char neinstr[]="5 - 15"; // int n=sizeof(instr); //char outstr[100]={ }; //char aa[]="hello"; //char cstr[]="a3c3hello212my221dd22www"; //stringFilter(instr,n,outstr); //stringZip(instr,n,outstr); //arithmetic(neinstr,n,outstr); //cout<<aa<<endl; //cout<<outstr<<endl; //cout<<noutstr<<endl; //convert(cstr,outstr); //my_word(cstr,outstr); //cout<<outstr<<endl; /*int a=121; bool f=isPrimNumber(a); if(f) cout<<"这是一个素数"<<endl; else cout<<"这不是一个素数"<<endl;*/ /*int ary[6]={4,4,21,1,2,23}; int k=func(ary,6); cout<<k;*/ /*int i=12344221; bool f=isPlalindromeNumber(i); if(f) cout<<"这是一个回文"<<endl; else cout<<"这不是一个回文"<<endl; getPrim(100); */ //int a=230; //cout<<func(a)<<endl; //int a[10]={2,34,5,22,212,32,43,12,9,12}; //InsertionSort(a,10); //SelectSort(a,10); //BubleSort(a,10); //Qsort(a,0,9); //for(int i=0;i<10;i++) // cout<<a[i]<<" "; /*int b=5; int * const p=&b; int a=12; int * const r=&b; const int * p=&a; int k=6; //p=&k; b=k; cout<<b<<endl;*/ //char *ss="hello"; //int p=sizeof(ss); //int q=strlen(ss); //cout<<p<<q; //int a=0; //char b='a'; //char str[]="1000"; //int k=parseInt(str,2); //cout<<k; //lag(100); struct node * L1=Initlist(5); struct node * L2=Initlist(7); puts(L1); puts(L2); mubble(L1,L2); //Reverselist(L1); puts(L1); system("pause"); }