# self referential structure in data structure

Note by Mahesh Gupta
4 years, 7 months ago

MarkdownAppears as
*italics* or _italics_ italics
**bold** or __bold__ bold
- bulleted- list
• bulleted
• list
1. numbered2. list
1. numbered
2. list
Note: you must add a full line of space before and after lists for them to show up correctly
paragraph 1paragraph 2

paragraph 1

paragraph 2

[example link](https://brilliant.org)example link
> This is a quote
This is a quote
    # I indented these lines
# 4 spaces, and now they show
# up as a code block.

print "hello world"
# I indented these lines
# 4 spaces, and now they show
# up as a code block.

print "hello world"
MathAppears as
Remember to wrap math in $$...$$ or $...$ to ensure proper formatting.
2 \times 3 $$2 \times 3$$
2^{34} $$2^{34}$$
a_{i-1} $$a_{i-1}$$
\frac{2}{3} $$\frac{2}{3}$$
\sqrt{2} $$\sqrt{2}$$
\sum_{i=1}^3 $$\sum_{i=1}^3$$
\sin \theta $$\sin \theta$$
\boxed{123} $$\boxed{123}$$

Sort by:

Since "self-referential means" referring to itself, a self-referential data structure is something that contains a reference to an object of the same type as itself.

To be more specific, a self-referential structure is a class, one of whose fields is a reference to a (different) copy of the same class.

A specific example of a self-referential class is the class that describes an element of a list. An element of a list not only has a value, but also should contain information about where it is in that list. This could be done by storing the index number of that element (is it the first, second, third,... element in the list?) as well as its value, but this proves to be less effective than having a data structure which "tells" each element what its predecessor in the list is, and what its successor in the list is. Here is some (Pascal) code which would define such a structure:

TListElement = class Record
Val: Integer;
Prior: TListElement;
Next: TListElement;
end;


Note that there are fields inside the TLIstElement class which are of type TListElement - that is why this is a self-referential data structure.

A list consisting of a single value $$10$$ would be contained in a single variable $$a$$ of type TListElement with

a.Val := 10;            a.Prior := null;                   a.Next := null;


A list consisting of the number $$23$$ followed by the number $$25$$ would be contained in two variables $$a,b$$ of type TListElement with

a.Val := 23;  a.Prior := null;  a.Next := b;    b.Val := 25; b.Prior := a; b.Next := null;


and an element z of value $$25$$ can be inserted between successive elements x and y in a list by defining:

z.Val := 25;  z.Prior := x;   z.Next := y;      x.Next := z;    y.Prior := z;


This structure enables you to find things like "the value of the term in the list three places earlier than the element with the variable name a" as

a.Prior.Prior.Prior.Val;


Of course, if the element a is the first, second or third element of the list, then this code will throw an exception, dealing with that sort of problem is what programming is about!

The first element in the list is the single element of the list whose "Prior" field is null. The last element in the list is the single element whose "Next" field is null.

- 4 years, 7 months ago

what is mean self referential structure?

- 4 years, 7 months ago