冒泡排序 选择排序 二分法查找

package rshuzu;

/*
 * 冒泡排序算法：
 *         int类型数组：3 1 6 2 5
 */
public class BubbleSort {

    public static void main(String[] args) {

        int[] a = {3,1,6,2,5};
        
        //开始排序
        for(int i=a.length-1; i>0; i--){ //一共有多少次大循环
            for(int j=0;j<i;j++){ //每个子循环会循环j次
                if(a[j]>a[j+1]){
                    //交换位置
                    int temp; //中间变量
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        
        //遍历
        for(int i=0; i<a.length; i++)
            System.out.println(a[i]);
    }
}

/*
 * 3 1 6 2 5
 * 
 * 第一次循环：
 * 1 3 6 2 5
 * 1 3 6 2 5
 * 1 3 2 6 5
 * 1 3 2 5 6
 * 
 * 1 3 2 5
 * 第二次循环：
 * 1 3 2 5 
 * 1 2 3 5
 * 1 2 3 5
 * 
 * 1 2 3
 * 第三次循环：
 * 1 2 3
 * 1 2 3
 * 
 * 1 2
 * 第四次循环：
 * 1 2
 */

package rshuzu;

/*
 * 选择排序：
 *         3 1 6 2 5
 * 
 *         算法：找出最小值，然后这个最小值和最前面的数据交换位置
 */
public class SelectSort {

    public static void main(String[] args) {

        int[] a = {3, 1, 6, 2, 5};
        
        //选择排序
        for(int i=0; i<a.length-1; i++){
            
            //记录最小值元素的下标
            int min = i; //记录索引值
            
            for(int j=i+1; j<a.length; j++){
                
                if(a[min]>a[j]){
                    //给min重新赋值
                    min = j;
                }
            }
            
            //考虑交换位置
            if(min != i){
                int temp;
                temp = a[i];
                a[i] = a[min];
                a[min] = temp;
            }
        }
        
        //输出
        for(int i=0; i<a.length; i++){
            System.out.println(a[i]);
        }
    }

}

/*
 * 3 1 6 2 5
 * 第一次循环：
 * 1 3 6 2 5
 * 
 * 3 6 2 5
 * 第二次循环：
 * 2 6 3 5
 * 
 * 6 3 5
 * 第三次循环：
 * 3 6 5
 * 
 * 6 5
 * 第四次循环：
 * 5 6
 * 
 * 第一次索引值是0 第二次是1 以此类推
 */

package rshuzu;
/*
 * 二分法查找
 *         1、二分法查找是建立在已经排序的基础之上的
 *         2、以下程序分析从小到大排序
 *         3、这个数组中没有重复的元素
 * 
 *         1 3 5 9 11 13 56
 *         以上是一个已经排好序的int类型的数组，要求快速找出13这个元素的下标
 * 
 *         int begin = 0;
 *         int end = 6;
 *         int mid = 3;
 *         中间元素是9，9<13
 * 
 *         begin = mid + 1; //4
 *         end = 6;
 *         mid = 5;
 *         中间元素是13.  13==13
 */
public class MyArrays {

    public static void main(String[] args) {

        int[] a = {1,3,4,5,7,8,9,10,23,29};
        
        int destElement = 7;
        
        //要求从a数组中查找10这个元素的下表
        int index = binarySearch(a,destElement); //找不到元素则返回-1
        
        System.out.println((index == -1)? "-1": "下标是："+ index);
    }

    //折半查找的核心算法
    public static int binarySearch(int[] a, int destElement){
        
        int begin = 0;
        int end = a.length - 1;
        
        while(begin <= end){ //为了防止查找不到所导致的死循环
            
            int mid = (begin + end)/2; //mid每时每刻在变
            
            if(a[mid] == destElement){
                return mid;
            }else if(a[mid] > destElement){
                end = mid - 1;
            }else if(a[mid] < destElement){
                begin = mid + 1;
            }
        }
        
        return -1;
    }
}

package rshuzu;

import java.util.Arrays;

/*
 * Arrays是SUN提供的一个工具类
 * 
 * java.util.Arrays;
 * 
 *         该工具类主要针对的是数组的操作
 *         排序，二分查找等
 */
public class ArraysTest {

    public static void main(String[] args) {

        int[] a = {3,1,6,2,5};
        
        //排序
        Arrays.sort(a);
        
        //输出
        for(int i=0; i<a.length; i++){
            System.out.println(a[i]);
        }
        
        //对排序之后的数据进行二分查找
        int index = Arrays.binarySearch(a, 1); //0
        System.out.println("下标：" + index);
    }

}