Chapter 48
Interval Skip List

Andreas Fabri

Table of Contents

48.1 Definition
48.2 Example Programs
   48.2.1   First Example with Simple Interval
   48.2.2   Example with Faces of a Triangulated Terrain

48.1   Definition

An interval skip list is a data structure for finding all intervals that contain a point, and for stabbing queries, that is for answering the question whether a given point is contained in an interval or not. The implementation we provide is dynamic, that is the user can freely mix calls to the methods insert(..), remove(..), find_intervals(..), and is_contained(..)

The interval skip list class is parameterized with an interval class.

The data structure was introduced by Hanson [Han91], and it is called interval skip list, because it is an extension of the randomized list structure known as skip list [Pug90].

48.2   Example Programs

We give two examples. The first one uses a basic interval class. In the second example we create an interval skip list for the z-ranges of the faces of a terrain, allowing to answer level queries.

48.2.1   First Example with Simple Interval

The first example reads two numbers n and d from std::cin. It creates n intervals of length d with the left endpoint at n. It then reads out the intervals for the 1-dimensional points with coordinates 0 ... n+d.

The interval skip list class has as template argument an interval class. In this example we use the class Interval_skip_list_interval.

File: examples/Interval_skip_list/intervals.cpp
#include <CGAL/Interval_skip_list.h>
#include <CGAL/Interval_skip_list_interval.h>
#include <vector>
#include <list>
#include <iostream>

typedef CGAL::Interval_skip_list_interval<double> Interval;
typedef CGAL::Interval_skip_list<Interval> Interval_skip_list;

int main()
  Interval_skip_list isl;
  int i, n, d;

  n = 10;
  d = 3;
  //std::cin >> n >> d;
  std::vector<Interval> intervals(n);
  for(i = 0; i < n; i++) {
    intervals[i] = Interval(i, i+d);
  std::random_shuffle(intervals.begin(), intervals.end());

  isl.insert(intervals.begin(), intervals.end());

  for(i = 0; i < n+d; i++) {
    std::list<Interval> L;
    isl.find_intervals(i, std::back_inserter(L));
    for(std::list<Interval>::iterator it = L.begin(); it != L.end(); it++){
      std::cout << *it;
    std::cout << std::endl;

  for(i = 0; i < n; i++) {
  return 0;


48.2.2   Example with Faces of a Triangulated Terrain

The second example creates an interval skip list that allows to find all the faces of a terrain intersected by an horizontal plane at a given height. The data points for the terrain are read from a file.

As model for the interval concept, we use a class that is a wrapper around a face handle of a triangulated terrain. Lower and upper bound of the interval are smallest and largest z-coordinate of the face.

File: examples/Interval_skip_list/isl_terrain.cpp
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Delaunay_triangulation_2.h>
#include <CGAL/Triangulation_euclidean_traits_xy_3.h>
#include <CGAL/Interval_skip_list.h>
#include <CGAL/Level_interval.h>
#include <iostream>
#include <fstream>

typedef  CGAL::Exact_predicates_inexact_constructions_kernel EIK;
typedef EIK::Point_3                                   Point_3;
typedef CGAL::Triangulation_euclidean_traits_xy_3<EIK> K;
typedef CGAL::Delaunay_triangulation_2<K>              Delaunay;
typedef Delaunay::Face_handle                          Face_handle;
typedef Delaunay::Finite_faces_iterator                Finite_faces_iterator;
typedef CGAL::Level_interval<Face_handle>              Interval;
typedef CGAL::Interval_skip_list<Interval>             Interval_skip_list;

int main()
  std::ifstream fin("terrain.pts"); // elevation ranges from 0 to 100
  Delaunay dt;


  Interval_skip_list isl;
  for(Finite_faces_iterator fh = dt.finite_faces_begin();
      fh != dt.finite_faces_end();
  std::list<Interval> level;
  isl.find_intervals(50, std::back_inserter(level));
  for(std::list<Interval>::iterator it = level.begin();
      it != level.end();
    std::cout << dt.triangle(it->face_handle()) << std::endl;
  return 0;