//
// main.cpp
// proj1
//
// Created by Yuxin Kang on 8/24/14.
// Copyright (c) 2014 Yuxin Kang. All rights reserved.
// #include <iostream>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std; //for cin and cout //==================cin & cout ===================
/*
int main(int argc, const char * argv[])
{
int x;
// insert code here...
std::cout << "Hello, World!!\n";
std::cout << "Please enter x\n";
std::cin >> x;
if (cin.fail()){
cout << "Bad input\n";
return 0;
}
std::cout << "you have entered the number of "<<x<<"\n";
return 0;
}
*/
//==================================================== ///==============memset================================ // int main(int argc, const char * argv[])
// {
// char str[] = "almost every programmer should know memset";
// memset (str,'-',6);
// puts (str);
// return 0;
// }
//===================================================== //==============ASCII_cout=============================
// int main(int argc, const char * argv[])
// {
// string s="09aZ i am kang ";
// for(int i=0;i< 5; ++i){
// int v = (int)s[i];
// cout << v <<"\n" ;
// }
//
// for (int i=1 ;i< 128;i++)
// {
// cout<<i<<"=="<<(char)i<<"\n";
// }
// }
//=================================================== //===================================================
//1. 1 Implement an algorithm to determine if a string has all unique characters What if you can not use additional data structures?
// int main(int argc, const char * argv[])
// {
// string s1= "czc";
// int check = 0;
// int len = s1.length();
// for(int i=0;i<len;i++)
// {
// int v= (int)(s1[i]-'a');
// int s=check & (1<<v);
// if(s)
// {
// cout << " \n bad [1<<v] ="<<(1<<v)<<"(check & (1<<v))="<<(check & (1<<v));
// cout <<"\n duplicate char ,no."<<i <<"and check now is "<<check;
// return false;
// }
// else
// {
// cout << "\n check="<<check;
// cout << " [1<<v] ="<<(1<<v)
// << " (check & (1<<v))="<<(check & (1<<v));
// check |=(1<<v);
// cout << "then check="<<check;
// }
//
// }
// return true;
// }
//===================================================== //===========================================================
//1 2 Write code to reverse a C-Style String (C-String means that “abcd” is represented as five characters, including the null character )
//
//void swap3(char&a,char&b)
//{
// a=a^b;
// b=a^b;
// a=a^b;
//}
//
//void reverse(char* str)
//{
// char* end= str;
// //char temp;
// while(*end)
// {
// end++;
// }
// end--;
// while(str<end)
// {
//// temp=*str;
//// *str++ =*end;//把*end 的值给*str然后指针后移一位
//// *end-- =temp;
// //swap(*str++,*end--);//调用了内部函数==
// swap3(*str++,*end--);
//
// }
//}
//
//int main(int argc, const char * argv[])
//{
// char s[]="123456";
// reverse(s);
// cout<<s;
//}
//=============================================================================== //=====1 3===Design an algorithm and write code to remove the duplicate characters in a string without using any additional buffer NOTE: One or two additional variables are fine An extra copy of the array is not
//P指向开始重复的字母,依次检查后面不重复的字母,将后面不重复的cover前面重复的字母
// 不重复|重复的----加\0截断
//void removeDuplicate(char s[])
//{
// cout<<"add :"<<(void*)&s[0]<<"\n";//强制输出第一个值的地址
// cout<<"add= :"<<&s<<"\n";
// cout<<"add_ :"<<(void*)&s<<"\n"; //地址的地址 :指针的地址
// int len = strlen(s);
// if(len<2) return;
// int check =0,p=0;
// for(int i=0; i<len; ++i)
// {
// int v=(int)(s[i]-'a');
// if((check&(1<<v))==0)
// {
// s[p++] = s[i];
// check |= (1<<v);
// // cout<<s<<"==== \n";
// }
// //cout<<s<<"\n";
// }
// s[p]='\0';
//
//}
//
//
//string removeDuplicate1(string s) //check检查,不重复的加到str上
//{
// int check =0;
// int len = s.length();
// if(len<2) return s;
// string str = "";
// for(int i=0; i<len; ++i)
// {
// int v = (int)(s[i]-'a');
// if((check&(1<<v))==0)
// {
// str+= s[i];
// check |=(1<<v);
// }
// }
// return str;
//
//}
//
//string removeDuplicate2(string s) //循环两个指针 i,j j指在后面寻找不一样的,加到str上
//{
// int len= s.length();
// if(len<2) return s;
// string str="";
// for(int i=0;i<len;++i)
// {
// if(s[i]!='\0')
// {
// str+=s[i];
// for(int j=i+1;j<len;++j)
// {
// if(s[i]==s[j])
// s[j]='\0';
// }
// }
// }
// return str;
//}
//
//void removeDuplicate3( char s [])
//{
// int len = strlen(s);
// if (len<2) return;
// bool c[256];
// memset(c,0,sizeof(c));
// int p =0;
// for(int i=0; i<len; ++i)
// {
// if(!c[s[i]]) //s[i]之前不存在
// {
// s[p++]=s[i];
// c[s[i]] = true;
// }
// }
//}
//
//int main()
//{
// char s[]="ababababdfcZZ";
// cout<<"add2 :"<<&s<<"\n";
// cout<<"add2_:"<<&s<<"\n";
// removeDuplicate(s);
// cout<<"add3:"<<&s<<"\n";
// cout<<"final--"<<s;
// char s1[]="ababababdfcZZ";
// string s2="ababababdfcZZ";
// removeDuplicate1(s2);
// cout<<"\n[go string]:\n(1)"<<removeDuplicate1(s1)
// <<"\n"<<removeDuplicate1(s2)
// <<"\n(2)"<<removeDuplicate2(s2);
//
//
// // cout<<"\n***abc\0dd"; //'\0后面截断'
//
//}
//=========================================================================== //=======1 4 Write a method to decide if two strings are anagrams or not========= //bool isAnagram(string s, string t)
//{
// sort(&s[0],&s[0]+s.length());
// sort(&t[0],&t[0]+t.length());
// if(s==t) return true;
// else return false;
//}
//
//bool isAnagram1(string s, string t)
//{
// if(s==""||t=="") return false;
// if(s.length() !=t.length()) return false;
// int len = (int)s.length();
// int c[256];
// memset(c,0,sizeof(c));
// for(int i=0;i<len;++i)
// {
// ++c[(int)s[i]];
// --c[(int)t[i]];
// }
// for(int i=0; i<256; ++i)
// if(c[i]!=0)
// return false;
// return true;
//}
//int main()
//{
// char s[]="AZaaabbbc";
// char t[]="AZabaabbc";
// cout<<isAnagram1(s,t);
//
//}
//
//
//
//
// //1 5 Write a method to replace all spaces in a string with ‘%20’
//先计算空格总数 新的数组长度=原来数组长+2*空格数
//char* replace1(char *c) //返回指向char的指针 char*
//{
// int len= (int)strlen(c);
// int cnt=0; // space num
// for(int i=0;i<len;++i)
// {
// if(c[i]==' ')
// ++cnt;
// }
// char * newString = new char[len+cnt*2];
// int p=0;
// for(int i=0;i<len;++i)
// {
// if(c[i]!=' ')
// {
// newString[p]=c[i];
// p++;
// }
// else
// {
// newString[p]='%';
// newString[p+1]='2';
// newString[p+2]='0';
// p+=3;
// }
// newString[p]='\0';
// }
// //cout<<newString;
// return newString;
//}
//int main()
//{
// const int len =10;
// char c[len]=" ab c";
// cout<<replace1(c);
//
//} //1 6 Given an image represented by an NxN matrix, where each pixel in the image is 4 bytes, write a method to rotate the image by 90 degrees Can you do this in place? //void rotate(int matrix[][4],int n)
//{
// for(int layer=0;layer<n/2;layer++) //管第几层旋转
// {
// int first = layer; //每层起始点
// int last = n - layer -1; //每层长度
// //0,3 1,2
// for(int j=first;j<last;j++) //matrix[纵坐标(向下增大)][横坐标(右增大) ]
// {
// int offset=j-first;
// int top=matrix[first][j];
// //left->top
// matrix[first][j]=matrix[last-offset][first];
// //bottom->left
// matrix[last-offset][first]=matrix[last][last-offset];
// //right->bottem
// matrix[last][last-offset]=matrix[j][last];
// //top->right
// matrix[j][last] = top;
//
// }
//
// }
//}
//
//void transpose(int a[][4], int n){
// for(int i=0; i<n; ++i) //先对角线互换
// for(int j=i+1; j<n; ++j)
// swap(a[i][j], a[j][i]);
// for(int i=0; i<n/2; ++i) //再上下换(1,4行,2,3行)
// for(int j=0; j<n; ++j)
// swap(a[i][j], a[n-1-i][j]);
//}
////1 2 3 4
////5 6 7 8
////9 10 11 12
////13 14 15 16
////
////1 5 9 13
////2 6 10 14
////3 7 11 15
////4 8 12 16
////
////4 8 12 16
////3 7 11 15
////2 6 10 14
////1 5 9 13
//
//int main(){
// int a[4][4] = {
// {1, 2, 3, 4},
// {5, 6, 7, 8},
// {9, 10, 11, 12},
// {13, 14, 15, 16}
// };
// for(int i=0; i<4; ++i){
// for(int j=0; j<4; ++j)
// cout<<a[i][j]<<" ";
// cout<<endl;
// }
// cout<<endl;
// //rotate(a, 4);
// transpose(a,4);
// for(int i=0; i<4; ++i){
// for(int j=0; j<4; ++j)
// cout<<a[i][j]<<" ";
// cout<<endl;
// }
// return 0;
//}
//
//
//1 7 Write an algorithm such that if an element in an MxN matrix is 0, its entire row and column is set to 0 //void zero(int **a, int m, int n)
//{
// bool row[m],col[n]; //用两个一纬数组 代表行列
// memset(row,false,sizeof(row));
// memset(col,false,sizeof(col));
// for(int i=0;i<m;i++)
// for(int j=0;j<n;j++)
// if(a[i][j]==0)
// {
// row[i]=true;
// col[j]=true;
// }
// for(int i=0;i<m;i++)
// for(int j=0; j<n;j++)
// if(row[i]||col[j]) // ||代表整行或者正列
// a[i][j]=0;
//}
//
//int main()
//{
// int m,n;
// cout<<"please enter the size of array:\n";
// cin>>m>>n;
// int **a;
// a=new int*[m];
// for(int i=0;i<m;++i)
// a[i]= new int[n]; //依次存 n大小的数组
// for(int i=0;i<m;i++)
// for(int j=0;j<n;j++)
// cin>>a[i][j];
// for(int i=0;i<m;i++)
// {
// for(int j=0;j<n;j++)
// {
// cout<<a[i][j]<<" ";
// }
// cout<<endl<<"\n";//same like cout<<"\n";
// }
//
//
//// a——》
//// ||指针1---》数组1
//// ||指针2---》数组2
//// ||指针3---》数组3
//
// zero(a,m,n);
// for(int i=0;i<m;i++)
// {
// for(int j=0;j<n;j++)
// {
// cout<<a[i][j]<<" ";
// }
// cout<<endl;//same like cout<<"\n";
// }
//
//} //1 8 Assume you have a method isSubstring which checks if one word is a substring of another Given two strings,s1 and s2,write code to check if s2 is a rotation of s1 using only one call to isSubstring (i e , “waterbottle” is a rotation of “erbottlewat”) //bool isSubstring(string s1, string s2)
//{
// if(s1.find(s2)!=string::npos) return true; //As a return value, it is usually used to indicate no matches.
// return false;
//}
//
//bool isRotation(string s1, string s2)
//{
// if(s1.length()!=s2.length())
// return false;
// return isSubstring(s1+s1,s2);
//}
// int main()
//{
// string a = "apple";
// string b = "pleap";
// cout<<isRotation(a,b)<<endl;
//
//} //2 1 Write code to remove duplicates from an unsorted linked list FOLLOW UP How would you solve this problem if a temporary buffer is not allowed? //
//typedef struct node
//{
// int data;
// node *next;
//}node;
//bool hash1[100];
//
//node* init(int a[],int n)
//{
// node *head , *p; //p:previous
// for(int i=0;i<n;i++)
// {
// node *nd= new node();
// nd->data=a[i];
// if(i==0)
// {
// head=p=nd; //p指向第一个节点 相当于创建了节点nd,装入p节点中
// continue;
// }
// p->next=nd;
// p=nd;
// }
// return head;
//}
//
//void removeduplicate(node *head)
//{
// if(head==NULL) return ;
// node *p=head, *q=head->next;
// hash1[head->data]=true; //因为数组坐标是唯一的 将head的值去占位,表示已经存在
// while(q)
// {
// if(hash1[q->data]) //表示下一个节点(p)在hash数组里面寻找
// {
// //存在
// node *t=q; //待删除节点
// p->next=q->next;
// q=p->next;
// delete t;
// }
// else
// {
// //not exist ,move
// hash1[q->data]=true;
// p=q;
// q=q->next;
//
// }
// }
//}
//
//
//void removeduplicate2(node *head)
//{
// if(head==NULL) return;
// node *p,*q,*c=head; //定义三个指针,c指向当前要检测的节点,p和q两个负责分别往后去检测有没有和c相同的节点,然后进行删除
// while(c)
// {
// p=c;q=c->next;
// int curdata = c->data;
// while(q)
// {
// if(curdata==q->data)
// {
// node *t =q; //准备删除q
// p->next=q->next;
// q=p->next;
// }
// else
// {
// p=q;
// q=q->next;
// }
// }
// c=c->next;
// }
//
//}
//
//void print(node* head)
//{
// while(head)
// {
// cout<<head->data;
// head=head->next;
// }
//}
//
//int main()
//{
// int n=6;
// int a[]={3,2,2,1,4,1}; //里面的值去对应hash1数组的编号
// memset(hash1,false,sizeof(hash1));
// node *head=init(a, n);
// removeduplicate(head);
// print(head);
// return 0;
//}
// //typedef struct node
//{
// node* next;
// int data;
//}node;
//
//node* init(int a[], int n)
//{
// node* head,*p;
// for(int i=0;i<n;i++)
// {
// node* nd=new node(); //create node for list
// nd->data=a[i];
// if(i==0)
// {
// head=p=nd;
// continue;
// }
// p->next=nd;
// p=nd;
// }
// return head;
//}
//
//node* nthTolast(node* head,int n)
//{
// if(head==NULL||n<1)
// return NULL;
// node* p1=head;
// node* p2=head;
// for(int i=0;i<n-1;i++)
// {
// if(p2==NULL)
// return NULL;//总长度不够
// p2=p2->next;
// }
//
// while(p2->next!=NULL)
// {
// p1=p1->next;
// p2=p2->next;
// }
// return p1;
//}
//int main()
//{
// int n=10;
// int a[]={9,2,3,5,6,7,8,9,1,0};
// node* head = init(a, n);
// node *p=nthTolast(head, 5);
// if(p) cout<<p->data<<endl;
//} //2 3
//Implement an algorithm to delete a node in the middle of a single linked list, given only access to that node
//in the middle of 在。。。内部 //
//typedef struct node
//{
// node* next;
// int data;
//}node;
//
//node* init(int a[],int n)
//{
// node* head ,*p ;
// for(int i=0;i<n;i++)
// {
// node* nd=new node();//create node in the list
// nd->data=a[i];
// if(i==0)
// {
// head=p=nd;
// continue;
// }
// p->next=nd;
// p=nd;
// }
// return head;
//}
//
//bool remove(node* p)
//{
// if(p==NULL||p->next==NULL) return false;
// //删除节点
// node* t = p->next;
// p->next=t->next;
// delete t;
//
// return true;
//}
//
//void print (node* head)
//{
// while(head)
// {
// cout<<head->data;
// head=head->next;
// }
//}
//int main()
//{
// int a[]={9,2,3,5,6,7,8,9,1,0};
// //node* head=init(a,10);//第二个参数必须是变量;error
// int n=10;
// node*p,* head;
// head=p=init(a,n); //初始化数组到list中
// cout<<"please enter the number of nd in the list you want to delete";
// int m; //要删除第m个
// cin>>m;
// for (int i=1;i<m-1;i++)
// p=p->next; //p指针向后移动
// if(remove(p)&&m!=1)
// print(head);
// else
// cout<<"failure";
//
//}
// //2 4
//You have two numbers represented by a linked list, where each node contains a sin- gle digit The digits are stored in reverse order, such that the 1’s digit is at the head of the list Write a function that adds the two numbers and returns the sum as a linked list //typedef struct node
//{
// node* next;
// int data;
//}node;
//
//node* init(int a[] ,int n)
//{
//
// node* head,*p;
// for(int i=0;i<n;i++)
// {
// node* nd=new node();
// nd->data=a[i];
// if(i==0)
// {
// head=p=nd;
// continue;
// }
// p->next=nd;
// p=nd;
// }
// return head;
//}
//
//node* addlink(node*p,node*q)
//{
// if(p==NULL) return q;
// if(q==NULL) return p;
// node* head =NULL;//计算后结果保存的node的头指针 的存在意义是为了以后为了返回整个list
// node* cur = NULL;//current point 的存在意义是为了链接新生成的节点
// int c=0; //前面计算的进位
// while(p&&q)
// {
// node* r=new node();
// int t=(q->data)+(p->data);
// r->data=(c+t)%10;
// c=t/10;
// p=p->next;
// q=q->next;
// if(cur)
// {
// cur->next=r;
// cur=r;
// }
// else
// {
// head=cur=r;
// }
// }
//
// while(p)
// {
// int t= p->data+c;
// node* r = new node();
// r->data=t%10;
// c=t/10;
// cur->next=r;
// cur=r;
// p=p->next;
// }
// while(q)
// {
// int t= q->data+c;
// node* r = new node();
// r->data=t%10;
// c=t/10;
// cur->next=r;
// cur=r;
// q=q->next;
// }
// if(c>0)
// {
// node* r=new node();
// r->data=c;
// cur->next=r;
// }
//
// return head;
//}
//
//void print(node* head)
//{
// while(head)
// {
// cout<<head->data;
// head=head->next;
// }
// cout<<"\n";
//}
//int main()
//{
// int a[]={1,2,9,9,3};
// int b[]={9,9,2};
// int m=sizeof(a)/4;
// int n=sizeof(b)/4;
// node *p1,*p2,*res;
// p1=init(a,m);
// p2=init(b,n);
// print(p1);
// print(p2);
// res=addlink(p1,p2);
// print(res);
//} //2 5
//Given a circular linked list, implement an algorithm which returns node at the begin- ning of the loop //typedef struct node
//{
// node* next;
// int data;
//}node;
//
//node* init(int a[],int m,int n)
//{
// node* head,*p; //head负责回传头指针 p负责链接每个节点
// node* q;//负责指向环链接的开始
// for(int i=0;i<n;i++)
// {
// node* nd=new node();
// nd->data=a[i];
// if(i==0)
// {
// head=p=nd;
// continue;
// }
// if(i==m)
// {
// q=nd; //q负责指向环链接的开始
// }
// p->next=nd;
// p=nd;
// }
// p->next=q;
// return head;
//}
//
//
//void loopstart(node* head)
//{
// node* fast,*slow; //
// fast=slow=head;
// do
// {
// if(fast->next->next==NULL||slow->next==NULL)
// {
// break;
// // return 0;
// }
// fast=fast->next->next;
// slow=slow->next;
// }while(slow!=fast);
// slow=head;//slow回到起点
// while(slow!=fast)
// {
// fast=fast->next;
// slow=slow->next;
// }
// // return fast;
// cout<<"the starting point of the cycle is "<<fast->data<<endl;
//}
//
//int main()
//{
// int a[]={3, 2, 1, 3, 5, 6, 2, 6, 3, 1 };
// int m=7;
// int n=10;
// node* head=init(a,m,n);
// loopstart(head);
//} //3 1 Describe how you could use a single array to implement three stacks //typedef struct node
//{
// int val;//当前的值
// int preIdx;//前面的值的编号 这样每个node之后是以数组存储
//}node;
//class stack
//{
//public:
// stack(int totalSize=900) //第一次见
// {
// buf = new node[totalSize];
// ptop[0]=ptop[1]=ptop[1]=-1;
// this->totalSize=totalSize; //----->不理解
// cur=0;//当前第几个数组
// }
// ~stack()
// {
// delete []buf;
// }
//
// void push(int stackNum, int val) // 当前组,当前数字
// {
// buf[cur].val=val;
// buf[cur].preIdx=ptop[stackNum];
// ptop[stackNum]=cur; //保存最高点的-位置编号
// ++cur;
// }
//
// void pop(int stackNum)
// {
// ptop[stackNum]=buf[ptop[stackNum]].preIdx; //将指向顶部的编号指向前一个编号
// }
//
// int top(int stackNum)
// {
// return buf[ptop[stackNum]].val;
// }
//private: //stack的每个属性
// node *buf;
// int ptop[3]; //分三段 标记顶的值
// int totalSize;
// int cur;
//};
//
//
//int main()
//{
// stack mystack;
// for(int i=0;i<10;i++)
// mystack.push(0,i);
// for(int i=10;i<20;i++)
// mystack.push(1,i);
// for(int i=100;i<200;i++)
// mystack.push(2, i);
//
// for(int i=0;i<3;i++)
// {
// //cout<<mystack.ptop[i]; //错误‘ptop is a private memeber of stack’
// cout<<mystack.top(i)<<endl;
// }
//
// for(int i=0;i<3;i++) //pop
// {
// mystack.pop(i);
// cout<<mystack.top(i)<<endl;
// }
// mystack.push(0, 111);
// mystack.push(1, 222);
// mystack.push(2, 333);
//
// for(int i=0;i<3;i++)
// {
// //cout<<mystack.ptop[i]; //错误‘ptop is a private memeber of stack’
// cout<<mystack.top(i)<<endl;
// }
//
//}
// //3.2 How would you design a stack which, in addition to push and pop, also has a function min which returns the minimum element? Push, pop and min should all operate in O(1) time
//思路:节点数组,每个节点保存 节点的值 和当前最小值(进入后的最小值)
//const int MAX_INT = ~(1<<31);//2147483647
//
//typedef struct node
//{
// int val;
// int min; //push后整个arrary的当前最小值
//}node;
//
//class StackWithMin
//{
//public:
//
// StackWithMin(int size=1000)// size of this stack
// {
// //init
// buf=new node[size];
// cur=-1;
// buf[-1].min=MAX_INT;
// }
// void push(int val)
// {
// buf[++cur].val=val;
// if(val<buf[cur-1].min)
// buf[cur].min=val;
// else
// buf[cur].min=buf[cur-1].min;
// }
// void pop()
// {
// --cur;
// }
// int top()
// {
// return buf[cur].val;
// }
// int min()
// {
// return buf[cur].min;
// }
// void printStack()
// {
// for(int i=0;i<3;i++)
// cout<<"val:"<< buf[i].val <<" min" <<buf[i].min<<endl;
// }
//
//private: //外部不好直接访问
//
// node* buf; //该stack也是有数组组成,但是数组里存的是node
// int cur;//current point
//
//};
//
//class stack
//{
//public:
// stack(int size=1000) //stack的大小
// {
// buf=new int[size];
// cur=-1;
// }
// ~stack()
// {
// delete []buf;
// }
// void push(int val)
// {
// buf[++cur]=val;
// }
// void pop()
// {
// --cur;//当前指针往下
// }
// int top()
// {
// return buf[cur];
// }
// bool empty()
// {
// return cur==-1;
// }
//
//private:
// int* buf; //这个stack 每个节点需要由int组成,是个int数组
// int cur; //指向当前的指针
//};
//
//
//class StackWithMin1
//{
//public:
// StackWithMin1()
// {}
// ~StackWithMin1()
// {}
// void push(int val)
// {
// s.push(val);
// if(val<min())
// minStack.push(val);
// }
// void pop()
// {
// s.pop();
// if(s.top()==min())
// minStack.pop();
// }
// int top()
// {
// return s.top();
// }
// int min()
// {
// if(minStack.empty()) return MAX_INT; //这步骤很重要
// return minStack.top();
// }
//
//private:
// stack s;
// stack minStack; //存储最小值
//};
//int main()
//{
// StackWithMin1 mystack;
// mystack.push(3);
// mystack.push(100);
// mystack.push(34);
// cout<<"min:"<<mystack.min()<<" top:"<<mystack.top()<<endl;
// // mystack.printStack();
//
//
//}
// //============little test=======================
//int main()
//{
// int a[] = {1,2,3};
// for(int i=0;i<3;)
// cout<<a[++i]<<endl;
// int a[] = {1,2,3};
// for(int i=0;i<3;)
// cout<<a[i++]<<endl;
//}
//=============================================== //33 Imagine a (literal) stack of plates If the stack gets too high, it might topple There- fore, in real life, we would likely start a new stack when the previous stack exceeds some threshold Implement a data structure SetOfStacks that mimics this SetOf- Stacks should be composed of several stacks, and should create a new stack once the previous one exceeds capacity SetOfStacks push() and SetOfStacks pop() should behave identically to a single stack (that is, pop() should return the same values as it would if there were just a single stack) //const int STACK_SIZE = 100;
//const int STACK_NUM = 10;
//class stack
//{
//private:
// int *buf;
// int cur;
// int capacity;
//
//public:
// stack(int capa=STACK_SIZE)
// {
// buf=new int[capa]; //将stack扩充 由装有int的数组组成
// cur=-1;
// capacity=capa;
// }
// ~stack()
// {
// delete []buf;
// }
// void push(int val)
// {
// buf[++cur]=cur;
// }
// void pop()
// {
// --cur;
// }
// int top()
// {
// return buf[cur];
// }
// bool empty()
// {
// return cur==-1;
// }
// bool full()
// {
// return cur==capacity-1;
// }
//};
//
//
//class SetOfStack //new data structure
//{
//private:
// stack* st; //
// int cur;
// int capacity;
//public:
// SetOfStack(int capa=STACK_NUM)
// {
// st= new stack[capa]; //注意这里是由capa个stack组成的数组 每个stack最大是STACK_SIZE个int
// }
// ~SetOfStack()
// {
// delete []st;
// }
// void push(int val)
// {
// if(st[cur].full()) ++cur; //一个stack满了,就到下一个stack
// st[cur].push(val);
// }
// void pop()
// {
// if(st[cur].empty()) --cur;
// st[cur].pop();
// }
// int top()
// {
// if(st[cur].empty()) --cur;
// return st[cur].top();
// }
// int potAt(int idx)
// {
// if(st[idx].empty()) --idx;
// return st[idx].top();
// }
//
// bool empty()
// {
// if(cur==0) return st[0].empty();
// else return false;
// }
// bool full()
// {
// if(cur==capacity-1)return st[cur].full();
// else return false;
//
// }
//};
//
//int main()
//{
// SetOfStack sos;
// for(int i=0;i<3*STACK_SIZE+1;i++)
// {
// sos.push(i);
// }
//} //
//3 4
//In the classic problem of the Towers of Hanoi, you have 3 rods and N disks of different sizes which can slide on to any tower The puzzle starts with disks sorted in ascending order of size from top to bottom (e g , each disk sits on top of an even larger one) You have the following constraints:
//(A) Only one disk can be moved at a time
//(B) A disk is slid off the top of one rod onto the next rod
//(C) A disk can only be placed on top of a larger disk
//Write a program to move the disks from the first rod to the last using Stacks //先试2个,2个可以移动,
//再试试3个,先移动1个,然后剩下2个,2个之前已经证明可以移动了
//移动4个,先1个,3个已经证明可以了 //#include <stack>
//struct op{
// int begin, end;
// char start,buff,dest;
// op(){} //op(){}
// op(int pbegin,int pend, int pstart,int pbuff,int pdest):begin(pbegin), end(pend), start(pstart), buff(pbuff),dest(pdest){} //for struct init ,存放在stack里面
//};
//void haoni(int n, char start, char buff, char dest)
//{
// stack<op> st; //生成存放op的stack
// op temp;
// st.push(op(1,n,start,buff,dest));
// while (!st.empty())
// {
// temp=st.top();//获取stack中当前的op,开始就是main中输入的(A,B,C),输入进temp,然后循环获取top输入进temp
// st.pop();//指针向下移动,又从-1开始 ,前面的相当于不在了,只是输给temp
//
// if(temp.begin!=temp.end)
// {
// //初始化这个op再压入stack
// st.push(op(temp.begin,temp.end-1,temp.buff,temp.start,temp.dest));//递归完成从B柱->到c柱 (3步骤)
// st.push(op(temp.end,temp.end,temp.start,temp.buff,temp.dest));//Move disk 3 from A to C(2步骤)
// st.push(op(temp.begin,temp.end-1,temp.start,temp.dest,temp.buff));//递归完成从A柱->到B柱 (1步骤)
// }else
// {
// cout<<"Move disk "<<temp.begin<<" from "<<temp.start<<" to "<<temp.dest<<endl;
// }
// }
//}
//int main()
//{
// int n=3;
// haoni(n,'A','B','C');
// return 0;
//}
// //3.5Implement a MyQueue class which implements a queue using two stacks //#include <iostream>
//#include <stack>
//#include <queue>
//template<typename T>
//class MyStack
//{
//public:
// void push(T val)
// {
// qin.push(val);
// }
// void pop()
// {
// if(!qin.empty())
// move(qin, qout);
// else
// move(qout,qin);
// }
// T top()
// {
// if(qin.empty())
// {
// return qout.back();
// }
// else return qin.back();
// }
//
// void move(queue<T> &src, queue<T> &dest) //思想是不管从谁到谁,我只管我这个函数开始到目标,和输入无关
// {
// while(!src.empty())
// {
// T val= src.front();
// src.pop();
// if(src.empty()) break;
// dest.push(val);
//
// }
// }
// int size()
// {
// return qin.size()+qout.size();
// }
//
//private:
// queue<T> qin, qout;
//};
//
//
//
//template <typename T>
//class MyQueue
//{
//public:
// MyQueue()
// {
// }
// ~MyQueue()
// {
// }
// void push(T val)
// {
// sin.push(val);
// }
// void pop()
// {
// move(sin,sout);
// sout.pop();
//
// }
// T front()
// {
// move(sin,sout);
// return sout.top();
// }
// T back() //**和上面相反
// {
// move(sout,sin);
// return sin.top();
// }
// int size()
// {
// return sin.size()+sout.size();
// }
// bool empty()
// {
// return sin.empty()&&sout.empty();
// }
// void move(stack<T> &src,stack<T> &dest)
// {
// if(dest.empty())
// {
// while(!src.empty())
// {
// dest.push(src.top());
// src.pop();
// }
// }
// }
//
//private:
// stack<T> sin, sout;
//};
//
//int main()
//{
// MyStack<int> st;
// for(int i=0;i<10;i++)
// {
// st.push(i);
// }
// cout<<"stack top: "<<st.top()<<endl;
// st.pop();
// cout<<"stack top after pop "<<st.top()<<endl;
//
// MyQueue<int> q;
// for(int i=0;i<10;i++)
// {
// q.push(i);
// }
//
// cout<<"front: "<<q.front()<<" back: "<<q.back()<<endl;
// q.pop();
// q.push(10);
// cout<<"after pop and push,front: "<<q.front()<<" back "<<q.back()<<endl;
// cout<<"size: "<<q.size()<<" empty? "<<q.empty()<<endl;
//} //3 6 Write a program to sort a stack in ascending order You should not make any assump- tions about how the stack is implemented The following are the only functions that should be used to write this program: push | pop | peek | isEmpty
//great
//#include <stack>
//stack<int> sSort(stack<int> st)
//{
// stack<int> newSt;
// while (!st.empty()) {
// int max = st.top();
// st.pop();
// while (!newSt.empty()&&newSt.top()>max) {
// st.push(newSt.top());
// newSt.pop();
// }
// newSt.push(max);
// }
// return newSt;
//}
//
//int main()
//{
// stack<int> st;
// for(int i=0;i<10;i++)
// {
// st.push(rand()%10);
// }
// stack<int> s = sSort(st);
// while(!s.empty())
// {
// cout<<s.top();
// s.pop();
// }
//} //4 1 Implement a function to check if a tree is balanced For the purposes of this question, a balanced tree is defined to be a tree such that no two leaf nodes differ in distance from the root by more than one

  

ctci(1)的更多相关文章

  1. 程序员面试必备经典CTCI,谷歌面试官经典作品!

    1.1 判断一个字符串中的字符是否唯一 1.2 字符串翻转 1.3 去除字符串中重复字符 1.8 利用已知函数判断字符串是否为另一字符串的子串 2.1 从链表中移除重复结点 2.2 实现一个算法从一个 ...

  2. [google面试CTCI] 2-1.移除链表中重复元素

    [链表] Q:Write code to remove duplicates from an unsorted linked list      FOLLOW UP      How would yo ...

  3. [google面试CTCI] 2-2 找出链表的倒数第n个节点元素

    [链表] Q:Implement an algorithm to find the nth to last element of a singly  linked list . 题目:找出链表的倒数第 ...

  4. [google面试CTCI] 2-3 只给定链表中间节点指针,如何删除中间节点?

    [链表] Q:Implement an algorithm to delete a node in the middle of a single linked list, given only acc ...

  5. [google面试CTCI] 2-0.链表的创建

    创建链表.往链表中插入数据.删除数据等操作,以单链表为例. 1.使用C语言创建一个链表: typedef struct nd{ int data; struct nd* next; } node; / ...

  6. [google面试CTCI] 1-8.判断子字符串

    [字符串与数组] Q:Assume you have a method isSubstring which checks if one word is a substring of another G ...

  7. [google面试CTCI] 1-7.将矩阵中特定行、列置0

    [字符串与数组] Q:Write an algorithm such that if an element in an MxN matrix is 0, its entire row and colu ...

  8. [google面试CTCI] 1-6.图像旋转问题

    [字符串与数组] Q:Given an image represented by an NxN matrix, where each pixel in the image is 4 bytes, wr ...

  9. [google面试CTCI] 1-5.替换字符串中特定字符

    [字符串与数组] Q:Write a method to replace all spaces in a string with ‘%20’ 题目:写一个算法将一个字符串中的空格替换成%20 解答: ...

  10. [google面试CTCI] 1-4.判断两个字符串是否由相同字符组成

    [字符串与数组] Q:Write a method to decide if two strings are anagrams or not 题目:写一个算法来判断两个字符串是否为换位字符串.(换位字 ...

随机推荐

  1. eShopOnContainers 是一个基于微服务的.NET Core示例框架

    找到一个好的示例框架很难,但不是不可能.大多数是小型Todo风格的应用程序,通常基于SimpleCRUD.值得庆幸的是,Microsoft已经为eShopOnContainers创建了一个基于微服务的 ...

  2. Springboot日志配置探索(主要看logback)(一)

    这篇博客是springboot日志配置探索的第一篇,主要讲默认配置下springboot的logback日志框架的配置(即直接使用是怎样的) 首先,是一个SpringBoot的有关日志的说明文档:ht ...

  3. 142. O(1)时间检测2的幂次

    用 O(1) 时间检测整数 n 是否是 2 的幂次. 您在真实的面试中是否遇到过这个题? Yes 样例 n=4,返回 true; n=5,返回 false. class Solution { publ ...

  4. [转]Creating Mailing Labels in SQL Server Reporting Services (rdlc 数据1页 2竖排 显示)

    本文转自:http://blogs.wrox.com/article/creating-mailing-labels-in-sql-server-reporting-services/ Most wo ...

  5. 一步步实现自己的ORM(四)

    通过前3章文章,大致对ORM有一定的了解,但也存在效率低下(大量用了反射)和重复代码,今天我们要对ORM进行优化. 具体流程如下: 我们优化的第一个就是减少反射调用,我的思路是定义一个Mapping, ...

  6. kafka系列二:多节点分布式集群搭建

    上一篇分享了单节点伪分布式集群搭建方法,本篇来分享一下多节点分布式集群搭建方法.多节点分布式集群结构如下图所示: 为了方便查阅,本篇将和上一篇一样从零开始一步一步进行集群搭建. 一.安装Jdk 具体安 ...

  7. 洛谷 P1048 采药

    采药 01背包模板题. #include <iostream> #include <cstdio> using namespace std; //Mystery_Sky //一 ...

  8. LR中订单流程脚本2

    Action(){ //1.设置服务器的IP地址 //lr_save_string("192.168.1.12:8080", "ip"); lr_save_st ...

  9. jmeter中文件上传配置

  10. (转)SpringMVC学习(三)——SpringMVC的配置文件

    http://blog.csdn.net/yerenyuan_pku/article/details/72231527 读者阅读过SpringMVC学习(一)——SpringMVC介绍与入门这篇文章后 ...