JAVA总结

笔记

volatile

1. 保证可见性
2. 不保证原子性
3. 禁止指令重排序

JMM

排序

\

交换排序（冒泡排序，快速排序）

public class SortPractise {
    public static void main(String[] args) {
        int[] a =  {1,32,43,5,6,8,789,9,9,0,10};
        for (int i: a) { System.out.print(i + "     "); }
        /**
         * 交换排序：冒泡排序，快速排序
         */

        //bubblesort(a);

       // quickSortImpl(a,0,a.length-1);

        /**
         * 插入排序：直接插入 希尔排序
         */

        System.out.println();

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

    }

    /**
     * 快速排序
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(nlogn)
     * 不稳定
     */
    private static void quickSortImpl(int[] a, int left, int right) {
        if(left >right) return;
        int tmp = a[left];
        int i = left;
        int j = right;
        while(i<j){
            while(tmp <= a[j] && i < j) j--;
            while(tmp >= a[i] && i < j) i++;
            {
                int l  = a[i];
                a[i] = a[j];
                a[j] = l;
            }
        }
            a[left] = a[i];
            a[i] = tmp;
        quickSortImpl(a,  left,i-1);
        quickSortImpl(a,i+1,right);

    }

    /**
     *冒泡排序 Bubble
     *时间复杂度O(n*n)
     * 空间复杂度O(1)
     * 稳定
     */
    private static void bubblesort(int[] a) {
        int len = a.length;
        for(int i = 0; i < len; i++){
            for (int j = 0; j < len -1 - i; j++) {
                if(a[j] >  a[j + 1]) {
                    int tmp = a[j ];
                    a[j] = a[j+1];
                    a[j+1]  = tmp;
                }
            }
        }
    }
}

插入排序（普通插入排序，希尔排序）

/**
     * 插入排序
     * 时间复杂度O(n*n)
     * 空间负责度O(1)
     * 稳定
     */
  private static void insertSort(int[] a) {
      int len = a.length;
      for (int i = 1; i <len ; i++) {
          for (int j = i; j >0 ; j--) {
              if(a[j] < a[j-1]){
                  int tmp = a[j];
                  a[j] =  a[j-1];
                  a[j-1] = tmp;
              }
          }
      }
  }
    /**
     * 希尔排序
     * 时间复杂度O（n^1.5）
     * 空间复杂度O（1）
     *不稳定
     *
     */
  private static void shellSort(int[] a) {
    int len = a.length;
    int gap =  len/2;
    while(gap > 0){
        for (int i = gap; i < len; i++) {
            int j = i;
            while(j >= gap && a[j] < a[j - gap]) {
                swap(a,j,j-gap);
                    j -= gap;
            }
        }
        gap /= 2;
    }
   }

选择排序

    /**
     * 选择排序
     * 时间复杂度：O(n*n)
     * 空间复杂度：O(1)
     *不稳定
     */

    private static void choseSort(int[] a) {
      int len = a.length;
        for (int i = 0; i < len; i++) {
//            int min = a[0];
            int count = i;
            for (int j = i + 1; j < len; j++) {
                if (a[count] > a[j]){
                    count = j;
                }

            }
            swap(a,count,i);
        }

堆排序

    /**
     * @堆排序
     * @时间复杂度：O(nlogn)
     * @空间复杂度 O(nlogn)
     * 不稳定
     */
private static void heapSort(int[] a) {
        int len = a.length;
        //初始化最大堆
        for (int i = len/2 -1; i >=0; i--) {
            adjustHeap(a,i,len);
        }

        for (int j = len-1; j >0 ; j--) {
            swap(a,0,j);
            adjustHeap(a,0,j);
        }
    }

    private static void adjustHeap(int[] a, int i,  int len) {
        int tmp = a[i];  //拿出堆顶的数
        for (int k = i*2 +1; k < len ; k = k*2 +1) {
           if(k+1 < len && a[k] < a[k+1]){ //如果右孩子存在，且有孩子比左孩子大，
               k++;
           }
           if(tmp > a[k]) break;
           else {
               a[i] = a [k];
               i = k;
           }
        }
        a[i] = tmp;
    }

归并排序

 /**
     * 归并排序
     * 时间复杂度：nlogn
     * 空间复杂度：n
     * 稳定
     * */
    private static void merge_sort_recursive(int[] a, int[] result, int start, int end) {
        if(start >= end) return;


        int len = end - start, mid = len/2 +start;
        int start1 = start, end1 = mid;
        int start2 = mid+1, end2 = end;//二分进行拆分
        merge_sort_recursive(a, result, start1, end1);
        merge_sort_recursive(a, result, start2, end2); //递归调用

        int k = start;

        while(start1 <= end1 && start2 <= end2) result[k++] = a[start1]< a[start2]? a[start1++]:a[start2++]; //取两边小的放入临时数组
        while(start1 <= end1) result[k++] = a[start1++];//取出剩余的元素放到临时队列中
        while(start2 <= end2) result[k++] = a[start2++];

        for (k = start; k <= end ; k++) {
            a[k]  = result[k]; // 将临时数组的元素放入a中
        }
    }