剑指offer——day1

、题目一

题目主要考察的是对栈和队列的理解和基本实现

typedef int STDataType;
#define DEFSTACKSIZE 100
typedef struct Stack
{
	STDataType* array;
	int size;		
	int capacity;  
}Stack;
void CheckCapacity(Stack* ps)
{
	if (ps->size >= ps->capacity)
	{
		ps->capacity *= 2;
		ps->array = (STDataType *)realloc(ps->array, ps->capacity * sizeof(STDataType));
	}
}
void StackInit(Stack* ps)
{
	ps->array = (STDataType *)calloc(DEFSTACKSIZE, sizeof(STDataType));
	ps->capacity = DEFSTACKSIZE;
	ps->size = 0;
}
void StackPush(Stack* ps, STDataType x)
{
	CheckCapacity(ps);
 
	ps->array[ps->size] = x;
	ps->size++;
}
void StackPop(Stack* ps)
{
	if (ps->size == 0)
	{
		return;
	}
	ps->size--;
}
STDataType StackTop(Stack* ps)
{
	if (ps->size == 0)
	{
		return (STDataType)-1;
	}
	return ps->array[ps->size - 1];
}
int StackEmpty(Stack* ps)
{
	return ps->size == 0;
}
int StackSize(Stack* ps)
{
	return ps->size;
}
void StackDestory(Stack* ps)
{
	if (ps->array)
	{ 
		free(ps->array);
		ps->array = NULL;
		ps->size = 0;
		ps->capacity = 0;
	}
}
typedef struct {
    Stack addstack;
    Stack delstack;
} CQueue;


CQueue* cQueueCreate() {
    CQueue* obj=(CQueue*)malloc(sizeof(CQueue));
    StackInit(&obj->addstack);
    StackInit(&obj->delstack);
    return obj;
}

void cQueueAppendTail(CQueue* obj, int value) {
    StackPush(&obj->addstack,value);
}

int cQueueDeleteHead(CQueue* obj) {
    assert(obj);
    if(StackEmpty(&obj->delstack))
    {
        while(!StackEmpty(&obj->addstack))
        {
            StackPush(&obj->delstack,StackTop(&obj->addstack));
            StackPop(&obj->addstack);
        }
    }
    int res=StackTop(&obj->delstack);
    StackPop(&obj->delstack);
    return res;
}

void cQueueFree(CQueue* obj) {
    StackDestory(&obj->addstack);
    StackDestory(&obj->delstack);
    free(obj);
}

题目二

结构体中多存放一个min成员保存最小元素

//实现栈
#define DEFSTACKSIZE 100
typedef struct {
    int *a;
    int top;
    int capacity;
    int min;
} MinStack;

/** initialize your data structure here. */

void checkstack(MinStack*obj)
{
    if (obj->top >= obj->capacity)
	{
	    obj->capacity *= 2;
		obj->a = (int*)realloc(obj->a, obj->capacity * sizeof(int));
	}
}

MinStack* minStackCreate() {
    MinStack* obj=(MinStack*)malloc(sizeof(MinStack));
    obj->top=0;
    obj->capacity=DEFSTACKSIZE;
    obj->a=(int*)calloc(DEFSTACKSIZE, sizeof(int));
    obj->min=INT_MAX;
    return obj;
}

void minStackPush(MinStack* obj, int x) {
    checkstack(obj);
    obj->a[obj->top]=x;
    obj->min=obj->min < x?obj->min:x;
    obj->top++;
}

void minStackPop(MinStack* obj) {
    obj->top--;
    if(obj->top==0)
    {
        obj->min=INT_MAX;
    }
    if(obj->top>0)
    {
        obj->min=obj->a[obj->top-1];
    }
    for(int i=obj->top-1;i>=0;i--)
    {
        if(obj->a[i]<obj->min)
        {
            obj->min=obj->a[i];
        }
    }
    
}

int minStackTop(MinStack* obj) {
    if(obj->top==0)
    {
        return ;
    }
    return obj->a[obj->top-1];

}

int minStackMin(MinStack* obj) {
    if(obj->top==0)
    {
        return ;
    }
    return obj->min;
}