public static RandomNode CopyRandomList(RandomNode head)
{
RandomNode current = head;
while (current != null)
{
RandomNode clone = new RandomNode(current.val, null, null);
clone.next = current.next;
current.next = clone;
current = clone.next;
}
current = head;
while (current != null)
{
current.next.random = current.random.next;
current = current.next.next;
}
current = head;
RandomNode newHead = head.next;
while (current != null)
{
RandomNode temp = current.next;
current.next = temp.next;
if (temp.next != null)
{
temp.next = temp.next.next;
}
current = current.next;
}
return(newHead);
}
private bool AddEdgeBetween(RandomNode node1, RandomNode node2)
{
Vector3 n1 = node1.transform.position;
Vector3 n2 = node2.transform.position;
// Find center between nodes
Vector3 centerPos = new Vector3(n1.x + n2.x, 0f, n1.z + n2.z) / 2;
// Find angle
float angle = -Mathf.Atan2(n2.z - n1.z, n2.x - n1.x) * Mathf.Rad2Deg;
//Debug.Log(node1.NodeType + " connecting to " + node2.NodeType + ", angle=" + angle + ", dist=" + UtilGraph.DistanceBetweenNodes(node1.transform, node2.transform));
// Initialize edge
CreateEdge(node1, node2, centerPos, angle);
// Check if any overlaps occured
//Debug.Log("Test: " + edge.CollisionOccured);
//if (edge.CollisionOccured)
//{
// Debug.Log(">>>>>>>>>>>>>>>>> Destroying edge!!");
// Destroy(edge.gameObject);
// return false;
//}
return(true);
}
public RandomNode CopyRandomList(RandomNode head)
{
var dummyHead = new RandomNode(0);
var originalHead = head;
var current = dummyHead;
var kv = new Dictionary <RandomNode, RandomNode>();
while (head != null)
{
current.next = new RandomNode(head.val);
current = current.next;
kv.Add(head, current);
head = head.next;
}
current = dummyHead.next;
while (originalHead != null)
{
if (originalHead.random != null)
{
current.random = kv.GetValueOrDefault(originalHead.random, null);
}
originalHead = originalHead.next;
current = current.next;
}
return(dummyHead.next);
}
public Node Create(NodeType type)
{
Node node = null;
switch (type)
{
case NodeType.Root:
node = new RootNode();
break;
case NodeType.Action:
node = new ActionNode();
break;
case NodeType.Sequencer:
node = new SequencerNode();
break;
case NodeType.Selector:
node = new SelectorNode();
break;
case NodeType.Random:
node = new RandomNode();
break;
case NodeType.RandomSelector:
node = new RandomSelectorNode();
break;
case NodeType.RandomSequencer:
node = new RandomSequencerNode();
break;
case NodeType.Decorator:
node = new DecoratorNode();
break;
case NodeType.Condition:
node = new ConditionNode();
break;
case NodeType.ConditionWhile:
node = new ConditionWhileNode();
break;
default:
Debug.Assert(false, "未定義のノードタイプ");
break;
}
if (node != null)
{
node.Init(idSeed);
Register(idSeed, node);
idSeed += 1;
}
return(node);
}
NodeState SelectRandom()
{
totalSum = 0f;
foreach (RandomNode node in nodes)
{
totalSum += node.percentage;
}
foreach (RandomNode node in nodes)
{
float rand = Random.Range(0, totalSum);
currentNode = node;
randSum = currentNode.percentage;
if (rand <= randSum)
{
currentState = currentNode.node.Evaluate();
if (currentState == NodeState.FAIL)
{
nodes.Remove(node);
return(SelectRandom());
}
return(currentState);
}
totalSum -= currentNode.percentage;
}
return(NodeState.FAIL);
}
//private Dictionary<RandomNode, List<RandomNode>>
public override void CreateEdges(string mode)
{
// Dictionary for counting number of times nodeID has been used - Dict<nodeID, counter>
Dictionary <int, int> nodeUsedCounter = new Dictionary <int, int>();
for (int x = 0; x < nodes.Count; x++)
{
nodeUsedCounter.Add(nodes[x].NodeID, 0);
}
int edgesAdded = 0, overLapCheck = 3;
while (edgesAdded < numberOfEdges || overLapCheck < 0)
{
// Find least used node
int leastUsedNode = 0;
int value = UtilGraph.INF;
foreach (var node in nodeUsedCounter)
{
if (node.Value < value)
{
value = node.Value;
leastUsedNode = node.Key;
}
}
RandomNode node1 = nodes[leastUsedNode];
// Find a random node
RandomNode node2 = nodes[RandomRangeExcept(0, numberOfNodes, leastUsedNode)];
bool extraChance = true;
while (node1.IsNeighborWith(node2) && extraChance)
{
node2 = nodes[RandomRangeExcept(0, numberOfNodes, leastUsedNode)];
if (node1.IsNeighborWith(node2))
{
extraChance = false;
}
}
if (!extraChance)
{
break;
}
// Add edge between nodes (if no collisions with other edges or nodes)
if (AddEdgeBetween(node1, node2))
{
// Update frequency of these nodes
nodeUsedCounter[node1.NodeID] += 1;
nodeUsedCounter[node2.NodeID] += 1;
edgesAdded++;
}
else
{
overLapCheck--;
}
}
}
public void AddNeighbor(RandomNode node)
{
if (!neighbors.Contains(node))
{
neighbors.Add(node);
node.AddNeighbor(this);
}
}
public void RemoveNeighbor(RandomNode node)
{
if (neighbors.Contains(node))
{
neighbors.Remove(node);
node.RemoveNeighbor(this);
}
}
//TODO use NodeType to categorize Types.
public static BaseNode CreateNode(ActionNodeData aData)
{
if (aData.NodeType == null)
{
Debug.LogError("Type not set");
return(null);
}
aData.GUID = string.IsNullOrEmpty(aData.GUID) ? Guid.NewGuid().ToString() : aData.GUID;
aData.OutputPortIDs = aData.OutputPortIDs ?? new List <string>();
//The copy prevent the node to modify the list in the ActionNodeData
List <string> copy = new List <string>();
foreach (var outputPort in aData.OutputPortIDs)
{
copy.Add(outputPort);
}
BaseNode node;
Type type = Type.GetType(aData.NodeType);
if (type == typeof(ChangeSceneNode))
{
node = ChangeSceneNode.Create("Change Scene", aData.Position, aData.GUID, copy);
}
else if (type == typeof(StartNode))
{
node = StartNode.Create("Start Node", aData.Position, aData.GUID, copy);
}
else if (type == typeof(ConditionalNode))
{
node = ConditionalNode.Create("Conditional", aData.Position, aData.GUID, copy);
}
else if (type == typeof(MultiNode))
{
node = MultiNode.Create("Multi Output", aData.Position, aData.GUID, copy);
}
else if (type == typeof(ExitNode))
{
node = ExitNode.Create("Exit Node", aData.Position, aData.GUID, copy);
}
else if (type == typeof(RandomNode))
{
node = RandomNode.Create("Random Node", aData.Position, aData.GUID, copy);
}
else if (type == typeof(TakeObjectNode))
{
node = TakeObjectNode.Create("Take Object", aData.Position, aData.GUID, copy);
}
else
{
throw new NotImplementedException($"Node type {type} not handled in NodeFactory");
}
node?.SetSerializedScript(aData.SerializedScript);
return(node);
}
protected override void onGUI()
{
RandomNode myTarget = (RandomNode)target;
EditorGUIExtension.SimpleBox("", 5, "", delegate()
{
var min = myTarget.Variables.GetByName("Min");
var max = myTarget.Variables.GetByName("Max");
VariableEditor.VariableField(min, null, true);
VariableEditor.VariableField(max, null, true);
});
EditorGUILayout.Space();
}
public DGRandNode(RandomNode rand, StateNode state)
: base(rand, state)
{
if (rand == null)
{
throw new ArgumentNullException("rand");
}
this.mRandomNode = rand;
this.mSlices = new SliceList(this);
this.mSliceAnchors = new AnchorPoint[0];
this.mSliceStrings = new string[0];
this.mSliceCount = 0;
this.mMGH = 7;
this.UpdateVisualization();
}
private RandomNode CopyList(RandomNode head)
{
if (head == null)
{
return(null);
}
RandomNode cur = head;
RandomNode next = null;
while (cur != null)
{
next = cur.next;
cur.next = new RandomNode(cur.value);
cur.next.next = next;
cur = next;
}
cur = head;
RandomNode copyNode = null;
while (cur != null)
{
next = cur.next.next;
cur.next.rand = cur.rand == null ? null : cur.rand.next;
cur = next;
}
RandomNode res = head.next;
cur = head;
while (cur != null)
{
next = cur.next.next;
copyNode = cur.next;
cur.next = next;
copyNode.next = next != null ? next.next : null;
cur = next;
}
return(res);
}
public RandomNode CopyRandomList(RandomNode head)
{
if (head == null)
{
return(null);
}
RandomNode current = head;
while (current != null)
{
RandomNode next = current.next;
current.next = new RandomNode(current.val, next, null);
current = next;
}
current = head;
while (current != null)
{
if (current.random != null)
{
current.next.random = current.random.next;
}
current = current.next.next;
}
current = head;
RandomNode copyHead = head.next;
while (current != null)
{
RandomNode after = current.next.next;
RandomNode copy = current.next;
current.next = after;
if (after != null)
{
copy.next = after.next;
}
current = after;
}
return(copyHead);
}
/// <summary>
/// clone
/// </summary>
/// <returns></returns>
public IBehaviourNode Clone()
{
var behaviourNode = new RandomNode();
base.CopyToCompositeNode(behaviourNode);
return behaviourNode;
}
public RandomNode(int _val)
{
val = _val;
next = null;
random = null;
}
// Start is called before the first frame update
public void ReadTree(TextAsset textAsset)
{
dialogTree = new Dictionary <string, DialogNode>();
dialogFile = textAsset;
dialog = new JSONObject(dialogFile.text);
dialog = dialog[0]["nodes"];
//parses the json file based on node types
foreach (JSONObject n in dialog.list)
{
switch (n[nodeType].str)
{
case "start":
DialogNode a = new DialogNode(n[next].str, DialogNode.NodeType.START);
dialogTree.Add(n[nodeName].str, a);
break;
case "show_message":
if (n[text][lang].str.Contains("\\n"))
{
n[text][lang].str = n[text][lang].str.Replace("\\n", "\n");
}
if (n.keys.Contains("choices"))
{
ChoiceNode c = new ChoiceNode(n[speaker][0].str, n[text][lang].str, n[choices]);
dialogTree.Add(n[nodeName].str, c);
}
else
{
TextBoxNode tb = new TextBoxNode(n[next].str, n[speaker][0].str, n[text][lang].str);
dialogTree.Add(n[nodeName].str, tb);
}
break;
case "chance_branch":
case "random_branch":
if (n.keys.Contains("chance_1"))
{
RandomNode cb = new RandomNode(n[branch], (int)n[chance].i);
dialogTree.Add(n[nodeName].str, cb);
}
else
{
RandomNode rb = new RandomNode((int)n[poss].i, n[branch]);
dialogTree.Add(n[nodeName].str, rb);
}
break;
case "execute":
string function = n[text].str;
string[] inputs = function.Split(',');
CodeNode cn = new CodeNode(n[next].str, Int32.Parse(inputs[0]), inputs[1], inputs[2]);
dialogTree.Add(n[nodeName].str, cn);
break;
default:
DialogNode d = new DialogNode(n[next].str, DialogNode.NodeType.NULL);
dialogTree.Add(n[nodeName].str, d);
break;
}
}
}
private Random <TContext> MapRandomNode(RandomNode node)
{
return(new Random <TContext>(node.Name, Map(node.Child), node.Threshold, node.RandomProvider));
}
void GenerateBehaviors()
{
Animator a = GetAnimator();
////////////////////////////////// Movement //////////////////////////////////
EvadeNode evade = new EvadeNode(this.rB, speed, 0.4f, 25);
IsBlockedNode isBlocked = new IsBlockedNode(transform, evade, 1, 1);
MoveNode move = new MoveNode(rB, target, speed, atkRange);
SequenceNode evading = new SequenceNode(new List <Node>()
{
isBlocked, evade
});
SelectorNode movement = new SelectorNode(new List <Node>()
{
evading, move
});
////////////////////////////////// Death //////////////////////////////////
HealthCheckNode isDead = new HealthCheckNode(this, 0, true);
ClampSuccessNode isDeadClamped = new ClampSuccessNode(isDead);
AnimationNode deathAnim = new AnimationNode(a, "Die");
OnAnimationCompleteNode onDeathAnimComplete = new OnAnimationCompleteNode(a, "Die");
DestroyNode destroy = new DestroyNode(this.gameObject);
SequenceNode death = new SequenceNode(new List <Node> {
isDeadClamped, deathAnim, onDeathAnimComplete, destroy
});
////////////////////////////////// Cover //////////////////////////////////
HealthCheckNode isLow = new HealthCheckNode(this, consideredLowHP, true);
SoundNode hurtSFX = new SoundNode(Sound.SeaMonsterHurt);
RandomNode chanceHurtSFX = new RandomNode(hurtSFX, 0.4f);
ColorFlashNode hurtFlash = new ColorFlashNode(GetMaterial(), Color.red, 3, 1);
RecoverHealthNode hpRecover = new RecoverHealthNode(this, hpRecoveryMultiplier);
FindCover findCover = new FindCover(this, target, 10);
SequenceNode hurting = new SequenceNode(new List <Node>()
{
chanceHurtSFX, hurtFlash
});
SequenceNode recovering = new SequenceNode(new List <Node>()
{
hpRecover, hurting
});
SequenceNode covering = new SequenceNode(new List <Node>()
{
findCover, movement
});
ParallelNode recoveringAndCovering = new ParallelNode(new List <Node>()
{
recovering, covering
}, 2);
SequenceNode cover = new SequenceNode(new List <Node>()
{
isLow, recoveringAndCovering
});
////////////////////////////////// Attack //////////////////////////////////
// Condition To Start Attack Sequence
IsInRangeNode isInATKRange = new IsInRangeNode(atkRange, transform, target);
// Attack Sequence
AnimationNode readyUpAnim = new AnimationNode(a, "Aim");
LookNode aim = new LookNode(rB, target, 1, 12, 7);
AnimationNode strikeAnim = new AnimationNode(a, "Fire");
TimerNode atkTimer = new TimerNode(1);
// Wrapping Nodes
SequenceNode attackPattern = new SequenceNode(new List <Node>()
{
readyUpAnim, aim, strikeAnim, atkTimer
});
ResetOnStateNode resetATK = new ResetOnStateNode(attackPattern, NodeState.SUCCESS);
SequenceNode attacking = new SequenceNode(new List <Node>()
{
isInATKRange, resetATK
});
SelectorNode attack = new SelectorNode(new List <Node>()
{
attacking, movement
});
////////////////////////////////// Patrol //////////////////////////////////
PatrolNode patrolMove = new PatrolNode(rB, Mathf.RoundToInt(speed * 0.7f), 0.5f, 6, 20, 1.5f, 4);
SelectorNode evadeAndPatrol = new SelectorNode(new List <Node>()
{
evading, patrolMove
});
SpotTargetNode spotTarget = new SpotTargetNode(transform, 40, 80, LayerMask.NameToLayer("Target"), LayerMask.NameToLayer("Enemy"));
FlagNode flag = new FlagNode(NodeState.SUCCESS, NodeState.FAILURE);
FlagActivator flagActivator = new FlagActivator(flag);
SequenceNode spotAndStop = new SequenceNode(new List <Node>()
{
spotTarget, flagActivator
});
SelectorNode patroling = new SelectorNode(new List <Node>()
{
spotAndStop, evadeAndPatrol
});
SequenceNode patrol = new SequenceNode(new List <Node>()
{
flag, patroling
});
////////////////////////////////// Top Node //////////////////////////////////
topNode = new Tree(new SelectorNode(new List <Node>()
{
death, cover, patrol, attack
}));
BehaviorTreeManager.AddTree(topNode);
}
public RandomNode(int _val, RandomNode _next, RandomNode _random)
{
val = _val;
next = _next;
random = _random;
}
public RandomNode(int data)
{
this.value = data;
next = null;
}
public RandomNode(int data, RandomNode next, RandomNode rand)
{
this.value = data;
this.next = next;
this.rand = rand;
}
private DGNode InitDGN(DGNode src, DecisionGraphNode dgn)
{
int i;
DGNode dst = null;
for (i = this.mDGraph.NodeCount - 1; i >= 0; i--)
{
dst = this.mDGraph.NodeAt(i);
if (dst.DGN == dgn)
{
break;
}
}
if (i < 0)
{
int j;
DGEdge edge;
AnchorPoint ap;
DecisionGraphNode[] dgns;
DGMulticastNode dgmcn = null;
switch (dgn.ChunkType)
{
case NextStateNode.ResourceType:
NextStateNode nsn = dgn as NextStateNode;
dst = new DGSnSnNode(nsn, this);
this.mDGraph.AddNode(dst);
dst.SetParent(this);
break;
case RandomNode.ResourceType:
RandomNode rand = dgn as RandomNode;
DGRandNode dgrn = new DGRandNode(rand, this);
this.mDGraph.AddNode(dgrn);
dgrn.SetParent(this);
List <RandomNode.Slice> slices = rand.Slices;
if (slices.Count > 0)
{
for (i = 0; i < slices.Count; i++)
{
ap = dgrn.GetSliceAnchor(i);
dgns = slices[i].Targets.ToArray();
for (j = 0; j < dgns.Length; j++)
{
dst = this.InitDGN(dgrn, dgns[j]);
edge = new DGEdge(dgrn, dst, false);
ap.Edges.Add(edge);
dst.EntryAnchor.Edges.Add(edge);
this.mDGraph.AddEdge(edge);
edge.SetParent(this);
}
}
}
dst = dgrn;
break;
case SelectOnDestinationNode.ResourceType:
SelectOnDestinationNode sodn
= dgn as SelectOnDestinationNode;
DGSoDnNode dgsodn
= new DGSoDnNode(sodn, this);
this.mDGraph.AddNode(dgsodn);
dgsodn.SetParent(this);
if (sodn.CaseCount > 0)
{
SelectOnDestinationNode.Case[] cases = sodn.Cases;
for (i = 0; i < cases.Length; i++)
{
ap = dgsodn.GetCaseAnchorAt(i);
dgns = cases[i].Targets;
for (j = 0; j < dgns.Length; j++)
{
dst = this.InitDGN(dgsodn, dgns[j]);
edge = new DGEdge(dgsodn, dst, false);
ap.Edges.Add(edge);
dst.EntryAnchor.Edges.Add(edge);
this.mDGraph.AddEdge(edge);
edge.SetParent(this);
}
}
}
dst = dgsodn;
break;
case SelectOnParameterNode.ResourceType:
SelectOnParameterNode sopn
= dgn as SelectOnParameterNode;
DGSoPnNode dgsopn
= new DGSoPnNode(sopn, this);
this.mDGraph.AddNode(dgsopn);
dgsopn.SetParent(this);
if (sopn.CaseCount > 0)
{
SelectOnParameterNode.Case[] cases = sopn.Cases;
for (i = 0; i < cases.Length; i++)
{
ap = dgsopn.GetCaseAnchorAt(i);
dgns = cases[i].Targets;
for (j = 0; j < dgns.Length; j++)
{
dst = this.InitDGN(dgsopn, dgns[j]);
edge = new DGEdge(dgsopn, dst, false);
ap.Edges.Add(edge);
dst.EntryAnchor.Edges.Add(edge);
this.mDGraph.AddEdge(edge);
edge.SetParent(this);
}
}
}
dst = dgsopn;
break;
case CreatePropNode.ResourceType:
CreatePropNode cpn = dgn as CreatePropNode;
DGPropNode dgcpn = new DGPropNode(cpn, this);
this.mDGraph.AddNode(dgcpn);
dgcpn.SetParent(this);
dgmcn = dgcpn;
break;
case ActorOperationNode.ResourceType:
ActorOperationNode aon = dgn as ActorOperationNode;
DGAcOpNode dgaon = new DGAcOpNode(aon, this);
this.mDGraph.AddNode(dgaon);
dgaon.SetParent(this);
dgmcn = dgaon;
break;
case StopAnimationNode.ResourceType:
StopAnimationNode san = dgn as StopAnimationNode;
DGStopNode dgsan = new DGStopNode(san, this);
this.mDGraph.AddNode(dgsan);
dgsan.SetParent(this);
dgmcn = dgsan;
break;
case PlayAnimationNode.ResourceType:
PlayAnimationNode pan = dgn as PlayAnimationNode;
DGPlayNode dgpan = new DGPlayNode(pan, this);
this.mDGraph.AddNode(dgpan);
dgpan.SetParent(this);
dgmcn = dgpan;
break;
}
if (dgmcn != null)
{
MulticastDecisionGraphNode mcn
= dgn as MulticastDecisionGraphNode;
if (mcn.TargetCount > 0)
{
ap = dgmcn.TargetAnchor;
dgns = mcn.Targets;
for (i = 0; i < dgns.Length; i++)
{
dst = this.InitDGN(dgmcn, dgns[i]);
edge = new DGEdge(dgmcn, dst, false);
ap.Edges.Add(edge);
dst.EntryAnchor.Edges.Add(edge);
this.mDGraph.AddEdge(edge);
edge.SetParent(this);
}
}
dst = dgmcn;
}
}
return(dst);
}
public static void Main(string[] args)
{
//create Stack
var stk = StackHelper.Create(new int[] { 10, 11, 12, 13, 14, 15 });
Console.Write("Create list(10, 11, 12, 13, 14, 15) as Stack :");
StackHelper.PrintAll(stk);
Console.WriteLine("\n");
//Create Queue
var q = QueueHelper.Create(new int[] { 10, 11, 12, 13, 14, 15, 16 });
Console.Write("Create list(10, 11, 12, 13, 14, 15, 16 ) as Queue :");
QueueHelper.PrintAll(q);
Console.WriteLine("\n");
q = QueueHelper.Create(new int[] { 1, 2, 3, 4 });
ReorderList.GetReorderList(q.Head);
//Check list is circular.
bool isCircular = CheckListIsCircular.Check(q.Head);
Console.Write("List(10, 11, 12, 13, 14, 15, 16 ) is Circular?:" + isCircular.ToString());
Console.WriteLine("\n");
//Reverse List
var reversedQ = ReverseList.Reverse(q.Head);
Console.Write("Reversed List( 10->11->12->13->14-> 15->16) Values:");
QueueHelper.PrintAll(reversedQ);
Console.WriteLine("\n");
//SwapNode
q = QueueHelper.Create(new int[] { 10, 11, 12, 13, 14, 15, 16 });
var swapedList = SwapPairs.SwapNodes(q.Head);
Console.Write("Swaped List( 10->11->12->13->14->15->16 ) Values in Pairs:");
QueueHelper.PrintAll(swapedList);
Console.WriteLine("\n");
//Sort Based on actual Value
q = QueueHelper.Create(new int[] { 1, 2, 3, -4, -5, -6, -10 });
var actualValueSorted = SortBasedOnAbsoluteValue.Sort1(q.Head);
Console.Write("Sort Based on Actual values in List(1-> 2->3->-4->-5-> -6-> -10):");
QueueHelper.PrintAll(actualValueSorted);
Console.WriteLine("\n");
//Sort Based on actual Value
q = QueueHelper.Create(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
int k = 3;
var altRevList = AlternativeKNodes.ReverseAlterNativeKNodes(q.Head, k);
Console.Write($"Reversed Alternative {k} Nodes in list(1->2->3->4->5->6->7->8->9->10 ):");
QueueHelper.PrintAll(altRevList);
Console.WriteLine("\n");
//Reverse List
q = QueueHelper.Create(new int[] { 10, 11, 12, 13, 14, 15, 16 });
var reversedRecurQ = ReverseRecursively.Reverse(q.Head);
Console.Write("Reverse List(10->11->12->13->14->15->16) Values Recursively:");
QueueHelper.PrintAll(reversedRecurQ);
Console.WriteLine("\n");
//Merge Two Sorted Queues
var q1 = QueueHelper.Create(new int[] { 1, 5 });
var q2 = QueueHelper.Create(new int[] { 2, 3, 4 });
var mergedList = MergeKSortedLists.MergeRecursive(q1.Head, q2.Head);
Console.Write("Merge list1(1-> 5) and list2( 2->3->4) :");
QueueHelper.PrintAll(mergedList);
Console.WriteLine("\n");
//List Iterator
var listIterator = new ListIterator();
Console.Write("Write List in Order:");
while (listIterator.HasAny())
{
Console.Write(listIterator.Next() + " ");
}
Console.WriteLine("\n");
//deleting the middle node
q = QueueHelper.Create(new int[] { 10, 11, 12, 13, 14, 15, 16 });
var updatedList = DeleteNodeInTheMiddle.DeleteMiddleNode(q.Head);
Console.Write("List(10-> 11->12->13->14->15->16) after deleting the middle node:");
QueueHelper.PrintAll(updatedList);
Console.WriteLine("\n");
//NtheElement from the Last
q = QueueHelper.Create(new int[] { 10, 11, 12, 13, 14, 15, 16 });
int n = 5;
var nthNode = NthElementFromLast.FindNthElementFromLast(q.Head, n);
Console.Write(n + "th element from Last(10->11->12->13->14->15->16):" + nthNode.Val);
Console.WriteLine("\n");
//Double linkedlist
var doubleList = new DoubleList();
doubleList.InsertNode(10);
doubleList.InsertNode(11);
doubleList.InsertNode(12);
doubleList.InsertNode(13);
doubleList.InsertNode(14);
doubleList.PrintList();
Console.WriteLine("\n");
//Circular linkedlist
var circularList = new CircularList();
circularList.SetLoopBackVal(20);
circularList.Insert(10);
circularList.Insert(20);
circularList.Insert(30);
circularList.Insert(40);
circularList.Insert(50);
circularList.SetLoopBack();
//collition node
Node collitionNode = circularList.GetCollitionNode();
Console.Write("Colliding Node in a circular list(10->20->30->40->50->20):" + collitionNode.Val);
Console.WriteLine("\n");
//check a string is palindrum
Palindrum palindrum = new Palindrum();
bool result = palindrum.Check("MALAYALAM");
Console.Write("Is 'MALAYALAM' a Palindrum word:" + result.ToString());
Console.WriteLine("\n");
//TBD
//partition based on a pivot
q = QueueHelper.Create(new int[] { 1, 3, 2, 9, 4, 7, 11, 5 });
int pivot = 4;
var partitionList = PartitionBasedOnPivot.Partition(q.Head, pivot);
Console.Write($"Partition List( 1->3->2->9->4->7->11->5 ) based on Pivot({pivot}) :");
QueueHelper.PrintAll(partitionList);
Console.WriteLine("\n");
//Number addition
LQueue num1 = QueueHelper.Create(new int[] { 8, 7 });
LQueue num2 = QueueHelper.Create(new int[] { 8, 9 });
var sum = NumberListAddition.AddNumList(num1.Head, num2.Head);
Console.Write("List Addition List1(8->7) and List2(8->9):");
QueueHelper.PrintAll(sum);
Console.WriteLine("\n");
var sum1 = NumberListAddition.AddNumListRecursion(num1.Head, num2.Head);
Console.Write("List Addition List1(8->7) and List2(8->9) Recursively:");
QueueHelper.PrintAll(sum);
Console.WriteLine("\n");
//RandomNode r1 = new RandomNode();
//r1.val = 1;
//RandomNode r2 = new RandomNode();
//r2.val = 2;
//RandomNode r3 = new RandomNode();
//r3.val = 3;
//RandomNode r4 = new RandomNode();
//r4.val = 4;
//RandomNode r5 = new RandomNode();
//r5.val = 5;
//r1.next = r2;
//r2.next = r3;
//r3.next = r4;
//r4.next = r5;
//r5.next = null;
//r1.random = r4;
//r2.random = r1;
//r3.random = r5;
//r4.random = r2;
//r5.random = r3;
RandomNode r1 = new RandomNode();
r1.val = 1;
RandomNode r2 = new RandomNode();
r2.val = 2;
r1.next = r2;
r2.next = null;
r1.random = r2;
r2.random = r2;
var clone = CloneListWithRandomPtr.CopyRandomList(r1);
q = QueueHelper.Create(new int[] { 1, 2, 3, 4, 5, 6, 7 });
var oddEvenList = OddEvenLinkedList.GetOddEvenList(q.Head);
LRUCache lru = new LRUCache(4);
lru.put(1, 1);
lru.put(2, 2);
lru.put(3, 3);
lru.put(4, 4);
lru.put(4, 5);
var s1 = q = QueueHelper.Create(new int[] { 1, 3, 5 });
var s2 = q = QueueHelper.Create(new int[] { 2, 4 });
var merged = MergeKSortedLists.Merge(s1.Head, s2.Head);
Console.ReadLine();
}
public RandomNode(int _val)
{
this.val = _val;
this.next = null;
this.random = null;
}
void OnEnable()
{
rn = target as RandomNode;
rn.GetChildNodes();
}
public bool IsNeighborWith(RandomNode node)
{
return(neighbors.Contains(node));
}
