一、实现一个特殊的栈,在实现栈的基本功能的基础上,再实现返回栈中最小元素的操作

请指教交流!

 1 package com.it.hxs.c01;
 2
 3 import java.util.Stack;
 4
 5 /*
 6  实现一个特殊的栈,在实现栈的基本功能的基础上,再实现返回栈中最小元素的操作
 7  */
 8 public class GetMinStack {
 9
10     public static void main(String args[]) {
11         GetMinStack demoStack = new GetMinStack();
12         demoStack.push("1");
13         demoStack.push("2");
14         demoStack.push("");
15         System.out.println(demoStack.getMin());
16         System.out.println(demoStack.pop());
17         System.out.println(demoStack.getMin());
18     }
19
20     private Stack<String> stringStack;
21     private Stack<Integer> intStack;
22     private Stack<String> minStack;
23
24     public GetMinStack() {
25         this.stringStack = new Stack<String>();
26         this.intStack = new Stack<Integer>();
27         this.minStack = new Stack<String>();
28     }
29
30     public void push(String content) {
31         if ("".equals(content)||content == null) {
32             throw new RuntimeException("添加的元素值不能为空!");
33         } else {
34             int data = string2ASCII(content);
35             stringStack.push(content);
36             if (!intStack.isEmpty()) {
37                 int curIntStackData = intStack.peek();
38                 if (curIntStackData >= data) {// 数值栈intStack中最上面元素大于当前推入元素,则当前元素为最小,则当前元素推入最小元素栈minStack
39                     minStack.push(content);
40                 } else {
41                     minStack.push(minStack.peek());
42                 }
43             } else {
44                 minStack.push(content);
45             }
46             intStack.push(data);
47         }
48     }
49
50     public String pop() {
51         String result = "无元素";
52         if (!intStack.isEmpty()) {
53             intStack.pop();
54         }
55         if (!minStack.isEmpty()) {
56             minStack.pop();
57         }
58         if (!stringStack.isEmpty()) {
59             result = stringStack.pop();
60         }
61         return result;
62     }
63
64     public String getMin() {
65         String result = "无元素";
66         if (!minStack.isEmpty()) {
67             result = minStack.peek();
68         }
69         return result;
70     }
71
72     // 字符串转ASCII
73     public static int string2ASCII(String content) {
74         int result = 0;
75         char[] chars = content.toCharArray();
76         for (char c : chars) {
77             int temp = (int) c;
78             result = result + temp;
79         }
80         return result;
81     }
82
83 }
时间: 2024-10-19 14:17:44

一、实现一个特殊的栈,在实现栈的基本功能的基础上,再实现返回栈中最小元素的操作的相关文章

[算法]求栈中最小元素

如何用O(1)的时间复杂度求栈中最小元素 解题思路: 我们经常会采用空间换取时间提高时间复杂度.我们可以使用两个栈结构,一个栈用来存储数据,另一个栈用来存储栈中的最小元素.思路如下:如果当前入栈的元素比原来栈中的最小值还小,则把这个值压入保存最小元素的栈中:在出栈时,如果当前入栈的元素恰好为当前栈中的最小值,保存最小值的栈顶元素也出栈,使得当前最小值变为其入栈之前的那个最小值. 实现代码如下: package 求栈中最小元素; /** * 用链表方式实现栈 * @author dream * *

编程之美 - 写一个函数,返回数组中所有元素被第一个元素除的结果

问题: 写一个函数,返回数组中所有元素被第一个元素除的结果,包含第一个元素,也要自己除自己 分析: 主要注意两点:1,判断输入是否合法:2,判断除数是否为0:3,从后往前除(真猥琐) 代码实现: 1 /* div_array.cc 2 * 2014/09/03 create 3 * 写一个函数,返回数组中所有元素被第一个元素除的结果,包含第一个元素,也要自己除自己 4 */ 5 #include <iostream> 6 using namespace std; 7 8 void div_ar

O(1)时间复杂度实现入栈、出栈、获得栈中最小元素、获得栈中最大元素(转)

题目要求:定义栈的数据结构,添加min().max()函数(动态获取当前状态栈中的最小元素.最大元素),要求push().pop().min().max()的时间复杂度都是O(1). 思路解析:根据栈的后进先出特性,增加辅助栈,来存储当前状态下数据栈中的最小.最大元素. 原文:http://blog.csdn.net/happy309best/article/details/47725935

在实现栈中原来功能的基础上,获得一个栈中最小值,要求时间复杂度 bigO(1)

思路: 准备两个栈 stackData stackMin 1 package my_basic; 2 3 import java.util.Stack; 4 5 public class GetMinStack { 6 Stack<Integer> stackData = new Stack<Integer>(); 7 Stack<Integer> stackMin = new Stack<Integer>(); 8 9 public void push(i

如何在多实例基础上再添加一个mysql的实例

1)创建数据文件所需的目录 # mkdir -p /data/3308/data # cp /data/3306/my.cnf /data/3308 # cp /data/3306/mysql /data/3308 2)配置权限 # chown mysql.mysql /data/3308 -R # chown root.root /data/3308/mysql  # chmod 700 /data/3308/mysql 3)修改数据配置文件及启动脚本 # sed -i 's/3306/330

编写一个程序,求出整数数组中最小元素的下标。如果这样的元素个数大于1,则返回下标最小的数的下标。

int[] num = new int[]{5,6,1,4,3,6,7,8,92,6};  int min = num[0];  int n = 0;  for (int i = 0; i < num.length; i++) {   if(num[i]<min){    min = num[i];    n = i;   }     }  System.out.println("最小數的下标为:" + n);

实现栈最小元素的min函数

1 #include<iostream> 2 #include<stack> 3 using namespace std; 4 class min_stack 5 { 6 public: 7 void push(int); 8 void pop(); 9 int min(); 10 int size() 11 { 12 return data.size(); 13 } 14 private: 15 stack<int> data; 16 stack<int>

用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型

import java.util.Stack; /**  * 用两个栈来实现一个队列,完成队列的Push和Pop操作. 队列中的元素为int类型.  * @author user  *  *思路:队列是先入先出,栈是先入后出,可以将数据压入第一个栈后,在弹出来压入第二个栈,弹得时候直接从第二个栈弹出,弹出后又将  *第二个栈中的所有数据弹出重新压入的一个栈  */ public class Solution {     Stack<Integer> stack1 = new Stack<

011实现一个栈,除了push和pop操作,还要实现min函数以返回栈中的最小值,时间复杂度都为O(1)(keep it up)

实现一个栈,除了push和pop操作,还要实现min函数以返回栈中的最小值. push,pop和min函数的时间复杂度都为O(1). 看到这个题目最直接的反应是用一个变量来保存当前栈的最小值,让我们来看看这样可行否? 如果栈一直push那是没有问题,入栈元素如果比当前最小值还小,那就更新当前最小值. 可是如果pop掉的栈顶元素就是最小值,那么我们如何更新最小值呢?显然不太好办. 既然只用一个变量没法解决这个问题,那我们就增加变量.如果说每个结点除了保存当前的 值, 另外再保存一个从该结点到栈底的