笔试算法题（21）：将stack内外颠倒 & 判断扑克牌顺子

             1
            class
             MyStack {

             2
            private
            :

             3
            int *array;
 4int capability;
 5int top;
 6public:
 7         MyStack(int cap=5): array((int*)malloc(sizeof(int)*cap)), capability(cap), top(0) {}
 8         ~MyStack() {delete [] array;}
 910bool isFull() {
11return top == capability;
12        }
13bool isEmpty() {
14return top == 0;
15        }
16int freeSlot() {
17return capability - top;
18        }
19/**
20         * top当前的位置就是下一个push元素所在的slot
21         * */22bool push(int n) {
23if(isFull()) returnfalse;
24                 array[top++]=n;
25returntrue;
26        }
27bool pop(int *n) {
28if(isEmpty()) returnfalse;
29                 *n=array[--top];
30returntrue;
31        }
32void ShowStack() {
33int temp=top-1;
34                 printf("\n");
35for(int i=0;i<=temp;i++)
36                         printf("%d, ",array[i]);
37                 printf("\n");
38        }
39};
40void AddToBottom(MyStack *stack, int top) {
41int curTop;
42if(stack->pop(&curTop)) {
43                AddToBottom(stack, top);
44                 stack->push(curTop);
45         }else46                 stack->push(curTop);
47}
48void ReverseStack(MyStack *stack) {
49int top;
50if(stack->pop(&top)) {
51                ReverseStack(stack);
52                AddToBottom(stack, top);
53        }
54 }

             1
            /*
            *

             2
             * 解法1:

             3
             * 
            */
             4
            bool BetterVersion(int *array, int length) {
 5int hash[14];
 6int max=array[0],min=array[1];
 7/**
 8         * 使用一个14个元素的int数组表示13个数字和王（0）
 9         * 全部初始化为0
10         * */11for(int i=0;i<14;i++)
12                 hash[i]=0;
1314for(int i=0;i<length;i++) {
15if(array[i]==0)
16                         hash[0]++;
17else {
18/**
19                         * max和min仅在1到13之间统计
20                         * 并且一旦某个数字出现两次，则失败
21                         * */22if(hash[array[i］ == 0)
23                                 hash[array[i］=1;
24else25returnfalse;
26if(array[i]>max) max=array[i];
27if(array[i]<min) min=array[i];
28                }
29        }
30/**
31         * 只要max和min相差值小于5，说明肯定可以连续
32         * */33if(max-min<=4) returntrue;
34elsereturnfalse;
35 }/**
36 * 解法2:
37 * */38bool DetermineJunko(int *array, int length) {
39/**
40         * 使用插入排序对数组进行排序
41         * */42         InsertSort(array, 0, length-1);
43/**
44         * 计算王的个数，使用king索引，缺省值为-1
45         * */46int king=-1;
47for(int i=0;i<length;i++) {
48if(array[i]==0)
49                         king++;
50else51break;
52        }
53/**
54         * 从king后面一个位置开始，判断current和next索引
55         * 的元素是否连续
56         * 如果是则current和next向右移动
57         * 如果不是则向左移动king表示使用王替换
58         * 并且向右移动current和next
59         * 如果king已经到-1则失败
60         * 如果next已经到达数组末尾则成功
61         * */62int current=king+1, next=king+2, diff=0;
63while(next < length) {
64if(array[current]+1==array[next]) {
65                         current++;next++;
66                 } if (array[current]==array[next]) {
67returnfalse;
68                 } else {
69                         diff=array[next]-array[current];
70for(int i=1;i<diff;i++) {
71if(king>-1) {
72                                         king--;
73                                         current++;next++;
74                                 } else75returnfalse;
76                        }
77                }
78        }
79returntrue;
80 }