《Java语言程序设计与数据结构》编程练习答案（第二十四章）（一）

《Java语言程序设计与数据结构》编程练习答案（第二十四章）（一）

英文名：Introduction to Java Programming and Data Structures, Comprehensive Version, 11th Edition

24.1

public class book {


    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

    }


}

interface MyList<T> extends Collection<T>{
    public void add(int index, T e);

    public T get(int index);

    public int indexOf(Object o);

    public int lastIndexOf(Object o);

    public T remove(int index);

    public T set(int index, T e);

    @Override
    public default boolean add(T e){
        add(size(), e);
        return true;
    }

    @Override
    public default boolean isEmpty(){
        return size() == 0;
    }

    @Override
    public default boolean remove(Object e){
        if(indexOf(e) >= 0){
            remove(indexOf(e));
            return true;
        }
        else
            return false;
    }

    @Override
    public default boolean containsAll(Collection<?> c){
        for (Object o : c) {
            if (indexOf(o) == -1) {
                return false;
            }
        }
        return true;
    }

    @Override
    public default boolean addAll(Collection<? extends T> c){
        for(T t: c){
            add(t);
        }
        return true;
    }

    @Override
    public default boolean removeAll(Collection<?> c){
        for(Object o: c){
            remove(o);
        }
        return true;
    }

    @Override
    public default boolean retainAll(Collection<?> c){
        for(T t:this){
            if(!c.contains(t)){
                remove(t);
            }
        }
        return true;
    }

    @Override
    public default Object[] toArray(){
        ArrayList<T> tmp = new ArrayList<>(this);
        return tmp.toArray();
    }

    @Override
    public default <E> E[] toArray(E[] array){
        ArrayList<T> tmp = new ArrayList<>(this);
        return tmp.toArray(array);
    }
}

24.2

public class book {


    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

    }


}

interface MyList<T> extends Collection<T>{
    public void add(int index, T e);

    public T get(int index);

    public int indexOf(Object o);

    public int lastIndexOf(Object o);

    public T remove(int index);

    public T set(int index, T e);

    @Override
    public default boolean add(T e){
        add(size(), e);
        return true;
    }

    @Override
    public default boolean isEmpty(){
        return size() == 0;
    }

    @Override
    public default boolean remove(Object e){
        if(indexOf(e) >= 0){
            remove(indexOf(e));
            return true;
        }
        else
            return false;
    }

    @Override
    public default boolean containsAll(Collection<?> c){
        for (Object o : c) {
            if (indexOf(o) == -1) {
                return false;
            }
        }
        return true;
    }

    @Override
    public default boolean addAll(Collection<? extends T> c){
        for(T t: c){
            add(t);
        }
        return true;
    }

    @Override
    public default boolean removeAll(Collection<?> c){
        for(Object o: c){
            remove(o);
        }
        return true;
    }


    @Override
    public default Object[] toArray(){
        ArrayList<T> tmp = new ArrayList<>(this);
        return tmp.toArray();
    }

    @Override
    public default <E> E[] toArray(E[] array){
        ArrayList<T> tmp = new ArrayList<>(this);
        return tmp.toArray(array);
    }
}

class MyLinkedList<T> implements MyList<T>{

    private Node<T> head, tail;
    private int size = 0;

    @Override
    public void add(int index, T e) {

    }


    @Override
    public T remove(int index) {
        return null;
    }

    @Override
    public int size() {
        return 0;
    }


    @Override
    public Iterator<T> iterator() {
        return null;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public boolean contains(Object e){
        Node<T> current = head;
        while(current!=null){
            if(current.element.equals(e)){
                return true;
            }
            current = current.next;
        }
        return false;
    }

    @Override
    public T get(int index){
        Node<T> current = head;
        for(int i=0;i<index;i++){
            if(current == null){
                return null;
            }else{
                current = current.next;
            }
        }
        return current.element;
    }

    @Override
    public int indexOf(Object e){
        Node<T> current = head;
        int i=0;
        while(current!=null){
            if(current.element.equals(e)){
                return i;
            }
            i++;
            current = current.next;
        }
        return -1;
    }

    @Override
    public int lastIndexOf(Object e){
        int ret = -1;
        Node<T> current = head;
        int currentIndex = 0;
        while(current!=null){
            if(current.element.equals(e)){
                ret = currentIndex;
            }
            currentIndex++;
            current = current.next;
        }
        return ret;
    }
    
    @Override
    public T set(int index, T e){
        Node<T> current = head;
        for(int i=0;i<index;i++){
            if(current == null){
                return null;
            }else{
                current = current.next;
            }
        }
        T ret = current.element;
        current.element = e;
        return ret;
    }

    private static class Node<T>{
        T element;
        Node<T> next;
        public Node(T e){
            element = e;
        }
    }

}

24.3

public class book {


    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

    }


}

interface MyList<T> extends Collection<T>{
    public void add(int index, T e);

    public T get(int index);

    public int indexOf(Object o);

    public int lastIndexOf(Object o);

    public T remove(int index);

    public T set(int index, T e);

    @Override
    public default boolean add(T e){
        add(size(), e);
        return true;
    }

    @Override
    public default boolean isEmpty(){
        return size() == 0;
    }

    @Override
    public default boolean remove(Object e){
        if(indexOf(e) >= 0){
            remove(indexOf(e));
            return true;
        }
        else
            return false;
    }

    @Override
    public default boolean containsAll(Collection<?> c){
        for (Object o : c) {
            if (indexOf(o) == -1) {
                return false;
            }
        }
        return true;
    }

    @Override
    public default boolean addAll(Collection<? extends T> c){
        for(T t: c){
            add(t);
        }
        return true;
    }

    @Override
    public default boolean removeAll(Collection<?> c){
        for(Object o: c){
            remove(o);
        }
        return true;
    }


    @Override
    public default Object[] toArray(){
        ArrayList<T> tmp = new ArrayList<>(this);
        return tmp.toArray();
    }

    @Override
    public default <E> E[] toArray(E[] array){
        ArrayList<T> tmp = new ArrayList<>(this);
        return tmp.toArray(array);
    }
}

class TwoWayLinkedList<T> implements MyList<T>{

    private Node<T> head,tail;
    private int size = 0;

    public TwoWayLinkedList(){

    }

    @Override
    public void add(int index, T e) {
        if(index == 0){
            addFirst(e);
        }else if(index >= size){
            addLast(e);
        }else{
            Node<T> current = head;
            for(int i=1;i<index;i++){
                current = current.next;
            }
            Node<T> tmp = current.next;
            current.next = new Node<>(e);
            (current.next).previous = tmp.previous;
            (current.next).next = tmp;
            tmp.previous = current.next;
            size++;
        }
    }

    public void addFirst(T e){
        Node<T> newNode = new Node<>(e);
        newNode.next = head;
        head.previous = newNode;
        size++;
        if(tail == null){
            tail = head;
        }
    }

    public void addLast(T e){
        Node<T> newNode = new Node<>(e);
        if(tail == null){
            head = tail = newNode;
        }
        else{
            tail.next = newNode;
            newNode.previous = tail;
            tail = newNode;
        }
        size++;
    }

    @Override
    public T get(int index) {
        if(index < 0 || index >=size){
            return null;
        }else{
            Node<T> current = head;
            for(int i=0;i<index;i++){
                current = current.next;
            }
            return current.element;
        }
    }

    @Override
    public int indexOf(Object o) {
        Node<T> current = head;
        for(int i=0;i<size-1;i++){
            if(current.element.equals(o)){
                return i;
            }
            current = current.next;
        }
        return -1;
    }

    @Override
    public int lastIndexOf(Object o) {
        Node<T> current = tail;
        for(int i=size-1;i>0;i--){
            if(current.element.equals(o)){
                return i;
            }
            current = current.previous;
        }
        return -1;
    }

    @Override
    public T remove(int index) {
        if(index < 0 || index >= size){
            return null;
        }else if(index == 0){
            return removeFirst();
        }else if(index == size-1){
            return removeLast();
        }else{
            Node<T> previous = head;
            for(int i=1;i<index;i++){
                previous = previous.next;
            }
            Node<T> current = previous.next;
            previous.next = current.next;
            (previous.next).previous = previous;

            size--;
            return current.element;
        }
    }

    public T removeFirst(){
        if(size == 0){
            return null;
        }
        else{
            Node<T> tmp = head;
            head = head.next;
            if(head != null) {
                head.previous = null;
            }else{
                tail = null;
            }
            size--;
            return tmp.element;
        }
    }

    public T removeLast(){
        if(size == 0){
            return null;
        }
        else if(size == 1){
            Node<T> tmp = head;
            head = tail = null;
            size = 0;
            return tmp.element;
        }else{
            Node<T> current = head;
            for(int i=0;i<size - 2;i++){
                current = current.next;
            }
            Node<T> tmp = tail;
            tail = current;
            tail.next = null;
            tmp.previous = null;
            size--;
            return tmp.element;
        }
    }

    @Override
    public T set(int index, T e) {
        if(index < 0 || index >= size){
            return null;
        }
        else{
            Node<T> current = head;
            for(int i=0;i<index;i++){
                current = current.next;
            }
            T ret = current.element;
            current.element = e;
            return ret;
        }
    }

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

    @Override
    public boolean contains(Object o) {
        Node<T> current = head;
        for(int i=0;i<size-1;i++){
            if(current.element.equals(o)){
                return true;
            }
        }
        return false;
    }

    @Override
    public Iterator<T> iterator() {
        return new TwoWayLinkedListIterator();
    }

    public Iterator<T> iterator(int index){
        return new TwoWayLinkedListIterator(index);
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        for(Object o: c){
            if(!this.contains(o)){
                remove(o);
            }
        }
        return true;
    }

    @Override
    public void clear() {
        size = 0;
        head = tail = null;
    }

    private static class Node<T>{
        T element;
        Node<T> next;
        Node<T> previous;

        public Node(T e){
            element = e;
        }
    }

    private class TwoWayLinkedListIterator implements Iterator<T>{

        private Node<T> current = head;
        public TwoWayLinkedListIterator(){}
        public TwoWayLinkedListIterator(int index){
            for(int i=0;i<index;i++){
                head = head.next;
            }
        }

        @Override
        public boolean hasNext() {
            return current != null;
        }

        @Override
        public T next() {
            T e = current.element;
            current = current.next;
            return e;
        }

        @Override
        public void remove(){
            if(size == 0){

            }else if(size == 1){
                head = tail = null;
                size = 0;
            }else if(current.next == null){
                removeLast();
            }else if(current.previous == null){
                removeFirst();
            }else{
                current.next = (current.previous).next;
                (current.next).previous = current.previous;
                size--;
            }
        }
    }
}

24.4

public class book {


    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Stack<Integer> stack = new Stack<>();
        int number = 2;
        while(stack.size() < 50){
            if(checkPrime(number)){
                stack.add(number);
            }
            number++;
        }
        while (!stack.empty()){
            System.out.print(stack.pop()+" ");
        }
    }

    public static boolean checkPrime(int number){
        for(int i=2;i<=number/2;i++){
            if(number % i == 0){
                return false;
            }
        }
        return true;
    }
}

24.5

public class book {


    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

    }
    
}

class GenericQueue<T> extends LinkedList<T>{
    public void enqueue(T e){
        addLast(e);
    }

    public T dequeue(){
        return removeFirst();
    }

    public int getSize(){
        return this.size();
    }
    
}

24.6

public class book {


    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

    }

}

class MyPriorityQueue<T> {
    private HeapWithComparator<T> heapWithComparator;
    public MyPriorityQueue(){

    }

    public MyPriorityQueue(Comparator<? super T> comparator){
        this.heapWithComparator = new HeapWithComparator<>(comparator);
    }
    
    public void enqueue(T e){
        heapWithComparator.add(e);
    }
    
    public T dequeue(){
        return heapWithComparator.remove();
    }
    
    public int getSize(){
        return heapWithComparator.getSize();
    }
}


class HeapWithComparator<T> {
    private ArrayList<T> list = new ArrayList<>();
    private Comparator<? super T>comparator;


    public HeapWithComparator(){
        this.comparator = new Comparator<T>() {
            @Override
            public int compare(T o1, T o2) {
                return o1.toString().compareTo(o2.toString());
            }
        };
    }

    public HeapWithComparator(Comparator<? super T> comparator){
        this.comparator = comparator;
    }

    public void add(T newObject){
        list.add(newObject);
        int currentIndex = list.size()-1;
        while(currentIndex > 0){
            int parentIndex = (currentIndex-1) / 2;
            if(comparator.compare(list.get(currentIndex),list.get(parentIndex)) > 0){
                T tmp = list.get(currentIndex);
                list.set(currentIndex, list.get(parentIndex));
                list.set(parentIndex, tmp);
            }else{
                break;
            }
            currentIndex = parentIndex;
        }
    }

    public T remove(){
        if(list.size() == 0)
            return null;
        T removeObject = list.get(0);
        list.set(0, list.get(list.size()-1));
        list.remove(list.size()-1);

        int currentIndex = 0;
        while(currentIndex < list.size()){
            int leftChildIndex = 2*currentIndex + 1;
            int rightChildIndex = 2*currentIndex + 2;

            if(leftChildIndex >= list.size())
                break;
            int maxIndex = leftChildIndex;
            if(rightChildIndex < list.size()){
                if(comparator.compare(list.get(maxIndex), list.get(rightChildIndex)) < 0){
                    maxIndex = rightChildIndex;
                }
            }

            if(comparator.compare(list.get(currentIndex), list.get(maxIndex)) < 0){
                T tmp = list.get(maxIndex);
                list.set(maxIndex, list.get(currentIndex));
                list.set(currentIndex, tmp);
                currentIndex = maxIndex;
            }
            else{
                break;
            }
        }
        return removeObject;
    }

    public int getSize(){
        return list.size();
    }

}