You have received some interesting links and ideas already. I hope I can provide a little different point of view:
I learned to visualize and "like" data structures by being taught that computer memory is like a really long list. The structures then have different layout in the memory. By visualizing the structures in the memory, it became obvious to me (and interesting) how they work. Knowing the data layout in memory is incredibly important for a programmer as today's continuously growing machines are often halted by memory-access. A good memory-layout easen the burden for the CPU to fetch the data from the memory so that the CPU doesn't have to wait for data to arrive.
Data structures is the layout of the data in a memory. Consider memory as a long list, just like a shopping list but without the entries.
0...
1...
2...
3...
4...
5...
6...
When you put structures into the memory, they essentially fill up these slots in memory.
A list is very simple, it just fills the memory-list from the top and down:
0 Element 0
1 Element 1
2 Element 2
3 Element 3
Although sometimes you want to change element 2 to something else, maybe zero. That's the way lists work. You can access the data in the structure by knowing their index (in this case, 0 .. 3).
Stacks are different. You can only access the "top" of a stack by "pushing" an element to the top of it, or "poping" an element from the top of it. Pushing means adding another element and the old top becomes invisible. Poping means removing the top element and the one below it becomes visible.
0 [ Hidden data ]
. [ Hidden data ]
. [ Hidden data ]
. [ Hidden data ]
n [ Hidden data ]
n+1 Element 4
Linked lists are different. A linked list contains a pointer (index in the memory-list) to the data, and one pointer to the next element:
0 Data: Memory index 0x00000100
1 Next: Memory index 6
2
3
4
5
6 Data: Memory index 104
7 Next: Memory index 8
...
100 Data pointed to from first member
101
102
103
104 Data pointed to from second member
Queue's is like a more powerful stack, you have access to both the bottom and the top. You can only push items to the top and you can only pop items from the bottom.
0 (bottom) Element (ready to be popped)
1 [ Hidden data ]
2 [ Hidden data ]
3 [ Hidden data ]
.
.
.
n (top) (empty, ready to be pushed / be given data)
By visualizing the layout of each data-structure, they became a lot more obvious to me in how they require memory and how they really work ( also in the memory). I hope that my examples have given you some brief starting knowledge for you to base your future studies on. As a final example on data structures, I will give you an unbalanced binary tree that have had the following order of element insertion:
3, 2, 1, 10, 9, 8, 6, 5, 4, 7
The tree starts at memory address 100, since memory address 0 is invalid and I'll use that as a "no pointer".
100 Value: "3"
101 Left ptr: 103
102 Right ptr: 109
103 Value: "2"
104 Left ptr: 106
105 Right ptr: 0
106 Value: "1"
107 Left ptr: 0
108 Right ptr: 0
109 Value: "10"
110 Left ptr: 112
111 Right ptr: 0
112 Value: "9"
113 Left ptr: 115
114 Right ptr: 0
115 Value: "8"
116 Left ptr: 118
117 Right ptr: 0
118 Value: "6"
119 Left ptr: 121
120 Right ptr: 127
121 Value: "5"
122 Left ptr: 124
123 Right ptr: 0
124 Value: "4"
125 Left ptr: 0
126 Right ptr: 0
127 Value: "7"
128 Left ptr: 0
129 Right ptr: 0
Hope that helps!
