确定我的计划的时间复杂性？

Question

我的程序获得两个列表之间的对称差异。 这是我的代码：

    import java.util.*;

    /**
     * A class to find the symmetric difference between two lists.
     */

    public class SymDifference
    {
    /**
     * Finds the symmetric difference between two sorted lists.
     *
     * @param L1     first list
     * @param L2     second list
     * @param Result list with the symmetric difference
     */
    static <AnyType extends Comparable<? super AnyType>> void symDifference(List<AnyType> L1, List<AnyType> L2,
                                                                            List<AnyType> Result)
    {
        //create two iterators to go through the list
        ListIterator<AnyType> iterL1 = L1.listIterator();
        ListIterator<AnyType> iterL2 = L2.listIterator();

        //create two anytype objs
        AnyType itemL1 = null;
        AnyType itemL2 = null;

        //gets the first two items of the lists
        if (iterL1.hasNext() && iterL2.hasNext())
        {
            itemL1 = iterL1.next();
            itemL2 = iterL2.next();
        }

        //use a while loop to compare elements of lists
        while (itemL1 != null && itemL2 != null)
        {
            int compareResult = itemL1.compareTo(itemL2);

            //elements are the same so go on to the next items
            if (compareResult == 0)
            {
                //get next item for list L1
                if (iterL1.hasNext())
                {
                    itemL1 = iterL1.next();
                }
                else
                {
                    itemL1 = null;
                }
                //get next item for list L2
                if (iterL2.hasNext())
                {
                    itemL2 = iterL2.next();
                }
                else
                {
                    itemL2 = null;
                }
            }
            // the item of L1 comes after the item of L2, add item from L2 to results
            else if (compareResult < 0)
            {
                Result.add(itemL1);

                //get next item for list L1
                if (iterL1.hasNext())
                {
                    itemL1 = iterL1.next();
                }
                //get next item for list L2
                else
                {
                    itemL1 = null;
                }
            }
            // the item of L1 comes before the item of L2, add item from L1 to results
            else
            {
                Result.add(itemL2);

                //get next item for list L1
                if (iterL2.hasNext())
                {
                    itemL2 = iterL2.next();
                }
                //get next item for list L2
                else
                {
                    itemL2 = null;

                }
            }

        }

        //add remaining items from list L1
        while (itemL1 != null)
        {

            Result.add(itemL1);
            if (iterL1.hasNext())
            {
                itemL1 = iterL1.next();
            }
            else
            {
                itemL1 = null;
            }

        }

        //add remaining items from list L2
        while (itemL2 != null)
        {

            Result.add(itemL2);
            if (iterL2.hasNext())
            {
                itemL2 = iterL1.next();
            }
            else
            {
                itemL2 = null;
            }

        }
    }

    //tester class
    public static void main(String[] args)
    {
        ArrayList<Integer> a = new ArrayList<>();
        a.add(1);
        a.add(3);
        a.add(5);
        a.add(7);
        a.add(9);
        a.add(12);

        ArrayList<Integer> a2 = new ArrayList<>();
        a2.add(1);
        a2.add(2);
        a2.add(3);
        a2.add(9);
        a2.add(20);
        ArrayList<Integer> results = new ArrayList<>();

        symDifference(a, a2, results);
        Collections.sort(results);  // sort the results
        System.out.println(results.toString());

    }
}

我的代码是O(n)吗？我相当肯定，但我不确定。我仍然不完全理解时间的复杂性。我知道如果我横穿列表然后我得到O(n)，但是当你横穿两个列表时不知道它是否会改变。我相信它是O(n)因为列表在一个循环中被横向移动。任何帮助都感激不尽！谢谢你的时间！

Answer 1

是的，您的代码为O(m+n)，其中m是第一个列表的长度，n是第二个列表的长度...

复杂性与合并两个排序数组的复杂性相同。只是你没有在最终结果中添加两个列表之间的公共数字。