Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 12396)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 12396)
@@ -0,0 +1,55 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Single Point Crossover", "The single point crossover concatenates two linkage strings at a randomly chosen point.")]
+  [StorableClass]
+  public sealed class SinglePointCrossover : LinearLinkageCrossover {
+
+    [StorableConstructor]
+    private SinglePointCrossover(bool deserializing) : base(deserializing) { }
+    private SinglePointCrossover(SinglePointCrossover original, Cloner cloner) : base(original, cloner) { }
+    public SinglePointCrossover() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SinglePointCrossover(this, cloner);
+    }
+
+    public static LinearLinkage Apply(IRandom random, LinearLinkage p1, LinearLinkage p2) {
+      var length = p1.Length;
+      var child = new LinearLinkage(length);
+      var bp = random.Next(length - 1);
+      for (var i = 0; i <= bp; i++) child[i] = p1[i];
+      for (var i = bp + 1; i < length; i++) child[i] = p2[i];
+      return child;
+    }
+
+    protected override LinearLinkage Cross(IRandom random, ItemArray<LinearLinkage> parents) {
+      if (parents.Length != 2) throw new InvalidOperationException(Name + ": Can only cross exactly two parents.");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj	(revision 12395)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj	(revision 12396)
@@ -107,4 +107,5 @@
     <Compile Include="Crossovers\LowestIndexMaxCrossover.cs" />
     <Compile Include="Crossovers\MultiLLECrossover.cs" />
+    <Compile Include="Crossovers\SinglePointCrossover.cs" />
     <Compile Include="Interfaces\ILinearLinkageCreator.cs" />
     <Compile Include="LinearLinkage.cs" />
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs	(revision 12395)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs	(revision 12396)
@@ -182,12 +182,13 @@
     /// These tree structures may be created by e.g. merging two groups by
     /// linking one end node to the end node of another.
-    /// Consider following example: 6, 6, 7, 5, 5, 8, 8, 8, 9.
+    /// Consider following 1-based index array: 6, 6, 7, 5, 5, 8, 8, 8, 9.
     /// This results in the following tree structure for group 8:
     ///      8
     ///    /   \
     ///   6     7
-    ///  / \
-    /// 1   2
+    ///  / \    |
+    /// 1   2   3
     /// After this operation the array will be 2, 3, 6, 5, 5, 7, 8, 8, 9.
+    /// Representing a tree with one branch: 1 -> 2 -> 3 -> 6 -> 7 -> 8
     /// </summary>
     /// <remarks>
@@ -195,4 +196,5 @@
     /// linearizes the links. This requires two passes of the whole array
     /// as well as a dictionary to hold the smallest index of each group.
+    /// The runtime complexity is O(n).
     /// 
     /// The method assumes that there are no back links present.
@@ -200,16 +202,56 @@
     public void LinearizeTreeStructures() {
       // Step 1: Convert the array into LLE-e
+      ToLLEeInplace(array);
+      // Step 2: For all groups linearize the links
+      FromLLEe(array);
+    }
+
+    /// <summary>
+    /// Creates a copy of the underlying array and turns it into LLE-e.
+    /// </summary>
+    /// <remarks>
+    /// LLE-e is a special format where each element points to the
+    /// ending item of a group.
+    /// The LLE representation 2, 3, 5, 6, 5, 7, 8, 8 would become 
+    /// 5, 5, 5, 8, 5, 8, 8, 8 in LLE-e.
+    /// 
+    /// This operation runs in O(n) time.
+    /// </remarks>
+    /// <returns>An integer array in LLE-e representation</returns>
+    public int[] ToLLEe() {
+      var result = (int[])array.Clone();
+      ToLLEeInplace(result);
+      return result;
+    }
+
+    private void ToLLEeInplace(int[] a) {
+      var length = a.Length;
+      for (var i = length - 1; i >= 0; i--) {
+        if (array[i] == i) a[i] = i;
+        else a[i] = a[a[i]];
+      }
+    }
+
+    /// <summary>
+    /// Parses an LLE-e representation and modifies the underlying array
+    /// so that it is in LLE representation.
+    /// </summary>
+    /// <remarks>
+    /// This operation runs in O(n) time, but requires additional memory
+    /// in form of a dictionary.
+    /// </remarks>
+    /// <param name="llee">The LLE-e representation</param>
+    public void FromLLEe(int[] llee) {
       var length = array.Length;
       var groups = new Dictionary<int, int>();
       for (var i = length - 1; i >= 0; i--) {
-        if (array[i] == i) groups[i] = i;
-        else array[i] = array[array[i]];
-      }
-      // Step 2: For all groups linearize the links
-      for (var i = length - 1; i >= 0; i--) {
-        if (array[i] == i) continue;
-        var g = array[i];
-        array[i] = groups[g];
-        groups[g] = i;
+        if (llee[i] == i) {
+          array[i] = i;
+          groups[i] = i;
+        } else {
+          var g = llee[i];
+          array[i] = groups[g];
+          groups[g] = i;
+        }
       }
     }
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/GraftManipulator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/GraftManipulator.cs	(revision 12395)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/GraftManipulator.cs	(revision 12396)
@@ -24,6 +24,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -33,18 +31,8 @@
   public sealed class GraftManipulator : LinearLinkageManipulator {
 
-    public IValueLookupParameter<IntValue> MaxGroupsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["MaxGroups"]; }
-    }
-
     [StorableConstructor]
     private GraftManipulator(bool deserializing) : base(deserializing) { }
     private GraftManipulator(GraftManipulator original, Cloner cloner) : base(original, cloner) { }
-    public GraftManipulator() {
-      Parameters.Add(new ValueLookupParameter<IntValue>("MaxGroups", "The maximum number of groups. If a value less or equal than 0 is used the number of groups is not limited.", new IntValue(-1)));
-    }
-    public GraftManipulator(int maxGroups)
-      : this() {
-      MaxGroupsParameter.Value = new IntValue(maxGroups);
-    }
+    public GraftManipulator() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -52,5 +40,5 @@
     }
 
-    public static void Apply(IRandom random, LinearLinkage lle, int maxGroups) {
+    public static void Apply(IRandom random, LinearLinkage lle) {
       int tries = lle.Length;
       var index = random.Next(lle.Length);
@@ -59,8 +47,8 @@
         tries--;
       }
-      if (lle[index] != index) Apply(random, lle, maxGroups, index);
+      if (lle[index] != index) Apply(random, lle, index);
     }
 
-    public static void Apply(IRandom random, LinearLinkage lle, int maxGroups, int index) {
+    public static void Apply(IRandom random, LinearLinkage lle, int index) {
       var groups = lle.Select((val, idx) => Tuple.Create(idx, val))
                       .Where(x => x.Item1 == x.Item2)
@@ -84,6 +72,5 @@
 
     protected override void Manipulate(IRandom random, LinearLinkage lle) {
-      var maxGroups = MaxGroupsParameter.ActualValue.Value;
-      Apply(random, lle, maxGroups <= 0 ? int.MaxValue : maxGroups);
+      Apply(random, lle);
     }
   }
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/MergeGroupManipulator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/MergeGroupManipulator.cs	(revision 12395)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/MergeGroupManipulator.cs	(revision 12396)
@@ -28,5 +28,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Item("Merge Group Manipulator", "Performs a maximum of N merge operations on the groups. Groups may be merged multiple times.")]
+  [Item("Merge Group Manipulator", "Performs a maximum of N merge operations on the groups. An already merged group may be merged again.")]
   [StorableClass]
   public sealed class MergeGroupManipulator : LinearLinkageManipulator {
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/MoveItemManipulator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/MoveItemManipulator.cs	(revision 12395)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/MoveItemManipulator.cs	(revision 12396)
@@ -29,5 +29,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Item("Move Item Manipulator", "Performs a maximum of N move operations between groups or to new groups. Items may be moved multiple times.")]
+  [Item("Move Item Manipulator", "Performs a maximum of N move operations between groups or to new groups. An already moved item may be moved again.")]
   [StorableClass]
   public sealed class MoveItemManipulator : LinearLinkageManipulator {
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/SplitGroupManipulator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/SplitGroupManipulator.cs	(revision 12395)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/SplitGroupManipulator.cs	(revision 12396)
@@ -31,5 +31,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Item("Split Group Manipulator", "Performs a maximum of N split operations on the groups. Groups may be split multiple times.")]
+  [Item("Split Group Manipulator", "Performs a maximum of N split operations on the groups. An already split group may be split again.")]
   [StorableClass]
   public sealed class SplitGroupManipulator : LinearLinkageManipulator {
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/SwapItemManipulator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/SwapItemManipulator.cs	(revision 12395)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/SwapItemManipulator.cs	(revision 12396)
@@ -28,5 +28,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Item("Swap Item Manipulator", "Swaps items between groups. Items may be swapped multiple times.")]
+  [Item("Swap Item Manipulator", "Performs N swaps operations of two items each. The same items may be swapped multiple times, at least two groups need to be present.")]
   [StorableClass]
   public sealed class SwapItemManipulator : LinearLinkageManipulator {
