Skip to content

Commit 36a7dd6

Browse files
mohit-gogittermohit-gogitter
authored
Add BalancedParenthesesChecker, NextGreaterElement, and ReverseStack (#473)
1 parent cf19352 commit 36a7dd6

7 files changed

+493
-0
lines changed

‎Algorithms.Tests/Stack/BalancedParenthesesCheckerTests.cs

+124
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,124 @@
1+
using System;
2+
using Algorithms.Stack;
3+
using NUnit.Framework;
4+
5+
namespace Algorithms.Tests.Stack
6+
{
7+
[TestFixture]
8+
public class BalancedParenthesesCheckerTests
9+
{
10+
public static bool IsBalanced(string expression)
11+
{
12+
var checker = new BalancedParenthesesChecker();
13+
return checker.IsBalanced(expression);
14+
}
15+
16+
[Test]
17+
public void IsBalanced_EmptyString_ThrowsArgumentException()
18+
{
19+
// Arrange
20+
var expression = string.Empty;
21+
22+
// Act & Assert
23+
var ex = Assert.Throws<ArgumentException>(() => IsBalanced(expression));
24+
25+
if(ex!=null)
26+
{
27+
Assert.That(ex.Message, Is.EqualTo("The input expression cannot be null or empty."));
28+
}
29+
30+
}
31+
32+
[Test]
33+
public void IsBalanced_ValidBalancedExpression_ReturnsTrue()
34+
{
35+
// Arrange
36+
var expression = "{[()]}";
37+
38+
// Act
39+
var result = IsBalanced(expression);
40+
41+
// Assert
42+
Assert.That(result, Is.EqualTo(true));
43+
}
44+
45+
[Test]
46+
public void IsBalanced_ValidUnbalancedExpression_ReturnsFalse()
47+
{
48+
// Arrange
49+
var expression = "{[(])}";
50+
51+
// Act
52+
var result = IsBalanced(expression);
53+
54+
// Assert
55+
Assert.That(result, Is.EqualTo(false));
56+
}
57+
58+
[Test]
59+
public void IsBalanced_UnbalancedWithExtraClosingBracket_ReturnsFalse()
60+
{
61+
// Arrange
62+
var expression = "{[()]}]";
63+
64+
// Act
65+
var result = IsBalanced(expression);
66+
67+
// Assert
68+
Assert.That(result, Is.EqualTo(false));
69+
}
70+
71+
[Test]
72+
public void IsBalanced_ExpressionWithInvalidCharacters_ThrowsArgumentException()
73+
{
74+
// Arrange
75+
var expression = "{[a]}";
76+
77+
// Act & Assert
78+
var ex = Assert.Throws<ArgumentException>(() => IsBalanced(expression));
79+
if (ex != null)
80+
{
81+
Assert.That(ex.Message, Is.EqualTo("Invalid character 'a' found in the expression."));
82+
}
83+
}
84+
85+
[Test]
86+
public void IsBalanced_SingleOpeningBracket_ReturnsFalse()
87+
{
88+
// Arrange
89+
var expression = "(";
90+
91+
// Act
92+
var result = IsBalanced(expression);
93+
94+
// Assert
95+
Assert.That(result, Is.EqualTo(false));
96+
}
97+
98+
[Test]
99+
public void IsBalanced_SingleClosingBracket_ReturnsFalse()
100+
{
101+
// Arrange
102+
var expression = ")";
103+
104+
// Act
105+
var result = IsBalanced(expression);
106+
107+
// Assert
108+
Assert.That(result, Is.EqualTo(false));
109+
}
110+
111+
[Test]
112+
public void IsBalanced_ExpressionWithMultipleBalancedBrackets_ReturnsTrue()
113+
{
114+
// Arrange
115+
var expression = "[{()}]()";
116+
117+
// Act
118+
var result = IsBalanced(expression);
119+
120+
// Assert
121+
Assert.That(result, Is.EqualTo(true));
122+
}
123+
}
124+
}

‎Algorithms.Tests/Stack/NextGreaterElementTests.cs

+100
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,100 @@
1+
using System;
2+
using Algorithms.Stack;
3+
using NUnit.Framework;
4+
5+
namespace Algorithms.Tests.Stack
6+
{
7+
[TestFixture]
8+
public class NextGreaterElementTests
9+
{
10+
private static int[] FindNextGreaterElement(int[] input)
11+
{
12+
var obj = new NextGreaterElement();
13+
return obj.FindNextGreaterElement(input);
14+
}
15+
16+
[Test]
17+
public void FindNextGreaterElement_InputIsEmpty_ReturnsEmptyArray()
18+
{
19+
// Arrange
20+
int[] input = Array.Empty<int>();
21+
int[] expected = Array.Empty<int>();
22+
23+
// Act
24+
var result = FindNextGreaterElement(input);
25+
26+
// Assert
27+
Assert.That(result, Is.EqualTo(expected));
28+
}
29+
30+
[Test]
31+
public void FindNextGreaterElement_BasicScenario_ReturnsCorrectResult()
32+
{
33+
// Arrange
34+
int[] input = { 4, 5, 2, 25 };
35+
int[] expected = { 5, 25, 25, -1 };
36+
37+
// Act
38+
var result = FindNextGreaterElement(input);
39+
40+
// Assert
41+
Assert.That(result, Is.EqualTo(expected));
42+
}
43+
44+
[Test]
45+
public void FindNextGreaterElement_NoNextGreaterElement_ReturnsCorrectResult()
46+
{
47+
// Arrange
48+
int[] input = { 13, 7, 6, 12 };
49+
int[] expected = { -1, 12, 12, -1 };
50+
51+
// Act
52+
var result = FindNextGreaterElement(input);
53+
54+
// Assert
55+
Assert.That(result, Is.EqualTo(expected));
56+
}
57+
58+
[Test]
59+
public void FindNextGreaterElement_AllElementsHaveNoGreaterElement_ReturnsAllNegativeOnes()
60+
{
61+
// Arrange
62+
int[] input = { 5, 4, 3, 2, 1 };
63+
int[] expected = { -1, -1, -1, -1, -1 };
64+
65+
// Act
66+
var result = FindNextGreaterElement(input);
67+
68+
// Assert
69+
Assert.That(result, Is.EqualTo(expected));
70+
}
71+
72+
[Test]
73+
public void FindNextGreaterElement_InputWithDuplicates_ReturnsCorrectResult()
74+
{
75+
// Arrange
76+
int[] input = { 4, 4, 3, 2, 4 };
77+
int[] expected = { -1, -1, 4, 4, -1 };
78+
79+
// Act
80+
var result = FindNextGreaterElement(input);
81+
82+
// Assert
83+
Assert.That(result, Is.EqualTo(expected));
84+
}
85+
86+
[Test]
87+
public void FindNextGreaterElement_SingleElementArray_ReturnsNegativeOne()
88+
{
89+
// Arrange
90+
int[] input = { 10 };
91+
int[] expected = { -1 };
92+
93+
// Act
94+
var result = FindNextGreaterElement(input);
95+
96+
// Assert
97+
Assert.That(result, Is.EqualTo(expected));
98+
}
99+
}
100+
}

‎Algorithms.Tests/Stack/ReverseStackTests.cs

+84
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
using Algorithms.Stack;
2+
using NUnit.Framework;
3+
using System.Collections.Generic;
4+
5+
6+
namespace Algorithms.Tests.Stack
7+
{
8+
public class ReverseStackTests
9+
{
10+
public static void Reverse<T>(Stack<T> stack)
11+
{
12+
var obj = new ReverseStack();
13+
obj.Reverse(stack);
14+
}
15+
16+
[Test]
17+
public void Reverse_EmptyStack_DoesNotChangeStack()
18+
{
19+
// Arrange
20+
Stack<int> stack = new Stack<int>();
21+
22+
// Act
23+
Reverse(stack);
24+
25+
// Assert
26+
Assert.That(stack.Count, Is.EqualTo(0));
27+
}
28+
29+
[Test]
30+
public void Reverse_SingleElementStack_DoesNotChangeStack()
31+
{
32+
// Arrange
33+
Stack<int> stack = new Stack<int>();
34+
stack.Push(1);
35+
36+
// Act
37+
Reverse(stack);
38+
39+
// Assert
40+
Assert.That(stack.Count, Is.EqualTo(1));
41+
Assert.That(stack.Peek(), Is.EqualTo(1));
42+
}
43+
44+
[Test]
45+
public void Reverse_MultipleElementStack_ReturnsCorrectOrder()
46+
{
47+
// Arrange
48+
Stack<int> stack = new Stack<int>();
49+
stack.Push(1);
50+
stack.Push(2);
51+
stack.Push(3);
52+
// The stack is now [3, 2, 1] (top to bottom)
53+
54+
// Act
55+
Reverse(stack);
56+
57+
// Assert
58+
Assert.That(stack.Count, Is.EqualTo(3));
59+
Assert.That(stack.Pop(), Is.EqualTo(1)); // Should return 1
60+
Assert.That(stack.Pop(), Is.EqualTo(2)); // Should return 2
61+
Assert.That(stack.Pop(), Is.EqualTo(3)); // Should return 3
62+
}
63+
64+
[Test]
65+
public void Reverse_StackWithDuplicates_ReturnsCorrectOrder()
66+
{
67+
// Arrange
68+
Stack<int> stack = new Stack<int>();
69+
stack.Push(1);
70+
stack.Push(2);
71+
stack.Push(1);
72+
// The stack is now [1, 2, 1] (top to bottom)
73+
74+
// Act
75+
Reverse(stack);
76+
77+
// Assert
78+
Assert.That(stack.Count, Is.EqualTo(3));
79+
Assert.That(stack.Pop(), Is.EqualTo(1)); // Should return 1
80+
Assert.That(stack.Pop(), Is.EqualTo(2)); // Should return 2
81+
Assert.That(stack.Pop(), Is.EqualTo(1)); // Should return 1
82+
}
83+
}
84+
}

0 commit comments

Comments
 (0)