liuhuiyan_2014的专栏

main.h 1 #pragma once 2 #include 3 #include 4 #include 5 using namespace std; 6 extern "C" void Covenment(FILE * fileout,FILE *filein); 7 enum sg 8 { 9 NOO,//一般状态 10

main.h1 #pragma once 2 #include 3 #include 4 using namespace std; 5 int GET(int const &a,char const &ch,int const &b); 6 template//用模板，因为我要使用一个字符栈，保存运算符号，一个数字栈，保存要计算的数字。 7 class Stack

关于运算符号的重载问题，各种运算符号重载的实现。

#include 2 using namespace std; 3 int main() 4 { 5 //比如说你要求将一个数值直接用十六进制表示出来. 6 unsigned long a; 7 int i=0; 8 char str[8]={0}; 9 str[8]='\0'; 10 cout<<"请输入这个数字:"<<endl; 11

#include #include #include #include #define DefaultSize 7using namespace std;struct Node{ char *pname;//文件名字 int line;//行号 int size;//大小 long long save;//存储地址ip Node *next;};struct Hash

#include #define DefaultSize 10using namespace std;templateclass Grail{ public: Grail() { data = new T[DefaultSize]; for(int i=0;i<10;i++) { data[i]=i; } } const T& operator[](

#include #include #define DefaultSize 10using namespace std;enum KindOfStatus{Active,Empty,Deleted};templateclass HashTable{public: HashTable(int d,int sz=DefaultSize) { _D = d; Ta

#include #include using namespace std;struct SchoolNo{ int no; friend bool operator == (const SchoolNo &school1,const SchoolNo &school2) { return (school1.no==school2.no); }friend ostrea

#include #include using namespace std;#define SIZE 10#define NULL_DATA -1class Node{ public: Node(int x=SIZE) { data = new int[x]; for(int i=0;i<x;i++) { data[i] = NULL_DATA; } }

//合并排序#include #include using namespace std;void sort(int c[],int a[],int b[],int n){ int i=0; int j=0;//a int k=0;//b while(k!=5 && j!=5) { if(a[j]>b[k]) { c[i++]=b[k++]; }

#include #include #include using namespace std;void Grial(int _N){ int count=0; vector ar; ar.push_back(2); int _A=0;//统计循环次数。 int _K; int _I; for(_I=3;_I<=_N;_I+=2) { for(_K=3;_K<_I;_

#include #include #include using namespace std;int main(){ int count = 0; while(malloc(1204*1204)) { count++; } cout<<count<<endl; cout<<(count/1024)<<"G"<<endl; return 0;}我的总内存是4G，

#include using namespace std;struct Node{ int data; Node * next; Node(int x=0):data(x),next(NULL){}};class List{ public: List() { first = new Node(); } void Insert(int x) {

#include using namespace std;int Grail(int x){ int N=0; for(;x!=0;x>>=4)//一次左移4位。 { N+="\0\1\1\2\1\2\2\3\1\2\2\3\2\3\3\4"[x&0xf]; } return N;}int main(){ cout<<Grail(15)<<endl;}

#include using namespace std;int Grail(int x){ int N=0; while(x) { x=x&(x-1); N++; } return N;}int main(){ cout<<Grail(7)<<endl; //0111 //0110 //0101 //0100 //0100 //0011 ret

#include#includeusing namespace std;templateclass MinHeap{public: MinHeap(int sz=DefaultSize) { capacity = sz>DefaultSize?sz:DefaultSize; heap = new Type[capacity]; size = 0; } MinHea

#include #define _SZ 10using namespace std;templateclass Grial{ public: Grial(_Ty *_P,int _X=_SZ) { _SP=_X; data = new _Ty[_SP]; for(int _I=0;_I<_SP;_I++) { data[_I]=_P[_I]; }

#include using namespace std;class Grail{ public: virtual void _A() { cout<<"Grail::_A()"<<endl; } virtual void _B() { cout<<"Grail::_B()"<<endl; } virtual void _C() { cout<<"Grail:

#include using namespace std;void Grial(int a[],int x,int y){ if(x>=y)return ; int i=x; int j=y; int temp; int key=a[(i+j)/2]; while(i<j) { while(a[i]<key)i++;//找到第一个比key大的数 while(a[j]>k

#include #include #define CHAR_BIT 8using namespace std;templateclass bitset{ typedef unsigned long _Ty; friend ostream & operator &_R) { for(size_t _P=_N;_P>0;) _O<<(_R.test(--_P)?'1

main.h:#include #include #define DefaultSize 10#define maxWeight -1using namespace std;templatestruct Edge{ int dest; E cost; Edge *link; Edge(int d=0,int c=0):dest(d),cost(c),link(NUL

#include using namespace std;void swap(int *a,int *b){ int temp = *a; *a = *b; *b = temp;}void Grial(int a[],int x,int y){ int i=x-1; int j=x; int key = a[y]; if(x>=y)return ; while(j<y

#include using namespace std;templatestruct Node{ T data; Node *next; Node():next(NULL){}};templateclass List{ public: List() { head = new Node(); } void Insert(T x) { Node *s =

#include #include using namespace std;int sum(int a,int b){ return (rand()%(b-a)+a+1);}void Grial(int a[],int x,int y){ if(x>=y)return ; int i=x; int j=y; int temp; int b=sum(i,j);//求取随机值

#include using namespace std;templateclass Node{ public: Node(_Ty _X=_Ty()):_Data(_X),_Next(NULL){} int _Data; Node *_Next;};templateclass List{ public: List() { _First = new Node()

//将字符串反转，型如:123 456 789 abc ，反转后的结果是 abc 789 456 123/*#include #include using namespace std;void Exchange(char *&str){ char *p=str+strlen(str)-1; char *q=str; while(q<p) { char temp=*q;

#include #include #include using namespace std;templatestruct BinTreeNode{ T data; BinTreeNode *leftchild; BinTreeNode *rightchild; BinTreeNode(T x=T()):data(x),leftchild(NULL),rightchild(NU

#include //n!的求解using namespace std;int Giral(int n){ (n>2) && (n*=Giral(n-1));//这里不能写n>0，因为n=0时会返回0，将乘式的结果会化成0，n>2比n>1要少一次，效率要高一些. return n;}int main(){ cout<<Giral(4)<<endl;}#include

无论何时何地都不要去问别人问题，如果是和别人讨论就除外，因为当你从一个问题开始思考的时候，这就收获是无法言语的，时间一长，你就会发现，你学什么都会了，学什么都容易了，如果你一有问题就去问别人的话，时间一长，你自己做的事情或者解决的问题，你都不能确定是不是正确的，所以你又要去问别人，如此恶性循环，是一个it猿的悲剧，因为他总是很努力，却总是也无法提高，要想提高自己，就必须每问必问问自己，最后

/*#include using namespace std;//2014!里面0的个数.int Giral(int x){ int i=0; int j=0; while(x) { int sum = x; if(x%2==0) { while(x%2==0) { x/=2; i++; } } if(x%5==0)

#/bin/bash#对文本里面的数据进行排序awk 'BEGIN{ RS=","}{print $0}END{}'<a | sort -n | sed '/^$/ d' | awk 'BEGIN{ RS="\n";ORS=","}{print $0}END{}'|sed 's/,$//g'下面是c++版本的。---------------------------

#include using namespace std;//输入一个已经按升序排序过的数组和一个数字，//在数组中查找两个数，使得它们的和正好是输入的那个数字。//要求时间复杂度是O(n)。如果有多对数字的和等于输入的数字，输出任意一对即可。//例如输入数组1、2、4、7、11、15和数字15。由于4+11=15，因此输出4和11。void Grial(int a[],int x,i

//输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。//我的思路是2个指针往后面找，你想啊，如果是一个指针，肯定需要遍历2次，第一个遍历总共节点数，第二次才遍历最终结果//这样的做法明显是不够好的，时间复杂度变成了2n，但是如果我们用2个指针，他们之间的距离差k个节点，有一个节点到达NULL//时(尾部)，另一个节点就是我们要求的节点可以返回得到结果.#

//把数组排成最大的数（数组、算法）。//题目：输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最大的一个。//例如输入数组{32, 321}，则输出这两个能排成的最大数字32321.。//或者输入数组{10,9,33,1000}输出这四个能排列的最大数字933101000.#include #define MAXSIZE 100using namespace s

#include #define DefaultSize 9using namespace std;class Grial{ public: Grial(int sz=DefaultSize) { visted = new bool [sz]; data = new int [sz]; size = sz; for(int i=1;i<=sz;i++) {

#include #include using namespace std;//数组中超过出现次数超过一半的数字（数组）//题目：数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字。templateint Grial(bitset &bt,int a[]){ int check[_N]; for(int i=1;i<=_N;i++) { int count = 0

#include #define DefaultSize 9//问题描述://12个高矮不同的人,排成两排,每排必须是从矮到高排列,而且第二排比对应的第一排的人高,问排列方式有多少种?using namespace std;class Grial{ public: Grial(int sz=DefaultSize) { visted = new bool [sz]; da

#include #include #define SIZE 10#define MAXVALUE 0x7fffffffusing namespace std;//题目是:求一个字符串中最小字串.//求最小字串，比求最大字串难的多，下面有我的求最大字串代码,我没有想到更好的方法，下面的这个方法虽然空间复杂度太大，可是时间复杂度是比较快的。templatestruct Node{

#include <iostream>using namespace std;struct Node{ int val; struct Node *next; Node(int x = int()):val(x),next(NULL){}};struct List{ List() { head=NULL; } void

#include using namespace std;//指定一个位置开始，然后每隔k个位置剔除一个元素，输出最后剩余的元素。//相当于所有数据绕成一圈，按k个位置长度剔除数据，当只剩一个时，游戏结束，得到结果.int Grial(int a[],int end,int start,int k){ int n = end; int i = start; while(n>1)