//
// 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. c#学习系列之Application.StartupPath的用法(美女时钟的做法)

    Application.StartupPath是一个只读属性,是不可以设置的. Application.StarupPath获取启动了应用程序的可执行文件的路径,不包括可执行文件的名称.既是Appli ...

  2. 删除cookie时遇到的坑

    曾经有个“导出中”的需求,我用iframe实现下载对话框和cookie轮询验证token去解决的,但是昨天又发现了一个新问题: 因为前台需要提示导出失败的详细信息,这个信息我是在token返回0的时候 ...

  3. jQuery position() 源码解读

    position的代码比较简单... position: function() { if ( !this[ 0 ] ) { return; } var offsetParent, offset, el ...

  4. AtCoder D - 高橋君と見えざる手 / An Invisible Hand 简单思维题

    http://arc063.contest.atcoder.jp/tasks/arc063_b 因为每次都是选取最大值,那么用dp[i]表示第i个数结尾能得到最大是多少. 其实就是用a[i]去减去左边 ...

  5. Partition(线段树的离线处理)

    有一点类似区间K值的求法. 这里有两颗树,一个是自己建的线段树,一个是题目中给定的树.以线段树和树进行区分. 首先离散化一下,以离散化后的结果建线段树,线段树的节点开了2维,一维保存当前以当前节点为权 ...

  6. js 学习网站

    1.  Mozilla Developer Network(MDN) 这里你可以找到官方的完整的javascript参考,还有许多有用的指导,教程以及文章,从基本javascript使用到最佳实践以及 ...

  7. if __FILE__ == $0 end

    if __FILE__ == $0 end __FILE__是一个“具有魔力”的变量,它代表了当前文件名.$0是用于启动程序的文件名.那么代码“if __FILE__ == $0”便意味着检查此文件是 ...

  8. winfrom项目的打印

    自己可以下一个PDF打印机(例如下载64位office虚拟打印文档) 首先要添加控件 1.添加打印的选项卡,并命名为打印 2.点击打印选项卡,右击鼠标,选择选择项 using System;using ...

  9. (wp8.1开发)触摸键从推出变返回

    ---恢复内容开始--- 今天开发wp8.1,遇到这样一个问题,从第一个页面跳到第二个页面,在第二个页面按返回,结果程序退出了.原来是系统把返回键定义成退出了. 解决办法: 在第一个页面加入如下代码 ...

  10. Spring Cloud Gateway VS Zuul 比较,怎么选择?

    Spring Cloud Gateway 是 Spring Cloud Finchley 版推出来的新组件,用来代替服务网关:Zuul. 那 Spring Cloud Gateway 和 Zuul 都 ...