Java中几种简单的算法

冒泡排序:

    冒泡排序的思路: 相邻的两个数进行比较

    (1):首先需要连个for 循环

    (2):最外层for 循环控制最里面 for 循环的循环次数

    (3):通过设置中间参数的方式进行交换

    (4):代码如下:

 

    //冒泡排序

    public void bubbleSort() {

           //声明数组

            int a[] = {49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51};

            int temp = 0;

            //最外层是不是用来控制里面接下来需要比较多少次

            for (int i = 0; i < a.length - 1; i++) {

                //冒泡排序,把最大的数放到后面

                for (int j = 0; j < a.length - 1 - i; j++) {

                 //

                    if (a[j] > a[j + 1]) {

                        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]);

        }

 

    两个数直接的交互方式:

    注意: 在不引入其它变量的情况下交换两个数，利用两数之和来做

    // a = a+b; //a保存两数之和

    // b = a-b; //两数之和-b，即为a

    // a = a-b; //两数之和-b，此时的b已经变成了a，所以相当于sum-a=b

    // System.out.println("swapBySelf first function:a="+a+",b="+b);

    // //还有另一种方法,利用两数之差，即两数之间的距离

    // a = b-a; //a=两者的差

    // b = b-a; //b = 原来的b-两数的距离==原来的a

    // a = a+b; //最终的a=两者之差+原来的a==原来的b

 

快速排序:(具体实现思路如下)

    选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分

    public static void _choiceSort(Integer[] a) {

        if (a == null || a.length <= 0) {

            return;

           }

        for (int i = 0; i < a.length; i++) {

            int min = i; /* 将当前下标定义为最小值下标 */

 

             for (int j = i + 1; j < a.length; j++) {

                if (a[min] > a[j]) { /* 如果有小于当前最小值的关键字 */

                    min = j; /* 将此关键字的下标赋值给min */

                    }

               }

            if (i != min) {/* 若min不等于i，说明找到最小值，交换 */

                int tmp = a[min];

                a[min] = a[i];

                a[i] = tmp;

                }

         }

      }

 

二分查找:(主要是查找指定的一个数)当数据量很大适宜采用该方法。采用二分法查找时，数据需是有序不重复的

 

基本思想：假设数据是按升序排序的，对于给定值 x，从序列的中间位置开始比较，如果当前位置值等于 x，则查找成功；若 x 小于当前位置值，则在数列的前半段中查找；若 x 大于当前位置值则在数列的后半段中继续查找，直到找到为止。

 

public class DichotomySearch { 

    public static void main(String[] args) { 

        int[] arr = new int[] { 12, 23, 34, 45, 56, 67, 77, 89, 90 }; 

        System.out.println(search(arr, 12)); 

        System.out.println(search(arr, 45)); 

        System.out.println(search(arr, 67)); 

        System.out.println(search(arr, 89));

        System.out.println(search(arr, 99));

       }

    public static int search(int[] arr, int key) { 

        int start = 0; 

        int end = arr.length - 1; 

        while (start <= end) { 

           int middle = (start + end) / 2; 

           if (key < arr[middle]) {

                 end = middle - 1;

             } else if (key > arr[middle]) { 

                 start = middle + 1; 

             } else {

                 return middle; 

             } 

          } 

          return -1; 

     }

   }

 

选择排序

 

选择排序（Selection sort）是一种简单直观的 排序算法。它的工作原理是每一次从待排序的 数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。

int [] is ={1,6,5,4,7};
int temp=0;
for(int i=0;i<is.length-1;i++){
    for(int j=i+1;j<is.length;j++){
      if(is[j]<is[i]){
          temp =is[i];
          is[i] = is[j];
          is[j]=temp;
      }
    }
}
for(int i=0;i<is.length;i++){
    System.out.println(is[i]);
}