java学习笔记之一些简单排序

冒泡排序：
思想：（1）对数组中的的个数据，依次比较相邻的两个元素的大小
（2）如果前面的数据大于后面的数据，那么交换这两个数据
（3）用同样的方法，将剩下的数据逐一比较
平均的时间复杂度是：O(n^2)   最坏：O(n^2)

public void bubbleSort(int []array){for(int i = 1;i<array.length;i++){for(int j =0;j<array.length-i;j++){if(array[j]>array[j+1]){int temp = array[j];array[j] = array[j+1];array[j+1] = temp;}}}}

选择排序：
思想：
(1)将原始数组中选择一个最小的数据，将其和第一个位置的数据交换
(2)接着从剩下的n-1个数据中选择次小的数据，将其和第二个位置交换
(3)然后不断重复上述过程，知道最后两个数据不再交换

平均时间复杂度：O(n^2)最坏：O(n^2)

public void selectSort(int []array){for(int i = 0;i<array.length-1;i++){int index =i;for(int j =i+1;j<array.length;j++){if(array[j]<array[index]){index = j;}}if(index!=i){int temp = array[i];array[i] = array[index];array[index] = temp;}}}

插入排序：
思想：
(1)首先对数组的前两个数据进行从小到大的排序
(2)接着第3个数据和前两个数据进行比较，将第3个位置插入到合适的位置
(3)然后第4个进行第三步
(4)不断重复，知道最后一个数据插入到合适的位置
平均时间复杂度：O(n^2)最坏：O(n^2)

public void insertSort(int []array){for(int i=1;i<array.length;i++){int t = array[i];int j = i-1;while(j>=0&&t<array[j]){array[j+1] =array[j];j--;}array[j+1] = t;}}

希尔排序：
思想：
（缩小增量排序）
(1)将n个元素的数组分成n/2个数字序列，第一个数据和第n/2+1为一对......
(2)一次循环使得每个序列对排好序
(3)然后变成n/4个序列，再次排序
(4)不断重复上述过程，随着序列减少变为最后一个，也就完成了排序
平均时间复杂度：O(n^3/2) 最坏：O(n^2)

public void shellSort(int []array){for(int r = array.length;r>=1;r/=2){for(int i = r;i<array.length;i++){int temp = array[i];int j = i-r;while(j>=0&&temp<array[j]){array[j+r] = array[j];j-=r;}array[j+r] =temp;}}}

快速排序：
思想：
(1)首先设定一个分界值，以分界值将数据分为左右两部分
(2)将大于分界值的放在数组的右侧，小于分界值的放在数组的左侧
(3)然后，左边和右边的数据独立排序，对于左侧的的数据又可以取一个分界值，将其有分成左右两个部分，同样左边放置较小值，右边放置较大值，右侧的数组也是进行同样的操作。
(4)重复以上操作，可以看出这是一个递归定义，通过将左侧部分排好序后，再递归排好右侧部分顺序，左右两部分的数据排好序后，整个数组也就完成了整个数组的排序


平均时间复杂度：O(nlogn) 最坏：O(n^2)

public static void quickSort(int[] keys) {        quickSort(keys, 0, keys.length-1);    }      private static void quickSort(int[] keys, int begin, int end)    {        if (begin>=0 && begin<keys.length && end>=0 && end<keys.length && begin<end)        {            int i=begin, j=end;                                        int vot=keys[i];                                          while (i!=j)            {                while (i<j && keys[j]>=vot)                                   j--;                if (i<j)                    keys[i++]=keys[j];                                    while (i<j && keys[i]<=vot)                                   i++;                if (i<j)                    keys[j--]=keys[i];                                }            keys[i]=vot;                                                                   quickSort(keys, begin, j-1);                              quickSort(keys, i+1, end);                             }    }

归并排序：
思想：
将含有n个待排序的数据序列看成n个长度为1的有序子表组成，将其依次两两合并然后再对其两两合.....重复这个过程，直到最后长度为n；
平均时间复杂度：O(nlogn)最坏：O(nlogn)

public void merge(int a[],int s,int m,int t,int []temp){//temp =new int[t-s+1];int i = s,j =m+1,k =0;while(i<m&&j<=t){if(a[i]<a[j]){temp[k] = a[i];k++;i++;}else{temp[k] = a[j];j++;k++;}}while(i<m){temp[k] = a[i];k++;i++;}while(j<=t){temp[k] = a[i];j++;k++;}while(s<=t){a[s++] = temp[k++];}}public void mergeSort(int array[],int l,int r,int []temp){if(l<r){int mid = (l+r)/2;mergeSort(array,l,mid,temp);mergeSort(array,mid+1,r,temp);merge(array,l,mid,r,temp);}}public void mergeSort(int []arr){int []temp = new int[arr.length];mergeSort(arr, 0, arr.length-1, temp);}

桶排序O(n)、基数排序O(dn) ----d实常数  
不稳定的排序：
快速排序、希尔排序、堆排序O(nlogn)、选择排序