Подскажите пжл почему не принимает ответ? Уже 5 день ищую :( /* Свой список Посмотреть, как реализован LinkedList. Элементы следуют так: 1->2->3->4 и так 4->3->2->1 По образу и подобию создать Solution. Элементы должны следовать так: 1->3->7->15 ->8... ->4->9 ->10 2->5->11 ->12 ->6->13 ->14 Удалили 2 и 9 1->3->7->15 ->8 ->4->10 Добавили 16,17,18,19,20 (всегда добавляются на самый последний уровень к тем элементам, которые есть) 1->3->7->15 ->16 ->8->17 ->18 ->4->10->19 ->20 Удалили 18 и 20 1->3->7->15 ->16 ->8->17 ->4->10->19 Добавили 21 и 22 (всегда добавляются на самый последний уровень к тем элементам, которые есть. Последний уровень состоит из 15, 16, 17, 19. 19 последний добавленный элемент, 10 - его родитель. На данный момент 10 не содержит оба дочерних элемента, поэтому 21 добавился к 10. 22 добавляется в следующий уровень.) 1->3->7->15->22 ->16 ->8->17 ->4->10->19 ->21

Во внутренней реализации элементы должны добавляться по 2 на каждый уровень Метод getParent должен возвращать элемент, который на него ссылается. Например, 3 ссылается на 7 и на 8, т.е. getParent("8")=="3", а getParent("13")=="6" Строки могут быть любыми. При удалении элемента должна удаляться вся ветка. Например, list.remove("5") должен удалить "5", "11", "12" Итерироваться элементы должны в порядке добавления Доступ по индексу запрещен, воспользуйтесь при необходимости UnsupportedOperationException Должно быть наследование AbstractList<string>, List<string>, Cloneable, Serializable Метод main в тестировании не участвует */ public class Solution extends AbstractList<string> implements List<string>, Cloneable, Serializable { public static ArrayList<node> allNodes = new ArrayList<node>(); //все узлы кучи

    public static void main(String[] args) {
        List<String> list = new Solution();
        for (int i = 1; i < 16; i++) {
            list.add(String.valueOf(i));
        }
        System.out.println("Expected 3, actual is " + ((Solution) list).getParent("8"));
        ((Solution) list).remove("3");
        System.out.println("Expected null, actual is " + ((Solution) list).getParent("11"));
        ((Solution) list).add("16");
        ((Solution) list).add("17");
        ((Solution) list).add("18");

//        for(Node allNode : allNodes){
//            try{
//                System.out.println(allNode);
//            }catch(NullPointerException e){
//            }
//
//        }
    }

    public String getParent(String value) {
        String resultParent = "null";
        for(int i = 0;i < allNodes.size(); i++ ){
             Node curentNode = allNodes.get(i);
             String chekingVal = (String) curentNode.getValue();
             if(value.equals(chekingVal)){
                 resultParent = curentNode.getParentValue();
             }
        }

        return resultParent;
    }

    @Override
    public boolean remove(Object o)
    {
        String rmvInd = (String)o;
        for(int i = 0;i < allNodes.size(); i++ ){
            Node curentNode = allNodes.get(i);
            String chekingVal = (String) curentNode.getValue();
            if(rmvInd.equals(chekingVal)){ //нашли нужный узел удаляем
                curentNode.cascadeRemove();
            }
        }
        return true;
    }

    @Override
    public int hashCode()
    {
        return super.hashCode();
    }

    public Solution(){
        new Node();
    }

    @Override
    public boolean add(String s)
    {
        new Node(s);
        return true;
    }

    @Override
    public String set(int index, String element)
    {
        return super.set(index, element);
    }

    @Override
    public String remove(int index)
    {
        return super.remove(index);
    }

    @Override
    public int indexOf(Object o)
    {
        return super.indexOf(o);
    }

    @Override
    public int lastIndexOf(Object o)
    {
        return super.lastIndexOf(o);
    }

    @Override
    public void clear()
    {
        super.clear();
    }

    @Override
    public boolean addAll(int index, Collection<? extends String> c)
    {
        return super.addAll(index, c);
    }

    @Override
    public Iterator<String> iterator()
    {
        return super.iterator();
    }
    private class MyIterator implements Iterator<Node>{
        int index = 0;

        MyIterator(){}

        @Override
        public boolean hasNext()
        {
            try{
                Node nextNode = allNodes.get(index+1);
            }catch (IndexOutOfBoundsException e){
                return false;
            }
            return true;
        }

        @Override
        public Node next()
        {
            index++;
            Node nextNode = allNodes.get(index);
            return nextNode;
        }

        @Override
        public void remove()
        {
            allNodes.remove(index);
        }
    }

    @Override
    public ListIterator<String> listIterator()
    {
        return super.listIterator();
    }

    @Override
    public ListIterator<String> listIterator(int index)
    {
        return super.listIterator(index);
    }

    @Override
    public List<String> subList(int fromIndex, int toIndex)
    {
        return super.subList(fromIndex, toIndex);
    }

    @Override
    public String get(int index)
    {
        throw new UnsupportedOperationException();
    }

    @Override
    public int size()
    {
        return allNodes.size();
    }
}

package com.javarush.test.level20.lesson10.bonus04;

import java.util.ArrayList;

/**
 * Created by Администратор on 03.10.2016.
 */
class Node
{
    private Node parent;
    private Node rightNode;
    private Node leftNode;
    private String value;
    private int numberOfElement = -1;
    private static int nextNumber = -1;
    private static ArrayList<Node> nodesForFillOnNextLevel = new ArrayList<Node>();

    public Node()
    { //для первого узла
        if(nextNumber < 0){
            this.parent = null;
            this.rightNode = null;
            this.leftNode = null;
            this.value = null;
            numberOfElement = 0; //фактический это ID
            nextNumber = 0;
            nodesForFillOnNextLevel.add(this);
        }
    }

    public Node(String value)
    {
        Node newParent = nodesForFillOnNextLevel.get(0); //Выбираем родителя из списка еще не присвоинных
            if(newParent.getLeftNode() == null){
                this.numberOfElement = nextNumber++;
                    this.parent = newParent;
                    parent.setLeftNode(this);
                this.value = value;
                nodesForFillOnNextLevel.add(this);
                Solution.allNodes.add(this);
            }else if(newParent.getRightNode() == null){
                this.numberOfElement = nextNumber++;
                this.parent = newParent;
                this.value = value;
                parent.setRightNode(this);
                nodesForFillOnNextLevel.add(this);
                Solution.allNodes.add(this);
            }else if(newParent.leftNode != null && newParent.rightNode != null){
//                System.out.println("У родителя "+newParent.value+" и правый и левый узлы уже заполнены. Левый "+newParent.getLeftNode().value+" Правый "+newParent.getRightNode().value);
                nodesForFillOnNextLevel.remove(0); //Удаляем из списка узел к которому уже привязаны и правый и левый ребенок (в данном списке содержатся только узлы к которым ещё предстоит привязать ребенка)
                new Node(value); //Создаем следующий подуровень
            }

    }
    public void cascadeRemove(){

        for(int i = Solution.allNodes.size()-1;i > 0; i-- ){
            Boolean havetoRemoved = false;
            Node checkingNode       = Solution.allNodes.get(i); //Анализируемый узел
            Node checkingParentNode = Solution.allNodes.get(i); //Проверяем родителя узла
            while(checkingParentNode.parent != null){
                if(checkingParentNode.equals(this)){
                    havetoRemoved =true;
                }
                checkingParentNode = checkingParentNode.parent; //поднимаемся на уровень выше
            }
            if(havetoRemoved){
                for(int j = 0; j < nodesForFillOnNextLevel.size();j++){
                    Node forRem = nodesForFillOnNextLevel.get(j);
                    if(forRem.equals(checkingNode)){
                        nodesForFillOnNextLevel.remove(j);
                        nodesForFillOnNextLevel.trimToSize();
                        break;
                    }
                }
                Solution.allNodes.remove(i);
                checkingNode.revome();
                havetoRemoved = false;
            }
        }
        this.revome();
        Solution.allNodes.trimToSize(); //Делаем с опазданием чтоб не сбить нумерацию
    }
    private void revome(){
        this.parent = null;
        this.rightNode = null;
        this.leftNode = null;
        this.value = null;
        this.numberOfElement = Integer.MAX_VALUE;

    }

    public Node getRightNode()
    {
        return rightNode;
    }

    public void setRightNode(Node rightNode)
    {
        this.rightNode = rightNode;
    }

    public Node getLeftNode()
    {
        return leftNode;
    }

    public void setLeftNode(Node leftNode)
    {
        this.leftNode = leftNode;
    }

    public String getValue()
    {
        return value;
    }

    public String getParentValue()
    {
        Node upLevel = this.parent;
        String parentValue = (String) upLevel.value;
        return parentValue;
    }

    @Override
    public boolean equals(Object o)
    {
        if (this == o) return true;
        if (!(o instanceof Node)) return false;

        Node node = (Node) o;

        if (numberOfElement != node.numberOfElement) return false;
        if (parent != null ? !parent.equals(node.parent) : node.parent != null) return false;
        if (rightNode != null ? !rightNode.equals(node.rightNode) : node.rightNode != null) return false;
        if (leftNode != null ? !leftNode.equals(node.leftNode) : node.leftNode != null) return false;
        return value != null ? value.equals(node.value) : node.value == null;

    }

    @Override
    public int hashCode()
    {
        int result = parent != null ? parent.hashCode() : 0;
        result = 31 * result + (rightNode != null ? rightNode.hashCode() : 0);
        result = 31 * result + (leftNode != null ? leftNode.hashCode() : 0);
        result = 31 * result + (value != null ? value.hashCode() : 0);
        result = 31 * result + numberOfElement;
        return result;
    }

    @Override
    public String toString()
    {
        return "Node Value = "+(this.value != null ? this.value : "null")+" parent value ="+(this.parent.value != null? this.parent.value : "null");
    }
}

задан 14 Окт '16, 16:23

IvanZ's gravatar image

IvanZ
16718
одобрено: 37%

закрыто 13 Сен, 13:33

AndyRad's gravatar image

AndyRad
13.1k29

Вопрос был закрыт по следующей причине: "Problem is not reproducible or outdated" AndyRad 13 Сен, 13:33


"Доступ по индексу запрещён."
Это значит, что ВСЕ методы с доступом по индексу должны бросать исключение, а не только get.
listIterator, subList, indexOf и тому подобные...

Сам код не тестил и не вникал, это только то, что сразу в глаза бросилось.

ссылка

опубликован 14 Окт '16, 17:12

S_V_S's gravatar image

S_V_S
764
одобрено: 60%

Следить за вопросом

По Email:

После авторизации вы сможете подписаться на любые обновления здесь

Основы Markdown

  • *italic* or _italic_
  • **bold** or __bold__
  • ссылка:[текст](http://url.com/ "заголовок")
  • изображение?![alt текст](/path/img.jpg "заголовок")
  • нумерованный список: 1. Foo 2. Bar
  • Для того чтобы добавить разрыв строки просто добавьте два пробела.
  • основные HTML тэги, также поддерживаются

Тэги:

×27
×5

Задан: 14 Окт '16, 16:23

Просмотров: 267 раз

Отредактирован: 13 Сен, 13:33