Binary search routines : Sort Search « Collections Data Structure « Java

1. Java
2. Collections Data Structure
3. Sort Search

Binary search routines

    
/*
 * Copyright (c) 1998-2002 Carnegie Mellon University.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND
 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY
 * NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */


/**
 * Binary search routines.
 */
public abstract class BinarySearch {


    /**
     * Search a sorted array of integers.
     * @param array Array of integers
     * @param offset Starting offset of subarray to search
     * @param length Length of subarray to search
     * @param x Value to search for
     * @return largest index i in subarray (offset <= i <= offset+length)
     * such that all elements below i in the subarray are strictly less
     * than x.  If x is found in the subarray, then array[i] == x (and i is
     * the first occurence of x in the subarray).  If x is not found, 
     * then array[i] is where x should be inserted in the sort order.
     */
    public static int search (int[] array, int offset, int length, int x) {
        // handle 0-length subarray case right away
        if (length <= 0)
            return offset;

        int low = offset;
        int high = offset+length-1;
        // since length > 0, array[low] and array[high] are valid indices

        if (x <= array[low])
            return low;
        if (x > array[high])
            return high+1;
        
        while (low+1 < high) {
            // loop invariant: array[low] < x <= array[high],
            //                 offset <= low < high < offset+length
            int mid = (low + high)/2;
            if (x <= array[mid])
                high = mid;
            else
                low = mid;
        }
        // now we have array[low] < x <= array[high]
        //             && (low+1 == high || low == high)
        //  implies low+1 == high
        //debug.assertion (low+1 == high);
        return high;
    }
}

   
    
    
    
  

Related examples in the same category

1.	Linear search
2.	Animation for quick sort
3.	Quick Sort Implementation with median-of-three partitioning and cutoff for small arrays
4.	Simple Sort Demo
5.	A simple applet class to demonstrate a sort algorithm
6.	Sorting an array of Strings
7.	Simple version of quick sort
8.	Combine Quick Sort Insertion Sort
9.	Quick sort with median-of-three partitioning
10.	Fast Quick Sort
11.	Selection sort
12.	Insert Sort for objects
13.	Insert sort
14.	Bubble sort
15.	Merge sort
16.	Fast Merge Sort
17.	Binary Search
18.	Shell sort
19.	Recursive Binary Search Implementation in Java
20.	Topological sorting
21.	Heap sort
22.	Sort Numbers
23.	A quick sort demonstration algorithm
24.	Performing Binary Search on Java byte Array Example
25.	Performing Binary Search on Java char Array Example
26.	Performing Binary Search on Java double Array Example
27.	Performing Binary Search on Java float Array Example
28.	Performing Binary Search on Java int Array Example
29.	Performing Binary Search on Java long Array Example
30.	Performing Binary Search on Java short Array
31.	Sort items of an array
32.	Sort an array of objects
33.	Sort a String array
34.	Sort string array with Collator
35.	FastQ Sorts the [l,r] partition (inclusive) of the specfied array of Rows, using the comparator.
36.	A binary search implementation.
37.	Handles QuickSort and all of its methods.
38.	Implements QuickSort three different ways
39.	A quick sort algorithm to sort Vectors or arrays. Provides sort and binary search capabilities.
40.	Returns an array of indices indicating the order the data should be sorted in.