算法01——二分查找、冒泡排序、插入排序、快速排序、归并排序

一、二分查找

java写法：

package SuanFa.MySearch;

public class binSearch {
    public static void main(String[] args) {

        int[] a={1,2,3,4,5,6,7};
        System.out.println(myBinSerch(a,2));

    }


    public static int myBinSerch(int[] a,int n){
        int left=0;
        int right=a.length-1;
        int mid;
        while (left<=right) {
            mid = (left + right) / 2;
            if (a[mid] == n) {
                return mid;
            } else if (a[mid] < n) {
                left=mid+1;
            }
            else  if (a[mid]>n){
                right=mid-1;
            }
        }
        return -1;
    }
}

Scala写法

package SuanFa.MySearch

object sbinSearch {
  def main(args: Array[String]): Unit = {

var arr=Array(1,2,5,6,7,9)
println(search(arr,5))

  }

  def search(a: Array[Int], n: Int): Int = {
    var left: Int = 0
    var right: Int = a.size - 1
    while (left <= right) {
      var left = 0
      var right = a.size - 1
      while (left <= right) {
        var f = 2
        var mid = (left + right) / 2
        if (a(mid) > n) {
          right = mid - 1}
        else if (a(mid) < n) {
          left = mid + 1}
        else {
          return mid}
      }
    }
    return -1
  }
}

 

 

二、冒泡排序

首先看一下各种排序的复杂度

 

java写法：

package SuanFa.MySort;

public class bubbleSort {

    public static void main(String[] args) {

        int[] a={3,5,4,8,1,9,13,2,4};
         myBubbleSort(a);
        for(int i:a){
            System.out.println(i+"  ");
        }
    }

    public static void myBubbleSort(int[] a){
        int l=a.length;
        int t;
        for(int i=0;i<l-1;i++){
            for(int j=0;j<l-1-i;j++){

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

       return ;
    }
}

Scala写法：

package SuanFa.MySort

object bubbleSort2 {
  def main(args: Array[String]): Unit = {
    val a=Array(7,3,5,1,6,4,8)
    bubbleSort2(a)

    for(i<- 1 to  a.size-1){
      println(a(i))
    }
  }
  def bubbleSort2(arr:Array[Int]){
    for(i<- 0 until arr.length-1) {
      for (j <- 0 until arr.length - 1 - i) {
        if (arr(j) > arr(j + 1)) {
          val t = arr(j)
          arr(j) = arr(j + 1)
          arr(j + 1) = t
        }
      }
    }
  }
}

 

三、插入排序

java写法

    public static void myInsertSort(int[] a){
        int num;
        for(int i=1;i<a.length;i++){
            num=a[i];
            int j;
            for(j=i-1;j>=0;j--){
                if(a[j]>num){
                    a[j+1]=a[j];
                }
                else {
                    break;}
            }
            if(num!=a[i]){
                a[j+1]=num;}
        }
    }

scala写法

 

package SuanFa.MySort
import scala.util.control.Breaks._
object insertSort2 {
  def main(args: Array[String]): Unit = {

    val a=Array(7,3,5,1,6,4,8)
    insertSort2(a)
    for(i<- 1 to  a.size-1){
      println(a(i))
    }
  }
  
  def insertSort2(arr:Array[Int]){

    for(i<- 1 until arr.size){
      var num=arr(i)

      var j=i-1
      breakable {
        while (j >= 0) {
          if (arr(j) > num) {
            arr(j+1) = arr(j)
          }
          else {
            break;
          }
          j = j - 1
        }
      }
      if(num!=arr(i)){
        arr(j+1)=num
      }
    }

  }

}

 

四、快速排序

 

java版本

package SuanFa.MySort;

public class quickSort {
    public static void main(String[] args) {
        int[] a={3,5,4,8,1,9,13,2};
        myQuickSort(a,0,a.length-1);

        for(int i:a){
            System.out.println(i+"  ");
        }
    }


    public static void myQuickSort(int[] arr,int low,int high){
        int start=low;
        int end=high;
        int key=arr[low];
       while(start<end){

            while(start<end&&arr[end]>=key){end--;}
            if(arr[end]<key){int t=arr[start];arr[start]=arr[end];arr[end]=t; }

            while(start<end&&arr[start]<=key){start++;}
            if(arr[start]>key){int t=arr[start];arr[start]=arr[end];arr[end]=t;}
        }

        if(start>low){myQuickSort(arr,low,start-1);}
        if(end<high){myQuickSort(arr,end+1,high);}
    }

}

 

scala版本

package SuanFa.MySort

object quickSort2 {
  def main(args: Array[String]): Unit = {
    val a=Array(7,3,5,1,6,4,8)
    quickSort2(a,0,a.size-1)
    for(i<- 1 to  a.size-1){
      println(a(i))
    }
  }



  def quickSort2(arr:Array[Int],low:Int,high:Int){

    var key=arr(low)
    var start=low
    var end=high

    while(start<end){
      while(start<end&&key<=arr(end)){end=end-1}
      if(key>arr(end)){val t=arr(start)
        arr(start)=arr(end)
        arr(end)=t}

      while(start<end&&key>=arr(start)){start=start+1}
      if(key<=arr(start)){val t=arr(start)
        arr(start)=arr(end)
        arr(end)=t }
    }

    if(low<start){quickSort2(arr,low,start-1)}
    if(end<high){quickSort2(arr,end+1,high)}

  }

}

五、归并排序

java版本

package SuanFa.MySort;

public class mergeSort {

    public static void main(String[] args) {

        int[] a={3,5,4,8,1,9,13,2};
        myMergeSort(a,0,a.length-1);

        for(int i:a){
            System.out.println(i+"  ");
        }
    }

    public static void myMergeSort(int[] arr,int left,int right) {
    if(left>=right)
    {return;}
    int center=(left+right)/2;
    myMergeSort(arr,left,center);
    myMergeSort(arr,center+1,right);

    myMerge(arr,left,center,right);
    }

    private static void myMerge(int[] arr,int left,int center,int rigth) {
        int arrStart=left;//记录原始数组的最小下标

        int[]tmpArr=new int[arr.length];
        int mid=center+1;
        int tmpNow=left;


        while (left<=center&&mid<=rigth){
            if(arr[left]<=arr[mid]){ tmpArr[tmpNow++]=arr[left++];}
            else {tmpArr[tmpNow++]=arr[mid++];}
        }

        while (left<=center){tmpArr[tmpNow++]=arr[left++];}
        while (mid<=rigth){tmpArr[tmpNow++]=arr[mid++];}

        //将临时数组全部拷贝到原数组
        while (arrStart<=rigth){ arr[arrStart]=tmpArr[arrStart++];}
    }
}

scala版本

package SuanFa.MySort

object mergeSort2 {
  def main(args: Array[String]): Unit = {
    val a=Array(7,3,5,1,6,4,8)
    myMergeSort2(a,0,a.size-1)
    for(i<- 1 to  a.size-1){
      println(a(i))
    }
  }






  def  myMergeSort2(arr: Array[Int],left:Int,right:Int){

    if(left>=right){
      return
    }

    var center=(left+right)/2

    myMergeSort2(arr,left,center)
    myMergeSort2(arr,center+1,right)


    myMerge(arr,left,center,right)

  }


  def myMerge(arr:Array[Int], left0:Int,center0:Int, right0:Int){

var left=left0
    var center=center0
    var right=right0


    var ArrayStart=left
    var tmpArray=new Array[Int](arr.size)
    var mid=center+1
    var  tmpArrayNow=left

    while(left<=center&&mid<=right){
      if(arr(left)<=arr(mid)){
        tmpArray(tmpArrayNow)=arr(left)
        tmpArrayNow+=1
        left+=1
      }else{
        tmpArray(tmpArrayNow)=arr(mid)
        tmpArrayNow+=1
        mid+=1
      }
    }

    while(left<=center){  tmpArray(tmpArrayNow)=arr(left)
      tmpArrayNow+=1
      left+=1
    }

    while(mid<=right){
      tmpArray(tmpArrayNow)=arr(mid)
      tmpArrayNow+=1
      mid+=1}

    while(ArrayStart<=right){arr(ArrayStart)=tmpArray(ArrayStart)
      ArrayStart+=1
    }
  }

}