smile.sort

Interface Sort

public interface Sort

Sort algorithm trait that includes useful static functions such as swap and swift up/down used in many sorting algorithms.

Method Summary

Modifier and Type	Method and Description
static void	siftDown(double[] arr, int k, int n) To restore the max-heap condition when a node's priority is decreased.
static void	siftDown(float[] arr, int k, int n) To restore the max-heap condition when a node's priority is decreased.
static void	siftDown(int[] arr, int k, int n) To restore the max-heap condition when a node's priority is decreased.
static <T extends java.lang.Comparable<? super T>> void	siftDown(T[] arr, int k, int n) To restore the max-heap condition when a node's priority is decreased.
static void	siftUp(double[] arr, int k) To restore the max-heap condition when a node's priority is increased.
static void	siftUp(float[] arr, int k) To restore the max-heap condition when a node's priority is increased.
static void	siftUp(int[] arr, int k) To restore the max-heap condition when a node's priority is increased.
static <T extends java.lang.Comparable<? super T>> void	siftUp(T[] arr, int k) To restore the max-heap condition when a node's priority is increased.
static void	swap(double[] arr, int i, int j) Swap two positions.
static void	swap(float[] arr, int i, int j) Swap two positions.
static void	swap(int[] arr, int i, int j) Swap two positions.
static void	swap(java.lang.Object[] arr, int i, int j) Swap two positions.

Method Detail

swap

static void swap(int[] arr,
                 int i,
                 int j)

Swap two positions.

swap

static void swap(float[] arr,
                 int i,
                 int j)

Swap two positions.

swap

static void swap(double[] arr,
                 int i,
                 int j)

Swap two positions.

swap

static void swap(java.lang.Object[] arr,
                 int i,
                 int j)

Swap two positions.

siftUp

static void siftUp(int[] arr,
                   int k)

To restore the max-heap condition when a node's priority is increased. We move up the heap, exchaning the node at position k with its parent (at postion k/2) if necessary, continuing as long as a[k/2] < a[k] or until we reach the top of the heap.

siftUp

static void siftUp(float[] arr,
                   int k)

To restore the max-heap condition when a node's priority is increased. We move up the heap, exchaning the node at position k with its parent (at postion k/2) if necessary, continuing as long as a[k/2] < a[k] or until we reach the top of the heap.

siftUp

static void siftUp(double[] arr,
                   int k)

To restore the max-heap condition when a node's priority is increased. We move up the heap, exchaning the node at position k with its parent (at postion k/2) if necessary, continuing as long as a[k/2] < a[k] or until we reach the top of the heap.

siftUp

static <T extends java.lang.Comparable<? super T>> void siftUp(T[] arr,
                                                               int k)

To restore the max-heap condition when a node's priority is increased. We move up the heap, exchaning the node at position k with its parent (at postion k/2) if necessary, continuing as long as a[k/2] < a[k] or until we reach the top of the heap.

siftDown

static void siftDown(int[] arr,
                     int k,
                     int n)

To restore the max-heap condition when a node's priority is decreased. We move down the heap, exchanging the node at position k with the larger of that node's two children if necessary and stopping when the node at k is not smaller than either child or the bottom is reached. Note that if n is even and k is n/2, then the node at k has only one child -- this case must be treated properly.

siftDown

static void siftDown(float[] arr,
                     int k,
                     int n)

To restore the max-heap condition when a node's priority is decreased. We move down the heap, exchanging the node at position k with the larger of that node's two children if necessary and stopping when the node at k is not smaller than either child or the bottom is reached. Note that if n is even and k is n/2, then the node at k has only one child -- this case must be treated properly.

siftDown

static void siftDown(double[] arr,
                     int k,
                     int n)

To restore the max-heap condition when a node's priority is decreased. We move down the heap, exchanging the node at position k with the larger of that node's two children if necessary and stopping when the node at k is not smaller than either child or the bottom is reached. Note that if n is even and k is n/2, then the node at k has only one child -- this case must be treated properly.

siftDown

static <T extends java.lang.Comparable<? super T>> void siftDown(T[] arr,
                                                                 int k,
                                                                 int n)

To restore the max-heap condition when a node's priority is decreased. We move down the heap, exchanging the node at position k with the larger of that node's two children if necessary and stopping when the node at k is not smaller than either child or the bottom is reached. Note that if n is even and k is n/2, then the node at k has only one child -- this case must be treated properly.