【Java】数组算法-CFANZ编程社区

文章目录

数组的算法

一、冒泡排序算法
二、选择排序算法
三、二分法

数组的算法

一、冒泡排序算法

原始数据：3 1 6 2 5
经过算法后：1 2 3 5 6

第一次

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 2 3 5
1 2 3 5

第三次

1 3 2
1 2 3

第四次

冒泡排序算法就是通过相邻的两个数的比较大小后，依次转换位置，首先确定出最大的数。从左往右依次得出。

package 数组算法;
public class bubbleSort {
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
      
    //创建数组
    int[] a = new int[]{3,1,6,2,5};
    
    //开始冒泡排序
    //外层控制循环排序次数
    for(int i = a.length-1;i>0;i--){
      //内层循环控制每次排序
      for(int j = 0; j<i; 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.print(a[i]+" ");
    }
  }
}

结果：
1 2 3 5 6

返回顶部

二、选择排序算法

选择排序即为从数组中选出最小的数与第一个位置的数进行交换。从前往后依次得出。（与冒泡排序相反）

package 数组算法;
public class selectSort {

  public static void main(String[] args) {

    // 创建数组
    int[] a = new int[] { 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 = 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]);
    }
  }
}

结果：
1
2
3
5
6

三、二分法

数学上的二分法：
二分法是指对于区间[a，b]上连续不断且f（a）·f（b）<0的函数y=f（x），通过不断地把函数f（x）的零点所在的区间一分为二，使区间的两个端点逐步逼近零点，进而得到零点近似值的方法。

相比于数学的二分法，我们这里的区间是在一个数组内，零点结尾要查找的数

二分法查找：

二分法是建立在已经排好序的基础上
以下示例是从小到大的排序方式排好的
在这个数组中没有重复的数
例如数组： 1 3 5 9 11 13 56

int begin = 0;

int end = 6;

int mid = 3;

中间元素是9，9<13

begin = mid+1;

end = 6;

mid = 5;

中间元素是13. 13==13

public class MyArray {
  private static int binarySearch(int[] a, int destElement) {
    int begin = 0;
    int end = a.length - 1;
    
    while (begin <= end) {
      int mid = (begin + end) / 2;
      
      // 分三类情况：
      //  1.当数组内中间数等于要查询的数
      
      if (a[mid] == destElement) {
        return mid;
      
      //  2.当数组的中间数大于要查询的数
      
      } else if (a[mid] > destElement) {
        end = mid - 1;
      
            //  3.当数组中的数小于要查询的数
            
            } else if (a[mid] < destElement) {
        begin = mid + 1;
      }
    }
    return -1;
  
  }

  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub

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

结果：
10在数组中的下标是：7

若查询的数不在数组中：

int[] a = new int[] { 1, 3, 4, 5, 7, 8, 9, 10, 23, 25 };
int destElement = 100;
// 要求从这个数组里查找10元素的下标
int index = binarySearch(a, destElement);
System.out.println((index == -1) ? destElement + "元素不存在！"
    : destElement + "在数组中的下标是：" + index);    
    
结果：
100元素不存在！

返回顶部