一、前言

1.做算法题的方法:

充分阅读题目.了解题目背后的关键意思;
分析题目,涉及到哪些数据结构,对问题进行分类. 到底属于链表问题, 栈思想问题, 字符串问题,二叉树问题,图相关问题,排序问题; 与你之前所接触过的算法题有没有类似,找到问题的解题思路；
实现算法. 在算法的实现的过程,并不是一蹴而就, 肯定是需要不断的调试,修改的;
验证算法正确性；
找到题源, 看其他的开发者对齐的解决思路；
找到题解建议之后, 对于其他优秀思路,分析它的优势,并且学习它的思路.并且写成其他解法的代码；
算法题的解题能力来自于2点: 对于数据结构与算法核心问题是否夯实 + 是否有足够多且足够耐心的积累;

2.栈的思想应用：

指的是利用栈的特性(先进后出)去解决问题,那么什么问题适合用栈思想解决了?

数据是线性的；
问题中常常涉及到数据的来回比较,匹配问题;例如,每日温度,括号匹配,字符串解码,去掉重复字母等问题；
问题中涉及到数据的转置,例如进制问题.链表倒序打印问题等；
利用栈思想解决问题时,首先需要透彻的解析问题之后,找到问题解决的规律.才能使用它解决。
二、算法题

1、数制的转换

代码实现

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;
typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */

/* 顺序栈结构 */
typedef struct
{
    SElemType data[MAXSIZE];
    int top; /* 用于栈顶指针 */
}SqStack;

//4.1 构建一个空栈S
Status InitStack(SqStack *S){
    
    S->top = -1;
    return OK;
}


//4.2 将栈置空
Status ClearStack(SqStack *S){
    
    //疑问: 将栈置空,需要将顺序栈的元素都清空吗?
    //不需要,只需要修改top标签就可以了.
    S->top = -1;
    return OK;
}

//4.3 判断顺序栈是否为空;
Status StackEmpty(SqStack S){
    if (S.top == -1)
        return TRUE;
    else
        return FALSE;
}

//4.4 返回栈的长度
int StackLength(SqStack S){
    return S.top + 1;
}

//4.5 获取栈顶
Status GetTop(SqStack S,SElemType *e){
    if (S.top == -1)
        return ERROR;
    else
        *e = S.data[S.top];
    
    return OK;
    
}

//4.6 插入元素e为新栈顶元素
Status PushData(SqStack *S, SElemType e){
    
    //栈已满
    if (S->top == MAXSIZE -1) {
        return ERROR;
    }
    
    //栈顶指针+1;
    S->top ++;
    //将新插入的元素赋值给栈顶空间
    S->data[S->top] = e;
    
    return OK;
}

//4.7 删除S栈顶元素,并且用e带回
Status Pop(SqStack *S,SElemType *e){
    
    //空栈,则返回error;
    if (S->top == -1) {
        return ERROR;
    }
    
    //将要删除的栈顶元素赋值给e
    *e = S->data[S->top];
    //栈顶指针--;
    S->top--;
    
    return OK;
}

//4.8 从栈底到栈顶依次对栈中的每个元素打印
Status StackTraverse(SqStack S){
    int i = 0;
    printf("此栈中所有元素");
    while (i<=S.top) {
        printf("%d ",S.data[i++]);
    }
    printf("\n");
    return OK;
}

/*
 1. 初始化一个空栈S
 2. 当十进制N非零时,循环执行以下操作
    * 把N与8求余得到的八进制数压入栈S;
    * N更新为N与8的商;
 3. 当栈S非空时,循环执行以下操作
    * 弹出栈顶元素e;
    * 输出e;
 */
void conversion(int N){
    
    SqStack S;
    SElemType e;
    //1.初始化一个空栈S
    InitStack(&S);
    
    //2.
    while (N) {
        PushData(&S, N%8);
        N = N/8;
    }
    
    //3.
    while (!StackEmpty(S)) {
        Pop(&S, &e);
        printf("%d\n",e);
    }
    
}

2、每日温度

题目: 根据每日气温列表，请重新生成一个列表，对应位置的输入是你需要再等待多久温度才会升高超过该日的天数。如果之后都不会升高，请在该位置0来代替。例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

解题关键: 实际上就是找当前元素从[i,TSize] 找到大于该元素时. 数了几次. 首先最后一个元素默认是0,因为它后面已经没有元素了.

2.1、暴力法

思路:

1.创建一个result 结果数组.
2.默认reslut[TSize-1] = 0;
3.从0个元素遍历到最后一个元素[0,TSize-1];
A.如果当前i >0 并且当前的元素和上一个元素相等,则没有必要继续循环. 则判断一下result[i-1]是否等于0,如果等于则直接将result[i] = 0,否则将result[i] = result[i-1]-1;
B.遍历元素[i+1,TSize]
如果当前T[j]>T[i],则result[i] = j-i;
如果当前T[j]已经是最后一个元素,则默认result[i] = 0;
代码实现：

int  *dailyTemperatures_1(int* T, int TSize, int* returnSize){
    
    int *result = (int *)malloc(sizeof(int) * TSize);
    *returnSize = TSize;
    result[TSize-1] = 0;
    
    for(int i = 0;i < TSize-1;i++)
        if(i>0 && T[i] == T[i-1])
            result[i] = result[i-1] == 0?0:result[i-1]-1;
        else{
            for (int j = i+1; j < TSize; j++) {
                if(T[j] > T[I]){
                    result[i] = j-i;
                    break;
                }
                if (j == TSize-1) {
                    result[i] = 0;
                }
            }
        }
    
    return result;
}

2.2 跳跃对比:

思路:

1.创建一个result 结果数组.
2.默认reslut[TSize-1] = 0;
3.从TSize-2个元素遍历到第一个元素[TSize-2,0];
4.从[i+1,TSize]遍历,j+=result[j];
-若T[i]<T[j],那么Result = j - I;
-若reuslt[j] == 0,则表示后面不会有更大的值,那么当前值就应该也是0;
代码实现：

int  *dailyTemperatures_2(int* T, int TSize, int* returnSize){
    
    int *result = (int *)malloc(sizeof(int) * TSize);
    *returnSize = TSize;
    result[TSize-1] = 0;
    
    for (int i=TSize-2; i >= 0; i--) {
        for (int j = i+1; j < TSize; j+=result[j]) {
            if (T[i] < T[j]) {
                result[i] = j-i;
                break;
            }else
            {
                if (result[j] == 0) {
                    result[i] = 0;
                    break;
                }
            }
        }
    }
    
    return result;
}

2.3 栈思想

思路:

1. 初始化一个栈(用来存储索引),value数组
1. 栈中存储的是元素的索引值index;
1. 遍历整个温度数组从[0,TSize];
  (1).如果栈顶元素<当前元素,则将当前元素索引index-栈顶元素index,计算完毕则将当前栈顶元素移除,将当前元素索引index 存储到栈中; 出栈后,只要栈不为空.继续比较,直到栈顶元素不能满足T[i] > T[stack_index[top-1]]
  (2).如果当前的栈为空,则直接入栈;
  (3).如果当前的元素小于栈顶元素,则入栈
  (4).while循环结束后,当前元素也需要入栈;
  代码实现：

int* dailyTemperatures_3(int* T, int TSize, int* returnSize) {
    
    int* result = (int*)malloc(sizeof(int)*TSize);
    // 用栈记录T的下标。
    int* stack_index = malloc(sizeof(int)*TSize);
    *returnSize = TSize;
    // 栈顶指针。
    int top = 0;
    int tIndex;
    
    for (int i = 0; i < TSize; I++)
        result[i] = 0;
    
    for (int i = 0; i < TSize; i++) {
        printf("\n循环第%d次,i = %d\n",i,i);
       
        // 若当前元素大于栈顶元素，栈顶元素出栈。即温度升高了，所求天数为两者下标的差值。
        while (top > 0 && T[i] > T[stack_index[top-1]]) {
            tIndex = stack_index[top-1];
            result[tIndex] = i - tIndex;
            top--;
            printf("tIndex = %d; result[%d] = %d, top = %d \n",tIndex,tIndex,result[tIndex],top);
        }
        
        // 当前元素入栈。
        stack_index[top] = I;
        printf("i= %d;  StackIndex[%d] = %d ",i,top,stack_index[top]);
        top++;
        
        printf(" top = %d \n",top);
    }
    
    return result;
}

3、括号匹配检验

题目：假设表达式中允许包含两种括号:圆括号与⽅方括号,其嵌套顺序随意,即() 或者[([][])]都是正确的.⽽而这[(]或者(()])或者([()) 都是不不正确的格式. 检验括号是否匹配的⽅方法可⽤用”期待的急迫程度"这个概念来描述.例例如,考虑以下括号的判断: [ ( [ ] [ ] ) ]
思路:

1. 将第0个元素压栈
1. 遍历[1,strlen(data)]
- (1). 取栈顶字符
- (2). 检查该字符是左括号("(","[")
  - a.是左"(",则判断紧接其后的data[i]是为右")"
    YES->压栈,NO->出栈
  - b.是左"[",则判断紧跟其后的data[i]是为右"]"
    YES->压栈,NO->出栈
  - c.表示式如果以"#"结尾,则判断紧跟其后的data是为左"(""]"
    YES->压栈,NO->-1;

3.遍历结束,则判断栈是否为空,为空则表示匹配成功;否则匹配失败;
代码实现：

#define Stack_Init_Size 100
#define Stack_Increment 10
//栈的定义
typedef struct {
    char* base; //栈底指针
    char* top;  //栈顶指针
    int stacksize;  //栈MaxSize
}SqStack;

//初始化栈
/*
 思路:
 1. 如果栈底为空
 2. 分配一个最大容量Stack_Init_Size的数组,栈底/栈顶都指向与它.[参考图空栈情况]
 3. 初始化栈的最大容易Stack_Init_Size
 */
int Init(SqStack *stack){

        stack->base=(char*)malloc(Stack_Init_Size*sizeof(char));
        stack->top=stack->base;
        if(stack->top) return -1;//表示无法初始化已出始化栈
    
        stack->stacksize = Stack_Init_Size;
        printf("初始化成功\n");
        return 0; //初始化成功
    
}

//获取栈顶数据
/*
 思路:
 1.判断栈是否为空
 2.非空,则栈定指针-1,返回栈顶元素;
 */
char GetTop(SqStack stack){
   
    if(stack.base==stack.top){
        printf("栈中没有数据\n");
        return '#';
    }
    //printf("获取栈顶数据成功\n");
    return *(stack.top-1);
}

//往栈中插入元素
/*
 思路:
 1.判断栈是否已满,若满则返回ERROR #问题:如何判断栈是否已满?
 2.栈满,则续容空间 #问题:如何给已满栈续容空间?
 3.将元素element压栈
 4.栈顶指针加"1"
 */
int Push(SqStack *stack,char element){
    if(stack->top-stack->base==stack->stacksize){
        stack->base=(char*)realloc(stack->base,Stack_Increment*sizeof(char));
        stack->top=stack->base+stack->stacksize;
        stack->stacksize+=Stack_Increment;
    }
    *stack->top=element;
    stack->top+=1;
    return 0;
}

//删除栈顶元素
/*
 思路:
 1.判断栈是否已空
 2.非空,则获取栈顶元素,并将栈顶减"1";
 */
char Pop(SqStack *stack){
    if(stack->top==stack->base){
        printf("栈为空\n");
        return '#';
    }
    //printf("删除数据成功");
    return *--stack->top;
}

//释放栈空间
int Destroy(SqStack *stack){
    free(stack->base);
    stack->stacksize=0;
    return 0;
}
int ExecuteData(SqStack stack,char* data){
    Push(&stack,data[0]);
    for(int i=1;i<strlen(data);i++){
        char top = GetTop(stack);
        switch(top){
            case '(':
                if(data[i]==')')Pop(&stack);
                else Push(&stack,data[I]);
                break;
            case '[':
                if(data[i]==']')Pop(&stack);
                else Push(&stack,data[I]);
                break;
            case '#':
                if(data[i]=='('||data[i]=='['){
                    Push(&stack,data[I]);
                    break;
                }
                else
                    default:return -1;break;
        }
    }
    
    //如果栈为空,则返回"0"->匹配成功 否则返回"-1"匹配失败
    if(stack.top==stack.base){
        Destroy(&stack);
        return 0;
    }
    else{
        
        Destroy(&stack);
        return -1;
    }
}

4、杨辉三角

杨辉三角@2x.png

思路:

1. 第一层循环控制行数i : 默认[i][0] = 1,[i][i] = 1
1. 第二层循环控制列数j : triangle[i][j] = triangle[i-1][j-1] + triangle[i-1][j]
  代码实现：

int** generate(int numRows, int* returnSize){
    
    *returnSize = numRows;
    
    int **res = (int **)malloc(sizeof(int*)*numRows);
    
    for (int i = 0; i < numRows; i++) {
        res[i] = (int *)malloc(sizeof(int)*(i+1));
        res[i][0] = 1;
        res[i][i] = 1;
        
        for (int j = 1; j < i; j++) {
            res[i][j] = res[i-1][j] + res[i-1][j-1];
        }
    }
    
    return res;
}

5、爬楼梯

题目：假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不不同的⽅方法可以爬到楼顶呢?注意:给定 n 是⼀一个正整数

5.1 递归法：

代码实现：

int ClimbStairs_1(int n){
    
    if (n<1)  return 0;
    if (n == 1) return 1;
    if (n == 2) return 2;
    
    return ClimbStairs_1(n-1) + ClimbStairs_1(n-2);
}

5.2 动态规划法