The terms can mean almost anything, but I will try to present here one way in which the terms "parallel algorithms" and "distributed algorithms" are understood. Here we interpret "distributed algorithms" from the perspective of "network computing" (think: algorithms that keep the Internet running).
I will use as a running example the problem of finding a proper 3-colouring of a directed path (linked list). I will first describe the problem from the perspective of "traditional" algorithms — those are also known as centralised algorithms, to emphasise that they are not distributed, or sequential algorithms, to emphasise that they are not parallelised.
Centralised sequential algorithms
The model of computing is e.g. the familiar RAM model.
The input is a linked list that is stored in the main memory of the computer. There is a read-only array $x$ with $n$ elements; node number $x[i]$ is the successor of node number $i$.
The output will be also stored in the main memory of the computer. There is a write-only array $y$ with $n$ elements.
We need to find a proper colouring of the list with $3$ colours. That is, for each index $i$ we must choose a colour $y[i] \in \{1,2,3\}$ such that $y[i] \ne y[j]$ whenever node $j$ is the successor of node $i$.
There is a single processor that can directly access any part of the main memory. In one time unit, the processor can read from main memory, write to main memory, or perform elementary operations such as arithmetic or comparisons. The running time of the algorithm is defined to be the number of time units until the algorithms stops.
Clearly, the problem can be solved in time $O(n)$, and this is optimal. For the upper bound, follow the linked list and colour the nodes with e.g. colours $1,2,1,2,\dotsc$. For the lower bound, observe that we need to write $\Omega(n)$ elements of output.
Parallel algorithms
The only difference between parallel and sequential algorithms is that we will use the PRAM model instead of the RAM model. In the PRAM model we can consider any number of processors, but here a particularly interesting case is what happens if there are precisely $n$ processors.
While we will have multiple processors, there is still just one main memory. As before, the input is stored as a single array in the main memory, and the output will be written in a single array in the main memory.
Now in one time unit, each processor in parallel can read from main memory, write to main memory, or perform elementary operations such as arithmetic or comparisons. Some care is needed with memory accesses that may conflict. For the sake of concreteness, let us focus on the CREW PRAM model: the processors may freely read any part of the memory, but concurrent writes are forbidden.
Now in this setting it is not at all obvious what is the time complexity of $3$-colouring linked lists. Perhaps we could solve the problem in $O(1)$ time, as we have $n$ processors, and only $n$ units of input to read and $n$ units of output to write?
However, it turns out that the time complexity of this problem is precisely $\Theta(\log \log^* n)$. So it can be solved in almost constant time, but not quite.
Distributed algorithms
Now things change radically. The model of computing is e.g. the LOCAL model, which has very little resemblance to RAM or PRAM.
There is no "main memory". There are no "arrays".
We are only given a computer network that consists of $n$ nodes. Each node is labelled with a unique identifier (say, a number from $\{1,2,\dotsc,n\}$). Each node has two communication ports: one port that connects the node with its successor, and one port that connects it with its predecessor.
The same (unknown) computer network is both our input and the tool that we are supposed to use to solve the problem. Each node is a computational entity that has to output its own colour, and the colours have to form a proper colouring of the network (i.e., my colour has to be different from the colours of my neighbours).
Note that everything is distributed: no single entity holds the entire input, and no single entity needs to know the entire output.
All nodes run the same algorithm. In one time unit, all nodes in parallel can send messages to their neighbours, receive messages from their neighbours, or perform elementary operations. The running time of the algorithm is defined to be the number of time units until all nodes have stopped and produced their local outputs.
Again, it is not at all obvious what is the time complexity of $3$-colouring. It turns out that it is precisely $\Theta(\log^* n)$.
From this perspective:
Research on parallel algorithms is primarily about understanding how to harness the computational power of a massively parallel computer. For practical applications, consider high-performance computing, number-crunching, multicore, GPU computing, OpenMP, MPI, grids, clouds, clusters, etc.
Research on distributed algorithms is primarily about understanding which tasks can be solved efficiently in a distributed system. For practical applications, consider computer networks, communication networks, social networks, markets, biological systems, chemical systems, physical systems, etc.
For example:
If you want to know how to multiply two huge matrices efficiently with modern computer hardware, it may be a good idea to first have a look at research related to "parallel algorithms".
If you want to know if there is any hope people could form stable marriages in their real-world social network, by just exchanging information with those whom they know, it may be a good idea to first have a look at research related to "distributed algorithms".
Once again, I emphasise that this is just one way in which the terms are used. There are many other interpretations. However, this is perhaps the most interesting interpretation in the sense that e.g. PRAM and LOCAL are radically different models.
As many other answers show, another possible interpretation is to understand "distributed algorithms" from the perspective of e.g. distributed high-performance computing (computer clusters, cloud computing, MPI, etc.). Then you could indeed say that distributed algorithms are not necessarily that different from e.g. I/O efficient parallel algorithms. At least if we put aside e.g. issues related to fault tolerance.
Incidentally, there is apparently some interest in the community to make the terminology slightly less confusing. People occasionally use the term distributed graph algorithms (cf. http://adga.hiit.fi/) or the term network computing to emphasise the perspective that I described here. However, there is not that much pressure to do that, as we can use formally precise terms such as "LOCAL" and "CONGEST" for distributed graph algorithms, "PRAM" for parallel algorithms, and e.g. "congested clique" and "BSP" (bulk synchronous parallel) for various in-between cases.
References
