数据结构与算法（7）- 关于栈的算法题

初心
247 阅读11分钟

题目一 ：括号匹配检验

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

思路：

    1. 将第0个元素压栈

    1. 遍历[1,strlen(data)] (3). 取栈顶字符 (4). 检查该字符是左括号("(","[")

      a.是左"(",则判断紧接其后的data[i]是为右")"
   YES->压栈,NO->出栈
b.是左"[",则判断紧跟其后的data[i]是为右"]"
   YES->压栈,NO->出栈
c.表示式如果以"#"结尾,则判断紧跟其后的data是为左"(""]"
   YES->压栈,NO->-1;

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

实现关键代码：

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;
    }
}

int main(int argc, const char * argv[]) {
    sqStack stack;
    initSqStack(&stack);
    char data[180];
    printf("请输入待匹配的字符串\n");
    scanf("%s",data);
    printf("%s\n",data);
    int result = executeData(stack,data);
    if(result==0)printf("括号是正确匹配的\n");
    else printf("括号匹配不正确\n");
    

    return 0;
}

打印结果：

题目二：每日气温

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

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

思路一：

暴力法:

  1. 从左到右开始遍历,从第一个数到最后一个数开始遍历. 最后一个数因为后面没有元素,默认是0,不需要计算;
  2. 从[i+1,TSize]遍历,每个数直到找到比它大的数,数的次数就是对应的值;

代码实现：

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;
}

打印结果：

思路三：

  1. 初始化一个栈(用来存储索引),value数组
  2. 栈中存储的是元素的索引值index;
  3. 将当前元素和栈顶元素比较;
    • 如果栈为空,那么直接将当前元素索引index 存储到栈中;
    • 如果栈顶元素>当前元素,则将当前元素索引index 存储到栈中;
    • 如果栈顶元素<当前元素,则将当前元素索引index-栈顶元素index,计算完毕则将当前栈顶元素移除,将当前元素索引index 存储到栈中

代码实现：

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;
}

打印结果

题目三：数进制转换问题

思路：

  • 1、有效数判断，如果如果小于1，给出提示并返回;
  • 2、循环将要处理的数，先取模n并将余数放入栈中，然后再取商
  • 3、如果商小于等于 0 ，则跳出循环

代码实现：

typedef struct Stack {
    int *datas;
    int top;
}SqStack;

ret initStack(SqStack *s) {
    s->datas = (int *)malloc(MAXSIZE * sizeof(int));
    s->top = 0;
    return 1;
}

//4.6 插入元素e为新栈顶元素
ret pushData(SqStack *s, int i) {
    if (s->top == MAXSIZE) {
        s->datas = (int *)realloc(s->datas, 10 * sizeof(int));
    }
    s->datas[s->top] = i;
    s->top += 1;
    return 1;
}

//获取栈顶元素
ret popTopElement(SqStack *s, int *i) {
    *i = s->datas[s->top-1];
    s->top -= 1;
    return 1;
}

//是否为空
ret isEmpty(SqStack s) {
    if (s.top == 0) {
        return 0;
    } else {
        return 1;
    }
}

//打印栈元素
void displayStack(SqStack s) {
    if (isEmpty(s) == 0) {
        printf("栈为空！");
    }
    while (s.top != 0) {
        printf("%d ",s.datas[s.top - 1]);
        s.top -- ;
    }
    printf("\n");
}

//转换
ret conversion(SqStack *s, int number, int mod) {
    if (number < 1) {
        printf("请给出有效数字");
        return;
    }
    int m;
    while (number > 0) {
        m = number % mod;
        pushData(s, m);
        number /= mod;
    }
    return 1;
}


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("数进制转换!\n");
    
    SqStack s;
    initStack(&s);
    int number = 5332;
    printf("%d \n", number);
    conversion(&s, number, 2);
    displayStack(s);
    printf("\n");
    
    

    return 0;
}

打印结果：

题目四：杨辉三角

思路：

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

代码实现：

int** generate(int rowNumber, int *resultSize) {
    int **result = (int **)malloc(rowNumber * sizeof(int*));
    *resultSize = rowNumber;
    
    for (int i = 0; i < rowNumber; i++) {
        result[i] = (int *)malloc((i + 1) * sizeof(int));
        result[i][0] = 1;
        result[i][i] = 1;
        for (int j = 1; j < i; j++) {
            result[i][j] = result[i-1][j-1] + result[i-1][j];
        }
    }
    
    return result;
}


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("杨辉三角问题!\n");
    int numRows = 10;
    int resultSize;
    int **result = generate(numRows, &resultSize);
    for (int i = 0; i < resultSize; i++) {
        for (int j = 0; j <= i; j++) {
            printf("%d " , result[i][j]);
        }
        printf("\n");
    }

    printf("\n");
    
    return 0;
}

打印结果：

题目五： 爬楼梯问题

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

思路一：

递归求解法

f(n) = f(n-1) + f(n-2);

f(1)=1;

f(2)=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);
}

int main(int argc, const char * argv[]) {
    // insert code here...
    printf("爬楼梯问题!\n");
    
    int ret = ClimbStairs_1(6);
    printf("6步台阶有%d种方法可以上到楼顶！\n",ret);
    return 0;
}

打印结果：

思路二：

动态规划法

代码实现：

int ClimbStairs_2(int n) {
    if (n ==  1) return 1;
    int *sumArr = (int *)malloc(n * sizeof(int));
    sumArr[0] = 0;
    sumArr[1] = 1;
    sumArr[2] = 2;
    for (int  i = 3; i <= n; i++) {
        sumArr[i] = sumArr[i - 1] + sumArr[i - 2];
    }
    
    return sumArr[n];
}


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("爬楼梯问题!\n");
    
    int ret = ClimbStairs_2(6);
    printf("6步台阶有%d种方法可以上到楼顶！\n",ret);
    return 0;
}

打印结果：

题目六：字符串编码问题

编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。

例如:

s = "3[a]2[bc]", 返回 "aaabcbc".

s = "3[a2[c]]", 返回 "accaccacc".

s = "2[abc]3[cd]ef", 返回 "abcabccdcdcdef".

思路:

12[a]为例;

  1. 遍历字符串 S
  2. 如果当前字符不为方括号"]" 则入栈stack中;
  3. 如果当前字符遇到了方括号"]" 则:
  • ① 首先找到要复制的字符,例如stack="12[a",那么我要首先获取字符a;将这个a保存在另外一个栈去tempStack;
  • ② 接下来,要找到需要备份的数量,例如stack="12[a",因为出栈过字符"a",则当前的top指向了"[",也就是等于2;
  • ③ 而12对于字符串是2个字符, 我们要通过遍历找到数字12的top上限/下限的位置索引, 此时上限curTop = 2, 下限通过出栈,top = -1;
  • ④ 根据范围[-1,2],读取出12保存到strOfInt 字符串中来, 并且将字符"12\0",转化成数字12;
  • ⑤ 当前top=-1,将tempStack中的字符a,复制12份入栈到stack中来;
  • ⑥ 为当前的stack扩容, 在stack字符的末尾添加字符结束符合'\0';

代码实现：

char * decodeString(char * s){
   
    /*.
     1.获取字符串长度
     2.设置默认栈长度50
     3.开辟字符串栈(空间为50)
     4.设置栈头指针top = -1;
     */
    int len = (int)strlen(s);
    int stackSize = 50;
    char* stack = (char*)malloc(stackSize * sizeof(char));
    int top = -1;
    
    //遍历字符串,在没有遇到"]" 之前全部入栈
    for (int i = 0; i < len; ++i) {
        if (s[i] != ']') {
            //将字符入栈stack
            stack[++top] = s[i];
        }
        else {
            int tempSize = 10;
            char* temp = (char*)malloc(tempSize * sizeof(char));
            int topOfTemp = -1;
            
            while (stack[top] != '[') {
                ++topOfTemp;
                temp[topOfTemp] = stack[top];
                //stack出栈,则top栈顶指针递减;
                top--;
            }
            
            //找到倍数数字.strOfInt字符串;
            char strOfInt[11];
            int curTop = top;
            top--;
            while (top != -1 && stack[top] >= '0' && stack[top] <= '9') {
                top--;
            }
            for (int j = top + 1; j < curTop; ++j) {
                strOfInt[j - (top + 1)] = stack[j];
            }
            //为字符串strOfInt数组加一个字符结束后缀'\0'
            strOfInt[curTop - (top + 1)] = '\0';

            //把字母复制strOfInt份到stack中去;
            int curNum = atoi(strOfInt);
            for (int k = 0; k < curNum ; ++k) {
                
                int kk = topOfTemp;
                while (kk != -1) {

                    ++top;
                    stack[top] = temp[kk];
                    kk--;
                    
                }
            }
            free(temp);
            temp = NULL;
        }
    }
    
    //realloc 动态内存调整;
    //void *realloc(void *mem_address, unsigned int newsize);
    //构成字符串stack后, 在stack的空间扩容.
    char* ans = realloc(stack, (top + 1) * sizeof(char));
    ans[++top] = '\0';
    
    //stack 栈不用,则释放;
    free(stack);
    return ans;
}

int main(int argc, const char * argv[]) {
    // insert code here...
    printf("字符串编码问题!\n");
    
    char *s ;
    s = decodeString("12[a]");
    printf("字符编码后的结果: %s\n\n\n\n",s);
    
    s = decodeString("3[a]2[bc]");
    printf("字符编码后的结果: %s\n\n\n\n",s);

    s = decodeString("3[a2[c]]");
    printf("字符编码后的结果: %s\n\n\n\n",s);

    s = decodeString("2[abc]3[cd]ef");
    printf("字符编码后的结果: %s\n\n\n\n",s);

    printf("\n");


    
    return 0;
}

结果打印：

题目七：去掉重复字母

给你一个仅包含小写字母的字符串，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）

示例1: 输入:"bcabc" 输出:"abc"

示例2: 输入:"cbacdcbc" 输出:"acdb"

解题关键:

字典序: 字符串之间比较和数字比较不一样; 字符串比较是从头往后挨个字符比较,那个字符串大取决于两个字符串中第一个对应不相等的字符; 例如 任意一个a开头的字符串都大于任意一个b开头的字符串;例如字典中apple 大于 book; 题目的意思,你去除重复字母后,需要按最小的字典序返回.并且不能打乱其他字母的相对位置;

例如 bcabc 你应该返回abc, 而不是bca,cab;

例如 cbacdcbc 应该返回acdb,而不是cbad,bacd,adcb

例如 zab,应该返回zab,而不是abz;

思路：

  1. 特殊情况判断，当字符串为NULL返回空字符串，长度为 1 ，直接返回
  2. 统计每个字符频度，存入数据
  3. 创建并初始化一个栈，用了存储去重后的最终结果并用他的特性帮组我们找到正确的字典序
  4. 遍历字符串 s
    1. 判断当前字符是否已在栈中存在，用临时变量 isExist 来标识；
    2. 如果已存在，便将当前字符频度减一；
    3. 如果不存在则判断栈中是否有元素，并且当前值小于栈顶的值，还要判断当前元素后面还会不会出现，通过之前统计的字符频度判断
    4. 如果条件满足，便跳过该元素，频次减一,并将当前栈顶元素出栈
    5. 将当前字符加入栈中
  5. 结束栈顶添加字符结束符

代码实现：

char *removeDuplicateLetters(char *s) {
    if (s == NULL) {
        return "";
    }
    if (strlen(s) == 1) {
        return s;
    }
    
    int recordArr[26] = {0};
    int len = (int)strlen(s);
    
    //统计每个字符的频次
    for (int i = 0; i < len; ++i) {
        char c = s[i];
        recordArr[c - 'a'] += 1;
    }
    
    char *stack = (char *)malloc(len * sizeof(char) + 1);
    int top = -1;
    
    for (int i = 0; i < len; ++i) {
        char c = s[i];
       
        //判断当前字符是否在栈中已存在
        int n = top;
        int isExist = 0;
        while (n > -1 && stack != NULL) {
            if (stack[n] == c) {
                isExist = 1;
                break;
            }
            n--;
        }
        
        if (isExist == 1) {//如果已存在频度减一
            recordArr[c - 'a']--;
        } else {//如果不存在便加入栈
            //如果栈里面有值，当前值并要小于或等于栈顶值，然后栈顶元素出现的次数大于
           if (top > -1 && c <= stack[top] && recordArr[stack[top] - 'a'] > 1) {
               //跳过该元素，频次要减一
               recordArr[stack[top] - 'a']--;
               //出栈
               top--;
           }
            //否则加入栈中
            top++;
            stack[top] = c;
        }
        
    }
    
    stack[top + 1] = '\0';
    return stack;
}


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("去掉重复字母,并取最小字典许!\n");
    
    char *c = "cbacdcbc";
    
    for (int i = 0; i < strlen(c); i++) {
        printf("%c ", c[i]);
    }
    printf("\n");
    char *newChar = removeDuplicateLetters(c);
    for (int i = 0; i < strlen(newChar); i++) {
          printf("%c ", newChar[i]);
      }
    printf("\n");
    return 0;
}

打印结果：

avatar
文章
阅读
粉丝