Java冒泡，快速，插入，选择排序^_^+二分算法查找

这段时间在学Java，期间学到了一些排序和查找方法。特此写来和大家交流，也方便自己的日后查看与复习。

1.下边是Java的主类：

public class Get
{
    public static void main(String[] args)
    {    
        
        int len=10;
        int[] a=new int[len];
        
        for(int i=0;i<len;i++)
        {
            int t=(int)(Math.random()*10);
            a[i]=t;
        }
        
        //静态初始化数组
        //int[] b=new int[]{1,2};
//        动态初始化数组：由下面看出动态初始化就是只指定数组的长度，由系统为数组分配初始值。
        int[] b=new int[10];
    
//        int a[]={2,45,34,1,3,6,5,67,867,76};
//        int a[]={4,2,45,34,1,3,6,5,67,867,76};
        Insert is=new Insert();
        is.sort(a);
//        Bubble bub=new Bubble();
//        bub.bubblesort(a);
        Select sl=new Select();
        sl.sort(a);
//        Quick qc=new Quick();
//        qc.sort(a, 0, a.length-1);
        
        
        for(int i=0;i<a.length;i++){
            b[i]=a[i];
            System.out.print(b[i]+"  ");
        }
        
        BinaryFind bf=new BinaryFind();
       
        /*System.out.println("Hello World!");
        Fun f=new Fun(23,"李四");
        System.out.println("我的名字叫"+f.name);
        System.out.println("我的年龄为"+f.age);*/
    }
}

其中，以下代码将定义一个数组，并且将产生一组随机数，存放在数组a[]中：

int len=10;
        int[] a=new int[len];
        
        for(int i=0;i<len;i++)
        {
            int t=(int)(Math.random()*10);
           a[i]=t;
        }

数组的初始化方式有静态和动态俩种，不能够混合使用，如

int[] b=new int[2]{1,2};将会报一个经典的错误。

2.二分算法查找。

二分算法的主要思想是：递归。一次没找到，将会不停的调用该函数，直到不满足条件或者找到该函数为止。

代码如下：

//二分算法！！！
class BinaryFind
{
    public void find(int left,int right,int a[],int val)
    {
        //找到中间的数midVal
      int midIndex=(left+right)/2;
        int midVal=a[midIndex];
        
        if(left<=right)
        {       
            //当左边小于右边时执行以下操作：
            if(midVal>val)
            {
                //递归调用
                find(left,midIndex-1,a,val);
            }else if(midVal<val)
            {
                find(midIndex+1,right,a,val);
            }else
            {
                System.out.println("已经找到该数,下标为："+midIndex);
            }
        }else
        {
            System.out.println("找不到该数");
        }
    }
}

3.插入排序

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)

//插入排序！！！
class Insert
{
    public void sort(int a[])
    {
        for(int i=1;i<a.length;i++)
        {
            int insertVal=a[i];
          //将insertVal与前一个数比较
            int index=i-1;
            while(index>=0&&insertVal<a[index])
            {
                //将a[index]向后移动
                a[index+1]=a[index];
                //让index向前移动
                index--;
            }
           //否则将insertVal插入到适当位置
            a[index+1]=insertVal;
        }
    }
}

谨记如果此判断条件index>=0的等号忘记加，则，数组中的第一个元素将不会参与排序！！！

while(index>=0&&insertVal<a[index])

4.快速排序！！！
//* 快速排序。
//* 思想：选定一个元素作为枢纽元素，将小于该元素的元素放到左边，大于该元素的放到右边。不断重复此过程。
//* 直到最终形成一个有序的列表。
//* 下面的参数low,high就是可以支持一个数组的一个子区间进行排序。
//* 如果是整个数组进行排序，则low=0,high=数组.length-1。
//* @param data:要排序的数组。
//* @param low:排序的起始位置
//* @param high:排序的结束位置。

class Quick
{
    public void sort(int a[], int low, int high){
        int i=low;
        int j=high;
        int key=a[low];
        
        if (low < high) {
           // 枢纽元素
            System.out.println("枢纽元素是：" + key + ",low:" + low + ",high:" + high);
        
        while(i<j)
        {
            while(i<j&&key<=a[j])    
            {
                j--;
            }
            a[i]=a[j];
//            int temp=a[j];这三行可以与前面一行互换，实现的功能相同。
//            a[j]=a[i];
//            a[i]=temp;</span>
            while(i<j&&key>=a[i])
            {
                i++;
            }
            a[j]=a[i];
//下面标红三行与上面一行功能相同
//            int temp1=a[j];
 //            a[j]=a[i];
//            a[i]=temp1;</span>

               a[i]=key; 
             } 
            sort(a,low,i-1);
            sort(a,i+1,high);
    }
   }
  }

 

快速排序值得注意的地方为，在主函数中调用方法要注意数组越界的问题。

即       Quick qc=new Quick();           qc.sort(a, 0, a.length-1);在传递实参的时候是a.length-1而不是a.length

5.选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

//选择排序！！！
class Select
{    int temp;
    public void sort(int a[]){
        for(int i=0;i<a.length-1;i++){
            
            for(intj=i+1;j<a.length;j++){
                 
                  将俩个元素进行比较
                 if(a[i]>a[j]){
                    temp=a[j];
                    a[j]=a[i];
                    a[i]=temp;
                }
            }
        }        
    }
}

6.冒泡排序

冒泡排序重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

//冒泡排序！！！
class Bubble
{    
    int temp;
  public void bubblesort(int a[]){    
    for(int i=0;i<a.length-1;i++){    

        for(int j=0;j<a.length-1-i;j++){  
               //a.length-1-i是因为最后的i个元素已经有序。

            if (a[j]>a[j+1])
            {
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
                
    }
  }
}

7.二维数组
这是自己先前用来练手的二维数组的使用方法，一起来看看吧。

//将一个矩阵倒置输出！！！
class Array
{
    //int num[][];
    int  num[][]={
                {1,2,3},
                {4,5,6},
                {7,8,9}
                };
    public  void get(){
        System.out.println("原数组为：");
        for(int i=0;i<=2;i++){
            for(int j=0;j<=2;j++){
                System.out.print(num[i][j]+"	");
            }
            System.out.println("
");
        }
        System.out.println("倒置后的数组为：");
        for(int i=0;i<=2;i++){
            for(int j=0;j<=2;j++){
                System.out.print(num[j][i]+"	");
            }
            System.out.println("
");
        }
    
    }

}

8.99乘法表
先前学习的俩层循环，99乘法表  ^_^

//输出99乘法表！！！
class Table
{
    public static void get(){
    for(int i=1;i<=9;i++){
        for(int j=1;j<=i;j++){
           System.out.print(i+"*"+j+"="+i*j+"	");
            
            }
        System.out.print("
");
        }
    }
}