Singly | Terminator simply uses git and lynx to track changes

As mentioned in the comments, you are responsible for the nodes and the list itself but not for the data, since you cannot know (in every case) if the data resides on the heap or on the stack.

Simply create a foreach method like this:

You probably cannot optimize startup time and performance by changing your application^{1, 2}. And especially for a small application³. And I certainly don't think there are "generic" ways to do it; i.e. optimizations that will work for all cases.

However, there are a couple of JVM features that should improve performance for a short-lived JVM.

Class Data Sharing (CDS) is a feature that allows JIT compiled classes to be cached in the file system (as a CDS archive) and which is then reused by later of runs of your application. This feature has been available since Java 5 (though with limitations in earlier Java releases).

The CDS feature is controlled using the -Xshare JVM option.

• -Xshare:dump generates a CDS archive during the run
• -Xshare:off -Xshare:on and -Xshare:auto control whether an existing CDS archive will be used.

The other way to improve startup times for a HotSpot JVM is (was) to use Ahead Of Time (AOT) compilation. Basically, you compile your application to a native code binary using the jaotc command, and then run the executable it produces rather than the java command. The jaotc command is experimental and was introduced in Java 9.

It appears that jaotc was not included in the Java 16 builds published by Oracle, and is scheduled for removal in Java 17. (See JEP 410: Remove the Experimental AOT and JIT Compiler).

The current recommended way to get AOT compilation for Java is to use the GraalVM AOT Java compiler.

^{1 - You could convert into a client-server application where the server "up" all of the time. However, that has other problems, and doesn't eliminate the startup time issue for the client ... assuming that is coded in Java.
2 - According to @apangin, there are some other application tweaks that may could make you code more JIT friendly, though it will depend on what you code is currently doing.
3 - It is conceivable that the startup time for a large (long running) monolithic application could be improved by refactoring it so that subsystems of the application can be loaded and initialized only when they are needed. However, it doesn't sound like this would work for your use-case.}

There are a few issues:

• curr.next has already been modified by the time you do curr = curr.next. So instead of going forward in the list, you're going backward (since curr.next is actually equal to prev by that time).

• head.next is never modified, yet it should become None. You should actually start one step "earlier" in the list, making curr equal to head and prev should be None.

• return curr is always going to return None, as that is the condition by which the while loop exits.

Here is a fix:

Because you haven't declared your _id on your Mongoose Schema, Mongoose is defaulting to an ObjectId type for your documents' _id instead of a String one that leads to the error.

To solve this you can declare the _id in your schema like this:

I think deletion while comparing with strings loaded from file is somewhat similar to first part of your problem where you were adding items to the list. You can create a method in your class which will scan the file line by line, search for a match for that line in linked list and remove if it's a match.

I was able to do that with three helper methods:

Can the answer be like this.

I didn't look into the algorithm, but the error means that either head1 or head2 is None at the moment you execute head1.data == head2.data.

When looking at the surrounding code, we have this:

Assuming that "words" are separated by spaces one approach would be to count the number of spaces between words and add 1. Then compare to the n value.

delete should only be used with an object that has been created with new.

You create objects on the stack and set lsptr to point to them. Note that the list nodes were not created by new. You then delete lsptr, which is invalid because they were not created by new. This causes an exception. The exception is not handled by the program, so it notifies the operating system that the program has failed. This is called trapping into the operating system. The OS then handles the failure by either: stopping the program and jumping to a debugger (if setup), aka breakpoint trap, or kills your program.

To fix the program, remove the deletes. You don't need to delete stack allocations, only heap allocated objects (new).