Java 基本算法实现

• 冒泡算法
• 选择排序
• 插入算法
• 快速排序
• 希尔排序
• 堆排序
• 基数排序
• 归并排序

---

1、冒泡算法

 冒泡排序算法的运作如下:

 1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
 2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
 3. 针对所有的元素重复以上的步骤，除了最后一个。
 4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

 public static void bubbleSort() {
        int a[] = {1, 2, 5, 3, 4, 7, 9, 8, 4, 0};
        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 value : a) {
            System.out.print(" " + value);
        }
    }

    public static void main(String[] args) {
        bubbleSort();
    }

2.选择排序

思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

/**
      外循环去除已经排好序的
       内循环排序
    **/
    public static void selectSort(int []array ){
         int position =0;// 记录最小值位置
         for(int i=0;i<array.length;i++){
             int j=i+1;
             position=i;
             int temp=array[i];// 最小值ֵ
             for(;j<array.length;j++){
                 if(array[j]<temp){
                     temp=array[j];
                     position=j;
                 }
             }
             // 交换
             array[position]=array[i];
             array[i]=temp;
         }
         System.out.println(Arrays.toString(array)+ " selectSort ");
    }

3 插入排序

  // 和选择排序的区别,选择排序左边是 整个数组的从小到大的排序，插入 排序左边是目前已经排序的（和打扑克起牌一样）
  //  已知左边是已经排序好的，右边找一个插入已经排好的数组中
  // 外层循环 从第二个开始寻找需要插入的数据；内层循环移动所有比他大的数据；然后插入数据。

  public static void insertSort(int[] array ){
      for(int i=1;i<array.length;i++){
          int temp=array[i];
          int j=i-1;
          for(;j>=0&&array[j]>temp;j--){
              // 将大于temp 的值 整体往后移动一个单位； 
              array[j+1]=array[j];
          }
          //j+1 即要插入的位置； 
          array[j+1]=temp;

      }

    for(int value:array){
        System.out.print(value);
     }


  }

4.快速排序 算法

思想 ： 从数列中挑出一个元素，称为 “基准”， 通过一趟排序将待排序数据分割成独立的两部分，其中一部分数据比基准小，另一部分比基准大，然后分别对这两部分继续进行排序，直到整个序列有序。
分而治之.
（算法思想：基于分治的思想，是冒泡排序的改进型。首先在数组中选择一个基准点（该基准点的选取可能影响快速排序的效率，），然后分别从数组的两端扫描数组，设两个指示标志（lo指向起始位置，hi指向末尾)，首先从后半部分开始，如果发现有元素比该基准点的值小，就交换lo和hi位置的值，然后从前半部分开始扫秒，发现有元素大于基准点的值，就交换lo和hi位置的值，如此往复循环，直到lo>=hi,然后把基准点的值放到hi这个位置。一次排序就完成了。以后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了）（三数取中）

    /**
     * 算法是模拟人的操作 ，你自己在纸上移动数据的方式 让代码帮你实现 
     * @param args
     */
    // 递归执行
    // 1.把整个序列看做一个数组，把第零个位置看做中轴，和最后一个比，如果比它小交换，比它大不做任何处理；
    // 2.交换了以后再和小的那端比，比它小不交换，比他大交换。
    // 3.这样循环往复，一趟排序完成，左边就是比中轴小的，右边就是比中轴大的，
    // 4.然后再用分治法，分别对这两个独立的数组进行排序
    public static void main(String[] args) {
        int array[] = {6, 5, 3, 2, 1, 8, 7, 2, 4};
        quickSort(array);
    }

    private static void quickSort(int [] array) {
        quickSort(array,0,array.length-1);
       System.out.println(Arrays.toString(array) +" quickSort");

    }
    public static void quickSort(int [] list ,int low,int high){
        if (low<high){
            int middle=getMiddle(list,low,high);
            quickSort(list,low,middle-1);
            quickSort(list,middle+1,high);
        }
    }

    private static int getMiddle(int[] list, int low, int high) {
        int temp=list[low];
        while (low<high){
            // 右边有大于中轴的
            while (low<high &&list[high]>=temp){
                high--;
            }
            list[low]=list[high];
            while (low<high&&list[low]<=temp){
                low++;
            }
            // 不满足上面条件的
            list[high]=list[low];
        }
        list[low]=temp;// 设置中轴的值
        return low;
    }
    常被认为在同数量级（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排序反而蜕化为冒泡排序。
    // 为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。

5.希尔排序

希尔排序也成为“缩小增量排序”，其基本原理是，现将待排序的数组元素分成多个子序列，使得每个子序列的元素个数相对较少，然后对各个子序列分别进行直接插入排序，待整个待排序列“基本有序”后，最后在对所有元素进行一次直接插入排序。
希尔排序的关键并不是随便分组后各自排序，而是将相隔某个“增量”的记录组成一个子序列，实现跳跃式移动，使得排序的效率提高。
// 借鉴