FilesExpand file tree

 master

/

NodeStack.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

183 lines (150 loc) · 3.89 KB

 master

/

NodeStack.java

Top

File metadata and controls

• Code
• Blame

183 lines (150 loc) · 3.89 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

/**

* Implementation of a stack using nodes.

* Unlimited size, no arraylist.

*

* @author Kyler Smith, 2017

*/

public class NodeStack<Item> {

/**

* Entry point for the program.

*/

public static void main(String[] args) {

NodeStack<Integer> Stack = new NodeStack<Integer>();

Stack.push(3);

Stack.push(4);

Stack.push(5);

System.out.println("Testing :");

Stack.print(); // prints : 5 4 3

Integer x = Stack.pop(); // x = 5

Stack.push(1);

Stack.push(8);

Integer y = Stack.peek(); // y = 8

System.out.println("Testing :");

Stack.print(); // prints : 8 1 4 3

System.out.println("Testing :");

System.out.println("x : " + x);

System.out.println("y : " + y);

}

/**

* Information each node should contain.

* @value data : information of the value in the node

* @value head : the head of the stack

* @value next : the next value from this node

* @value previous : the last value from this node

* @value size : size of the stack

*/

private Item data;

private static NodeStack<?> head;

private NodeStack<?> next;

private NodeStack<?> previous;

private static int size = 0;

/**

* Constructors for the NodeStack.

*/

public NodeStack() {

}

private NodeStack(Item item) {

this.data = item;

}

/**

* Put a value onto the stack.

*

* @param item : value to be put on the stack.

*/

public void push(Item item) {

NodeStack<Item> newNs = new NodeStack<Item>(item);

if(this.isEmpty()) {

NodeStack.setHead(new NodeStack<>(item));

newNs.setNext(null);

newNs.setPrevious(null);

} else {

newNs.setPrevious(NodeStack.head);

NodeStack.head.setNext(newNs);

NodeStack.head = newNs;

}

NodeStack.setSize(NodeStack.getSize() + 1);

}

/**

* Value to be taken off the stack.

*

* @return item : value that is returned.

*/

public Item pop() {

Item item = (Item) NodeStack.head.getData();

NodeStack.head = NodeStack.head.getPrevious();

NodeStack.head.setNext(null);

NodeStack.setSize(NodeStack.getSize() - 1);

return item;

}

/**

* Value that is next to be taken off the stack.

*

* @return item : the next value that would be popped off the stack.

*/

public Item peek() {

return (Item) NodeStack.head.getData();

}

/**

* If the stack is empty or there is a value in.

*

* @return boolean : whether or not the stack has anything in it.

*/

public boolean isEmpty() {

return NodeStack.getSize() == 0;

}

/**

* Returns the size of the stack.

*

* @return int : number of values in the stack.

*/

public int size() {

return NodeStack.getSize();

}

/**

* Print the contents of the stack in the following format.

*

* x <- head (next out)

* y

* z <- tail (first in)

* .

* .

* .

*

*/

public void print() {

for(NodeStack<?> n = NodeStack.head; n != null; n = n.previous) {

System.out.println(n.getData().toString());

}

}

/** Getters and setters (private) */

private NodeStack<?> getHead() {

return NodeStack.head;

}

private static void setHead(NodeStack<?> ns) {

NodeStack.head = ns;

}

private NodeStack<?> getNext() {

return next;

}

private void setNext(NodeStack<?> next) {

this.next = next;

}

private NodeStack<?> getPrevious() {

return previous;

}

private void setPrevious(NodeStack<?> previous) {

this.previous = previous;

}

private static int getSize() {

return size;

}

private static void setSize(int size) {

NodeStack.size = size;

}

private Item getData() {

return this.data;

}

private void setData(Item item) {

this.data = item;

}

}