Experiment 2. Lists

weie99

已于 2022-09-16 20:02:55 修改

阅读量293

点赞数 1

文章标签： java

于 2022-09-15 22:50:00 首次发布

本文链接：https://blog.csdn.net/qq_62835729/article/details/126881267

版权

import java.util.*;

import static java.util.Collections.sort;

public class test1 {
    public static void main(String[] args) {
        LinkedList<Integer> linkL = new LinkedList<>();
        LinkedList<Integer> linkP = new LinkedList<>();
        ArrayList<Integer> arrayL = new ArrayList<>();
        ArrayList<Integer> arrayP = new ArrayList<>();
        System.out.println("请输入List L的元素个数");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        System.out.println("请输入List L的元素");
        for(int i=0;i<num;i++)
        {
            int temp = sc.nextInt();
            linkL.add(temp);
            arrayL.add(temp);
        }
        System.out.println("请输入List P的元素个数");
        num = sc.nextInt();
        System.out.println("请输入List P的元素");
        for(int i = 0;i<num;i++)
        {
            int temp = sc.nextInt();
            linkP.add(temp);
            arrayP.add(temp);
        }
        sort(linkL);
        sort(linkP);
        sort(arrayL);
        sort(arrayP);
        System.out.println("已自动排序");
        System.out.println(linkL);
        System.out.println(linkP);
        System.out.println("函数printLots运行");
        printLots(linkL,linkP);
        printLots(arrayL,arrayP);
    }
    public static void printLots(LinkedList<Integer> l,LinkedList<Integer> p)
    {
        System.out.print("LinkedList_printLots:");
        Iterator iterl = l.iterator();
        int counter = 0;
        Iterator iterp = p.iterator();
        while(iterp.hasNext()){
            int temp = (int) iterp.next();
            while(counter<temp)
            {
                iterl.next();
                counter++;
            }
            System.out.print(iterl.next()+" ");
            counter++;
        }
        System.out.println();
    }
    public static void printLots(ArrayList<Integer> l,ArrayList<Integer> p)
    {
        System.out.print("ArrayList_printLots:");
        for(int i = 0;i<p.size();i++)
        {
            if(p.get(i)<0||p.get(i)>=l.size()){
                System.out.println("数据不在范围内！ ");
                continue;
            }
            System.out.print(l.get(p.get(i))+" ");
        }
        System.out.println();
    }


}

请输入List L的元素个数
9
请输入List L的元素

99 5 4 66 58 25 42 46 33
请输入List P的元素个数
4
请输入List P的元素
5 8 1 3
已自动排序
[4, 5, 25, 33, 42, 46, 58, 66, 99]
[1, 3, 5, 8]
函数printLots运行
LinkedList_printLots:5 33 46 99
ArrayList_printLots:5 33 46 99
————————————————


import java.util.*;

import static java.util.Collections.sort;

public class test2 {
    public static void main(String[] args) {
        LinkedList<Integer> linkl = new LinkedList<>();
        LinkedList<Integer> linkp = new LinkedList<>();
        ArrayList<Integer> arrayl = new ArrayList<>();
        ArrayList<Integer> arrayp = new ArrayList<>();
        ArrayList<Integer> arrayl1 = new ArrayList<>();
        ArrayList<Integer> arrayp1 = new ArrayList<>();
        LinkedList<Integer> linkl1 = new LinkedList<>();
        LinkedList<Integer> linkp1 = new LinkedList<>();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入List l的元素个数");
        int num = sc.nextInt();
        System.out.println("请输入List l的元素");
        for(int i=0;i<num;i++)
        {
            int temp = sc.nextInt();
            linkl.add(temp);
            arrayl.add(temp);
            arrayl1.add(temp);
            linkl1.add(temp);
        }
        System.out.println("请输入List p的元素个数");
        num = sc.nextInt();
        System.out.println("请输入List p的元素个数");
        for(int i =0;i<num;i++)
        {
            int temp = sc.nextInt();
            linkp.add(temp);
            arrayp.add(temp);
            arrayp1.add(temp);
            linkp1.add(temp);
        }
        System.out.println("已自动排序");
        sort(linkl);
        sort(linkp);
        sort(arrayl);
        sort(arrayp);
        sort(arrayl1);
        sort(arrayp1);
        sort(linkl1);
        sort(linkp1);
        System.out.println(linkl);
        System.out.println(linkp);
        System.out.println("运行myRetainAll");

        myRetainAll(arrayl,arrayp);
        myRetainAll(linkl,linkp);
        long startTime = System.nanoTime();
        arrayl1.retainAll(arrayp1);
        long overTime = System.nanoTime();
        System.out.print("RetainAll_array: ");
        for(int i:arrayl1)
        {
            System.out.print(i+" ");
        }
        System.out.println();
        System.out.println("RetainAll_ArrayTime:"+(overTime - startTime));
        startTime = System.nanoTime();
        linkl1.retainAll(linkp1);
        overTime = System.nanoTime();
        System.out.print("RetainAll_link：");
        for(int i:linkl1)
        {
            System.out.print(i+" ");
        }
        System.out.println();
        System.out.println("RetainAll_linkTime:"+(overTime - startTime));
    }
    public static void myRetainAll(ArrayList<Integer> l,ArrayList<Integer> p)
    {
        System.out.print("myRetainAll_ArrayList: ");
        long startTime = System.nanoTime();
        int j = 0;
        ArrayList<Integer> newArray = new ArrayList<>();
        for(int i = 0;i<l.size();i++)                    //时间复杂度O（m+n） 开辟了新的空间
        {
            while(j<p.size())                   //有序 j 不需要从0开始
            {
                if(l.get(i)>p.get(j)){
                    j++;
                }else if(l.get(i)<p.get(j)){
                    i++;
                }else{
                    newArray.add(l.get(i));
                    break;
                }
            }
        }
        long overTime = System.nanoTime();
        for(int i = 0;i<newArray.size();i++)
        {
            System.out.print(newArray.get(i)+" ");
        }

        System.out.println();
        System.out.println("MyRetainAll_arrayTime: "+(overTime - startTime));
    }

    public static void myRetainAll(LinkedList<Integer> l,LinkedList<Integer> p)  //时间复杂度 O(m+n) 不需要开辟额外空间
    {
        System.out.print("myRetainAll_LinkedList: ");
        long startTime = System.nanoTime();
        ListIterator<Integer> iterp = p.listIterator();                  //这个迭代器可以访问前一个
        for(int i : l)
        {
            while (iterp.hasNext())
            {
                if(iterp.next()>i)
                {
                    iterp.previous();
                    break;                                               //foreach 每次从头遍历   list.get() 时间复杂度O（n）
                }else if(iterp.next()<i)
                {
                    iterp.remove();
                }else{
                    iterp.next();
                }
            }

        }
        while(iterp.hasNext())          //如果l 列表已经遍历完 而列表p未遍历完就删除p的未遍历完的
        {
            iterp.next();
            iterp.remove();
        }
        long overTime = System.nanoTime();
        for(int i: p)
        {
            System.out.print(i+" ");
        }
        System.out.println();
        System.out.println("MyRetainAll_linkTime:"+(overTime - startTime));
    }
}

命令框内容：

请输入List l的元素个数
8
请输入List l的元素
1 5 4 2 6 3 10 7
请输入List p的元素个数
5
请输入List p的元素个数
11 10 2 4 13
已自动排序
[1, 2, 3, 4, 5, 6, 7, 10]
[2, 4, 10, 11, 13]
运行myRetainAll
myRetainAll_ArrayList: 2 4 10
MyRetainAll_arrayTime: 9500
myRetainAll_LinkedList: 2 4 10
MyRetainAll_linkTime:36400
RetainAll_array: 2 4 10
RetainAll_ArrayTime:11200
RetainAll_link：2 4 10
RetainAll_linkTime:12400

------------------------------------------------------------------

import java.sql.SQLOutput;
import java.util.*;

import static java.util.Collections.emptyListIterator;
import static java.util.Collections.sort;

public class test3 {
    public static void main(String[] args) {
        LinkedList<Integer> linkl = new LinkedList<>();
        LinkedList<Integer> linkp = new LinkedList<>();
        ArrayList<Integer> arrayl = new ArrayList<>();
        ArrayList<Integer> arrayp = new ArrayList<>();
        ArrayList<Integer> arrayl1 = new ArrayList<>();
        ArrayList<Integer> arrayp1 = new ArrayList<>();
        LinkedList<Integer> linkl1 = new LinkedList<>();
        LinkedList<Integer> linkp1 = new LinkedList<>();

        System.out.println("请输入List l的元素个数");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        System.out.println("请输入List l的元素");
        for(int i = 0;i<num;i++)
        {
            int temp = sc.nextInt();
            linkl.add(temp);
            arrayl.add(temp);
            linkl1.add(temp);
            arrayl1.add(temp);
        }
        System.out.println("请输入List P的元素个数");
        num = sc.nextInt();
        System.out.println("请输入List P的元素");
        for(int i = 0;i<num;i++)
        {
            int temp = sc.nextInt();
            linkp.add(temp);
            arrayp.add(temp);
            arrayp1.add(temp);
            linkp1.add(temp);
        }
        System.out.println("已经自动排序");
        sort(linkl);
        sort(linkp);
        sort(arrayl);
        sort(arrayp);
        System.out.println(linkl);
        System.out.println(linkp);
        System.out.println("Union函数已经运行");
        Union(arrayl,arrayp);
        Union(linkl,linkp);
        long startTime = System.nanoTime();
        arrayl1.removeAll(arrayp1);
        arrayp1.addAll(arrayl1);
        long overTime = System.nanoTime();
        System.out.print("retainAll+addAll_array:");
        sort(arrayp1);
        System.out.println(arrayp1);
        System.out.println("retainAll+addAll_array_Time: "+(overTime - startTime));

         startTime = System.nanoTime();
        linkl1.removeAll(linkp1);
        linkp1.addAll(linkl1);
         overTime = System.nanoTime();
        System.out.print("retainAll+addAll_linked:");
        sort(linkp1);
        System.out.println(linkp1);
        System.out.println("retainAll+addAll_linked_Time: "+(overTime - startTime));
    }
    public static void Union(LinkedList<Integer> l,LinkedList<Integer> p)
    {
        System.out.print("Union_LinkedList: ");
        long startTime = System.nanoTime();
        ListIterator<Integer> iterl = l.listIterator();
        ListIterator<Integer> iterp = p.listIterator();
        while (iterl.hasNext()||iterp.hasNext())
        {

            if(!iterl.hasNext()){
              break;
            }else if(!iterp.hasNext()) {
                while (iterl.hasNext()) {
                    //p.add(iterl.next());                                      (并发修改异常)
                    iterp.add(iterl.next());
                }
                break;
            }
            int templ = iterl.next();
            int tempp = iterp.next();
             if(tempp>templ)
            {
                iterp.previous();
               // p.add(iterl.previous());                                             不使用迭代器进行更新会报错ConcurrentModificationException（并发修改异常）
                iterp.add(iterl.previous());
                iterl.next();
            }else if(tempp<templ)
            {
                iterl.previous();
            }
        }
        long overTime = System.nanoTime();
        sort(p);
        System.out.println(p);
        System.out.println("myUnion_linked_Time: "+(overTime - startTime));
    }
    public static void Union(ArrayList<Integer> l,ArrayList<Integer> p)
    {
        System.out.print("Union_ArrayList: ");
        ArrayList<Integer> newArray = new ArrayList<>();
        long startTime = System.nanoTime();
        int j = 0;
        int i = 0;
        while(i<l.size()||j<p.size())
        {
            if(i==l.size()){
                while(j<p.size())
                {
                    newArray.add(p.get(j));            //当l列表已经遍历完毕，把p列表中的内容全部加入
                    j++;
                }
            }
            else if(j==p.size()){
                while(i<l.size())
                {
                    newArray.add(l.get(i));            //当p列表已经遍历完毕，把l列表中的内容全部加入
                    i++;
                }
            }
            else if(l.get(i)==p.get(j))                 //向新数组中加一次元素即可
            {                                      //数组的.get()函数时间复杂度为O(1)
                newArray.add(l.get(i));
                i++;
                j++;

            }
            else if(l.get(i)<p.get(j))
            {                                      //元素不相等，均加入
                newArray.add(l.get(i));
                i++;
            }
            else {
                newArray.add(p.get(j));
                j++;
            }

        }
        long overTime = System.nanoTime();
        System.out.println(newArray);
        System.out.println("myUnion_array_Time: "+(overTime - startTime) );
    }

}

命令行内容：

请输入List l的元素个数
8
请输入List l的元素

1 4 2 6 33 5 9 10
请输入List P的元素个数
7
请输入List P的元素
2 99 11 4 3 16 7
已经自动排序
[1, 2, 4, 5, 6, 9, 10, 33]
[2, 3, 4, 7, 11, 16, 99]
Union函数已经运行
Union_ArrayList: [1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 16, 33, 99]
myUnion_array_Time: 13800
Union_LinkedList: [1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 16, 33, 99]
myUnion_linked_Time: 46200
retainAll+addAll_array:[1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 16, 33, 99]
retainAll+addAll_array_Time: 30600
retainAll+addAll_linked:[1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 16, 33, 99]
retainAll+addAll_linked_Time: 16100

--------------------------------------------------------------------

import java.util.List;
import java.util.Scanner;

public class test6 {
    public static void main(String[] args) {
        System.out.println("请输入节点个数");                                             //这里我自己创建了一个链表
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        ListNode head = new ListNode(0);                       //创建一个头节点
        ListNode index = head;
        System.out.println("请输入单链表的数据");
        for(int i = 0;i<num;i++)
        {
            ListNode newNode = new ListNode(sc.nextInt());
            index.next = newNode;
            index = index.next;
        }
        System.out.println("你输入的链表顺序");
        index = head.next;
        while(index!=null) {
            System.out.print(index.val + " ");
            index=index.next;
        }
        System.out.println();
        System.out.println("reverseList函数运行");
        ListNode reversed = head.reverseList(head);
        System.out.println("反转的链表顺序");
        index = reversed;
        while (index!=head) {
            System.out.print(index.val + " ");
            index = index.next;
        }
        System.out.println();
    }
}
 class ListNode {                           //链表的各个节点
    int val;                                 //数据
    ListNode next;                         //下一个地址
    ListNode(int x) { val = x; }            //构造函数

     public static ListNode reverseList(ListNode head) {           //时间复杂度为O（N） 且不需要开辟新的空间
         if(head==null||head.next==null) return head;

         ListNode pre = head;
         ListNode cur = head.next;
         ListNode temp;
         while(cur!=null)
         {
             temp = cur.next;
             cur.next = pre;
             pre = cur;
             cur = temp;
         }
         head.next = null;
         return pre;

     }
}

命令行内容：

请输入节点个数
8
请输入单链表的数据
1 3 2 6 5 11 9 10
你输入的链表顺序
1 3 2 6 5 11 9 10
reverseList函数运行
反转的链表顺序
10 9 11 5 6 2 3 1

注意：不使用迭代器，因为迭代器不具备修改链表指针方向的方法

-----------------------------------------------------------

import java.util.Scanner;

public class test9 {
    public static void main(String[] args) {
        System.out.println("请输入第一个多项式的项数");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        polynomialsNode head1 = new polynomialsNode(0,0);
        polynomialsNode head2 = new polynomialsNode(0,0);
        polynomialsNode index = head1;
        System.out.println("请输入第一个多项式，每一项的输入为:系数 指数");
        for(int i=0;i<num;i++)
        {
            polynomialsNode newNode = new polynomialsNode(sc.nextInt(),sc.nextInt());
            index.next = newNode;
            index = index.next;
        }
        System.out.println("请输入第二个多项式的项数");
        num = sc.nextInt();
        index = head2;
        System.out.println("请输入第二个多项式，每一项的输入为:系数 指数");
        for(int i = 0;i<num;i++)
        {
            polynomialsNode newNode = new polynomialsNode(sc.nextInt(),sc.nextInt());
            index.next = newNode;
            index = index.next;
        }
        System.out.println("add函数已经运行");
        index = polynomialsNode.polynomialsAdd(head1,head2).next;
        while(index!=null)
        {
            if(index.next==null){
                System.out.print(index.coefficient+"x"+ index.exponent);
            }
            else System.out.print(index.coefficient+"x"+ index.exponent+"+");
            index = index.next;
        }
    }

}
class polynomialsNode {                           //多项式的各个项
    int coefficient;                          //系数
    int exponent;                             //指数
    polynomialsNode next;                         //下一个地址

    polynomialsNode(int coefficient,int exponent) {
        this.coefficient = coefficient;
        this.exponent = exponent;
    }            //构造函数

    public static polynomialsNode polynomialsAdd(polynomialsNode a,polynomialsNode b)   //注意此方法要求输入的指数必须为降序！！
    {
        polynomialsNode index1 = a.next;                                     //注意此处输入的链表均有头节点
        polynomialsNode indexpre = a;
        polynomialsNode index2 = b.next;
        while (index1!=null||index2!=null)
        {
            if(index1==null&&index2!=null)
            {
                indexpre.next = index2;
                break;
            }else if(index2==null&&index1!=null)
            {
                break;
            }
            if(index1.exponent==index2.exponent){                                     //当指数相同时，系数相加
                index1.coefficient = index1.coefficient+ index2.coefficient;
                indexpre = index1;
                index1 = index1.next;
                index2 = index2.next;
            }else if(index1.exponent>index2.exponent){
                indexpre = index1;
                index1 = index1.next;
            }else if(index1.exponent<index2.exponent){
                indexpre.next = index2;
                indexpre = index2;
                polynomialsNode temp = index2.next;
                index2.next = index1;
                index2 = temp;
            }
        }
        return a;
    }
}

命令行运行内容：

第一次内容：

请输入第一个多项式的项数
3
请输入第一个多项式，每一项的输入为:系数指数
10 1010 -2 110 5 10
请输入第二个多项式的项数
4
请输入第二个多项式，每一项的输入为:系数指数
-5 1010 4 101 -2 10 6 2
add函数已经运行
5x1010+-2x110+4x101+3x10+6x2

第二次内容:

请输入第一个多项式的项数
3
请输入第一个多项式，每一项的输入为:系数指数
10 1000 5 14 1 0
请输入第二个多项式的项数
4
请输入第二个多项式，每一项的输入为:系数指数
3 1990 -2 1492 11 1 5 0
add函数已经运行
3x1990+-2x1492+10x1000+5x14+11x1+6x0