算法学习 - 最小栈的实现O(1)时间

  1. //
  2. //  main.cpp
  3. //  MinStack2
  4. //
  5. //  Created by Alps on 14/12/3.
  6. //  Copyright (c) 2014年 chen. All rights reserved.
  7. //
  8. #include <iostream>
  9. #include <vector>
  10. using namespace std;
  11. class MinStack {
  12. public:
  13. vector<int> stack;
  14. int min;
  15. void push(int x) {
  16. if (stack.empty()) {
  17. stack.push_back(0);
  18. min = x;
  19. }else{
  20. stack.push_back(x-min);
  21. if (x < min) {
  22. min = x;
  23. }
  24. }
  25. }
  26. void pop() {
  27. if (stack.empty()) {
  28. return;
  29. }else{
  30. if (stack.back() < 0) {
  31. min = min - stack.back();
  32. }
  33. stack.pop_back();
  34. }
  35. }
  36. int top() {
  37. if (stack.empty()) {
  38. return NULL;
  39. }
  40. if (stack.back() > 0) {
  41. return stack.back()+min;
  42. }else{
  43. return min;
  44. }
  45. }
  46. int getMin() {
  47. if (stack.empty()) {
  48. return NULL;
  49. }
  50. return min;
  51. }
  52. };
  53. int main(int argc, const char * argv[]) {
  54. // insert code here...
  55. std::cout << "Hello, World!\n";
  56. return 0;
  57. }

在边缘测试的时候,我的编译器没出错,但是OJ上报WA了。

  1. //
  2. //  main.cpp
  3. //  MinStack4_leetcode
  4. //
  5. //  Created by Alps on 14/12/3.
  6. //  Copyright (c) 2014年 chen. All rights reserved.
  7. //
  8. #include <iostream>
  9. #include <stack>
  10. using namespace std;
  11. class MinStack{
  12. public:
  13. stack<long> s;
  14. long min;
  15. void push(int x){
  16. if (s.empty()) {
  17. s.push(0);
  18. min = x;
  19. }else{
  20. s.push(x-min);
  21. if (x < min) {
  22. min = x;
  23. }
  24. }
  25. }
  26. void pop(){
  27. if (s.empty()) {
  28. return;
  29. }else{
  30. if (s.top() < 0) {
  31. min = min - s.top();
  32. }
  33. s.pop();
  34. }
  35. }
  36. int top(){
  37. if (s.empty()) {
  38. return NULL;
  39. }else{
  40. if (s.top() > 0) {
  41. return (int)(min+s.top());
  42. }else{
  43. return (int)min;
  44. }
  45. }
  46. }
  47. int getMin(){
  48. if (s.empty()) {
  49. return NULL;
  50. }else{
  51. return (int)min;
  52. }
  53. }
  54. };
  55. int main(int argc, const char * argv[]) {
  56. int a = -2147483648;
  57. MinStack M;
  58. M.push(2147483646);
  59. M.push(2147483646);
  60. M.push(2147483647);
  61. printf("%d\n",M.top());
  62. M.pop();
  63. printf("%d\n",M.getMin());
  64. M.pop();
  65. printf("%d\n",M.getMin());
  66. M.pop();
  67. M.push(2147483647);
  68. printf("%d\n",M.top());
  69. printf("%d\n",M.getMin());
  70. M.push(a);
  71. printf("%d\n",M.top());
  72. printf("%d\n",M.getMin());
  73. M.pop();
  74. printf("%d\n",M.getMin());
  75. return 0;
  76. }

自己写的链表结构体。

  1. //
  2. //  main.cpp
  3. //  MinStack3_leetcode
  4. //
  5. //  Created by Alps on 14/12/3.
  6. //  Copyright (c) 2014年 chen. All rights reserved.
  7. //
  8. #include <iostream>
  9. using namespace std;
  10. class MinStack {
  11. public:
  12. struct StackNode{
  13. int num;
  14. StackNode *next;
  15. };
  16. typedef StackNode* stack;
  17. stack s;
  18. MinStack(){
  19. s = (stack)malloc(sizeof(struct StackNode));
  20. s->next = NULL;
  21. }
  22. int min;
  23. void push(int x) {
  24. if (s->next == NULL) {
  25. stack node = (stack)malloc(sizeof(struct StackNode));
  26. node->num = x;
  27. node->next = s->next;
  28. s->next = node;
  29. min = x;
  30. }else{
  31. stack node = (stack)malloc(sizeof(struct StackNode));
  32. node->num = x;
  33. node->next = s->next;
  34. s->next = node;
  35. if (x < min) {
  36. min = x;
  37. }
  38. }
  39. }
  40. void pop() {
  41. if (s->next == NULL) {
  42. return;
  43. }else{
  44. stack temp = s->next;
  45. if (min == s->next->num && s->next->next != NULL) {
  46. s->next = s->next->next;
  47. free(temp);
  48. min = s->next->num;
  49. for (stack loop = s->next; loop != NULL; loop = loop->next) {
  50. if (min > loop->num) {
  51. min = loop->num;
  52. }
  53. }
  54. }else{
  55. s->next = s->next->next;
  56. free(temp);
  57. }
  58. }
  59. }
  60. int top() {
  61. if (s->next == NULL) {
  62. return NULL;
  63. }
  64. return s->next->num;
  65. }
  66. int getMin() {
  67. if (s->next == NULL) {
  68. return NULL;
  69. }
  70. return min;
  71. }
  72. };
  73. int main(int argc, const char * argv[]) {
  74. MinStack MinS;
  75. MinS.push(-1);
  76. MinS.push(0);
  77. MinS.push(2);
  78. MinS.push(-2);
  79. printf("%d\n",MinS.top());
  80. MinS.pop();
  81. MinS.pop();
  82. MinS.pop();
  83. printf("%d\n",MinS.getMin());
  84. return 0;
  85. }

最古老的版本。

    1. //
    2. //  main.cpp
    3. //  MinStack_leetcode
    4. //
    5. //  Created by Alps on 14/12/2.
    6. //  Copyright (c) 2014年 chen. All rights reserved.
    7. //
    8. #include <iostream>
    9. #include "vector"
    10. using namespace std;
    11. class MinStack {
    12. public:
    13. struct StackNode{
    14. int num;
    15. int min;
    16. };
    17. vector<StackNode> stack;
    18. void push(int x) {
    19. if (stack.empty()) {
    20. StackNode S = {x,x};
    21. stack.push_back(S);
    22. }else{
    23. if (x < stack.back().min) {
    24. StackNode S = {x,x};
    25. stack.push_back(S);
    26. }else{
    27. StackNode S = {x,stack.back().min};
    28. stack.push_back(S);
    29. }
    30. }
    31. }
    32. void pop() {
    33. if (stack.empty()) {
    34. }else{
    35. stack.pop_back();
    36. }
    37. }
    38. int top() {
    39. if (stack.empty()) {
    40. return NULL;
    41. }
    42. return stack.back().num;
    43. }
    44. int getMin() {
    45. if (stack.empty()) {
    46. return NULL;
    47. }
    48. return stack.back().min;
    49. }
    50. };
    51. int main(int argc, const char * argv[]) {
    52. MinStack minstack;
    53. minstack.push(-1);
    54. minstack.push(1);
    55. printf("%d %d\n",minstack.top(), minstack.getMin());
    56. return 0;
    57. }
时间: 2024-10-23 22:50:00

算法学习 - 最小栈的实现O(1)时间的相关文章

算法学习记录-栈的应用--表达式运算

前面做了栈的基本操作 总感觉需要做一个实际的例子来检验一下. 这里我将用栈来做一个简单的四则运算. 目标比较简单: 做一个带小括号(“()”)的四则运算,如果要加入到中括号(“[]”)或者大括号(“{}”),依次类推. 求一个表达式: 用下面这个算是做例子,程序最后应该可以算出任何带小括号的运算. 3+(32-6)*9+5*3-(3*(65-15)/5)+12; 方法一:后缀法. 1.了解中缀和后缀表示法 中缀表示法:刚才的那个算是就是中缀表示法,我们通常看到的数学符号就是中缀表示法,即数字在计

【算法】最小栈

实现一个栈,带有出栈(pop).入栈(push).取最小元素(getMin)三个方法,且时间复杂度均为O(1). 初始想法: 创建 int min = -1,记录栈中最小元素的下标: 第一个元素进栈时,min = 0: 每当新元素进栈,让新元素与 min 下标位置的元素比较大小,min = 较小元素的下标: 调用 getMin 直接返回 min 的值. 这种方式进栈没有问题,而出栈时,若当前最小元素在栈顶并出栈了,用剩下哪个元素的下标顶替当前 min 就不得而知了.所以一旦最小元素的下标出栈,需

算法学习_栈

以蓝书为学习参考,进行的栈的学习 例题1: 实现一个栈,支持Push,Pop和GetMin(查询栈中最小的值)在O(1)完成 算法实现思路:建立两个栈,A存原本的数据,B存以栈底开头的每段数据的最小值 Push(X),在A中插入X,在B中插入min(B的栈顶数据,X).执行GetMin只需要输出B.top()即可 例题2: Input 8 I 2 I -1 I 1 Q 3 L D R Q 2 Output 2 3 //对顶栈算法 #include <bits/stdc++.h> using n

算法学习 - 括号匹配(栈实现)C++

括号匹配是栈最典型的应用了. 其实思路很简单,就是遇到一个左括号就压栈,遇到一个右括号就弹栈,看是否匹配就好了.最后检查下栈里是不是有剩余的括号就行了. 上代码~: // // main.cpp // bracketMatch // // Created by Alps on 14-7-28. // Copyright (c) 2014年 chen. All rights reserved. // #include <iostream> #define ElementType char usi

算法学习 - 后缀表达式 (C++ 栈实现)

后缀表达式就是把一个式子进行树的后序遍历.然后根据这个顺序来求值. 栈来实现的时候很简单. 例如中缀表达式:6 * [ 5 + ( 2 + 3 )  * 8 + 3 ] 则 后缀表达式为:6 5 2 3 + 8 * + 3 + * 下面上代码: // // main.cpp // postfixExpression // // Created by Alps on 14-7-28. // Copyright (c) 2014年 chen. All rights reserved. // #inc

【LeetCode-面试算法经典-Java实现】【155-Min Stack(最小栈)】

[155-Min Stack(最小栈)] [LeetCode-面试算法经典-Java实现][所有题目目录索引] 原题 Design a stack that supports push, pop, top, and retrieving the minimum element in constant time. push(x) – Push element x onto stack. pop() – Removes the element on top of the stack. top() –

算法学习 - 表达树的建立(后缀表达式法),树的先序遍历,中序遍历,后序遍历

表达树就是根据后缀表达式来建立一个二叉树. 这个二叉树的每个叶子节点就是数,真祖先都是操作符. 通过栈来建立的,所以这里也会有很多栈的操作. 树的先序遍历,中序遍历,后序遍历的概念我就不讲了,不会的自行百度,不然也看不懂我的代码. 下面是代码: // // main.cpp // expressionTree // // Created by Alps on 14-7-29. // Copyright (c) 2014年 chen. All rights reserved. // #includ

算法学习三阶段

?? 第一阶段:练经典经常使用算法,以下的每一个算法给我打上十到二十遍,同一时候自己精简代码, 由于太经常使用,所以要练到写时不用想,10-15分钟内打完,甚至关掉显示器都能够把程序打 出来. 1.最短路(Floyd.Dijstra,BellmanFord) 2.最小生成树(先写个prim,kruscal 要用并查集,不好写) 3.大数(高精度)加减乘除 4.二分查找. (代码可在五行以内) 5.叉乘.判线段相交.然后写个凸包. 6.BFS.DFS,同一时候熟练hash 表(要熟,要灵活,代码要

周总结(2017.2.16):第一周算法学习。

周总结:算法学习总结之DFS和BFS 一:DFS算法 目的:达到被搜索结构的叶节点. 定义:假定给定图G的初态是所有的定点都没有访问过,在G中任选一定点V为初始出发点,首先访问出发点并标记,然后依次从V出发搜索V的每个相邻点W,若W未曾出现过,则对W进行深度优先遍历(DFS),知道所有和V有路径相通的定点被访问. 如果从V0开始寻找一条长度为4的路径的话: 思路步骤: 先寻找V0的所有相邻点:dis{v1,v2,v3},V1没有访问过,所以对V1进行深度遍历并将V1标记为访问过,此时路径长度为1