Ejemplo n.º 1
0
 public bool QIsEmpty(LQueue pq)
 {
     if (pq.front == null)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Ejemplo n.º 2
0
        static void Main(string[] args)
        {
            LQueue q1 = new LQueue();

            Task <int> task1 = new Task <int>(() => q1.Pop());

            task1.Start();
            Task task2 = new Task(() => q1.Push(5));

            task2.Start();

            Console.WriteLine(task1.Result.ToString());
            Console.ReadKey();
        }
Ejemplo n.º 3
0
        public void BFS()
        {
            LQueue    que    = new LQueue();
            BTreeNode tempbt = new BTreeNode();

            tempbt = this;
            que.Enqueue(tempbt);
            while (tempbt != null)
            {
                if (tempbt.left != null)
                {
                    que.Enqueue(tempbt.left);
                }

                if (tempbt.right != null)
                {
                    que.Enqueue(tempbt.right);
                }

                print(tempbt.data);
                tempbt = que.Dequeue();
            }
        }
Ejemplo n.º 4
0
        public List <PathNode> BreadthFirstSearch(Node From, Node To)
        {
            List <PathNode> LPathNodes = new List <PathNode>();

            // Se acontecer de não achar a comida ou a cabeça da snake no algoritmo, retorno um caminho vazio, para evitar exceções
            if (From == null || To == null)
            {
                return(LPathNodes);
            }

            // variavel que controla quando encontrei a comida
            bool FoodAlreadyInPath = false;

            PriorityQueue <int, Node> LQueue = new PriorityQueue <int, Node>();

            // adiciono o inicio na fila
            From.Visited = true;
            LQueue.Enqueue(Heuristica(From.Info as Pixel, To.Info as Pixel), 0, From);

            while (LQueue.Count > 0)
            {
                Node LNode = LQueue.Dequeue();

                // Procuro o caminho evitando o corpo da snake e o caminho que está sendo utilizado no momento
                foreach (Edge edge in LNode.Edges.Where(t => !t.To.Visited && t.To.NodeType != NodeType.Snake && !t.To.InPath))
                {
                    edge.To.Visited = true;
                    edge.To.Parent  = LNode;

                    // se encontrei o final
                    if (edge.To.Equals(To))
                    {
                        // gero o caminho entre o inicio e o fim
                        LPathNodes = GetPathNodes(From, To);

                        // reseto tudo
                        LQueue = new PriorityQueue <int, Node>();
                        ResetGraph();

                        // indico que encontrei a comida, para entrar no proximo if
                        FoodAlreadyInPath = true;

                        // adiciono a comida na fila, pq meu caminho não termina na comida, e sim um pouco mais para frente
                        LQueue.Enqueue(Heuristica(edge.To.Info as Pixel, To.Info as Pixel), 0, edge.To);

                        break;
                    }

                    // se a comida já foi encontrada
                    if (FoodAlreadyInPath)
                    {
                        // faço o caminho do node atual até a comida
                        var AfterFood = GetPathNodes(To, edge.To);

                        // decidi utilizar mais 7 nodes dps da comida, cheguei nesse numero testando
                        if (AfterFood.Count >= 5)
                        {
                            LPathNodes.AddRange(AfterFood);

                            // limpo a fila para parar o algoritmo
                            LQueue = new PriorityQueue <int, Node>();

                            // saio do loop
                            break;
                        }
                    }

                    // senão sai do loop antes, continuo normalmente
                    LQueue.Enqueue(Heuristica(edge.To.Info as Pixel, To.Info as Pixel), 0, edge.To);
                }
            }

            // reseto o caminho antigo
            Graph.Nodes.ForEach(o => o.InPath = false);

            // marco o novo caminho, para que não seja utilizado na proxima execução
            LPathNodes.Select(s => s.currNode).ToList().ForEach(t => ((Node)t).InPath = true);

            // retorno o caminho
            return(LPathNodes);
        }