排序

1. 冒泡排序

时间复杂度：最好O(n)，平均和最坏情况O(n2)
空间复杂度：O(1)
稳定排序
原理：从第一个元素开始，依次比较相邻两个元素，如果前者比后者大，那么就交换者两个元素，然后处理下一组，依次类推，直到排序完成。
实现：

  1. publicvoid bubbleSort(int[] arr){
  2. boolean isChanged =false;
  3. for(int i =0; i < arr.length -1; i++){
  4. isChanged =false;
  5. for(int j =0; j < arr.length -1- i; j++){
  6. if(arr[j]> arr[j+1]){
  7. int tmp = arr[j];
  8. arr[j]= arr[j+1];
  9. arr[j+1]= tmp;
  10. isChanged =true;
  11. }
  12. }
  13. if(!isChanged)break;//本次没有发生交换，说明已经排好序了
  14. }
  15. }
2. 选择排序

时间复杂度：最好、平均和最坏情况O(n2)
空间复杂度：O(1)
不是稳定排序
原理：从第一个元素开始，每次逐一扫描选择未排序部分的最小值，排在已排序部分后面，然后从下一个位置开始，继续进行相同的操作，直到排序完成。
实现：

  1. /**
  2. * 选择排序
  3. */
  4. publicstaticvoid sort(int[] arr){
  5. //判断arr是否为空
  6. if(arr ==null)return;
  7. int minIndex;
  8. for(int i =0; i < arr.length -1; i++){
  9. minIndex = i;
  10. for(int j = i +1; j < arr.length; j++){
  11. if(arr[j]< arr[minIndex]){
  12. minIndex = j;
  13. }
  14. }
  15. if(minIndex != i){//最小值不是当前值，需要交换
  16. int tmp = arr[i];
  17. arr[i]= arr[minIndex];
  18. arr[minIndex]= tmp;
  19. }
  20. }
  21. }
3. 快速排序

时间复杂度：最好、平均情况O(nlogn)，最坏情况O(n2)
空间复杂度：平均情况O(logn)，最坏情况O(n)
不是稳定排序
原理：每次选择一个数，将数组按照这个数分成左右两个部分，右边的比它大，左边的比他小然后对左右两部分分别进行同样的操作，直到数组排序完成
实现：

  1. publicstaticvoid sort(int[] arr){
  2. sortCore(arr,0, arr.length -1);
  3. }
  5. /**
  6. * @param arr 排序的数组
  7. * @param start 开始位置
  8. * @param end 结束位置
  9. */
  10. privatestaticvoid sortCore(int[] arr,int start,intend){
  12. int poiv = partion(arr, start,end);
  13. if(poiv > start){
  14. sortCore(arr, start, poiv -1);
  15. }
  16. if(poiv >= start && poiv <end){
  17. sortCore(arr, poiv +1,end);
  18. }
  20. }
  22. privatestaticint partion(int[] arr,int start,intend){
  24. int tmp = arr[start];
  26. while(start <end){
  27. while(start <end&& arr[end]>= tmp)end--;
  29. if(start <end){
  30. arr[start]= arr[end];
  31. }
  33. while(start <end&& arr[start]< tmp) start++;
  35. if(start <end){
  36. arr[end]= arr[start];
  37. }
  38. }
  40. arr[start]= tmp;
  42. return start;
  43. }
4. 归并排序

时间复杂度：最好、平均和最坏情况O(nlogn)
空间复杂度：O(n)
稳定排序
原理：首选将要排序的数组对半分，对各自部分进行排序。每部分继续进行相同的操作，直至最底层。然后合并两个相邻的部分，直到所有元素都排序完成
实现：

  1. publicstaticvoid sort(int[] arr){
  2. //创建数组，辅助排序
  3. int[] copy =newint[arr.length];
  4. sortCore(arr, copy,0, arr.length -1);
  5. }
  7. /**
  8. * 归并排序核心实现
  9. * @param arr 排序的数组
  10. * @param copy 辅助空间
  11. * @param start 开始位置
  12. * @param end 结束位置
  13. * @param offset 索引相对于原数组的偏移
  14. */
  15. privatestaticvoid sortCore(int[] arr,int[] copy,int start,intend){
  16. if(start ==end){
  17. copy[start]= arr[start];
  18. return;}
  20. int mid =(end- start)/2+ start;
  22. //分成两部分，递归
  23. sortCore(arr, copy, start, mid);
  24. sortCore(arr, copy, mid +1,end);
  26. //合并两个部分，将合并结果存入
  27. int forward = mid;
  28. int behand =end;
  30. intlast=end;
  32. while(forward >= start && behand > mid){
  33. if(copy[forward]> copy[behand]){
  34. arr[last--]= copy[forward --];
  35. }else{
  36. arr[last--]= copy[behand --];
  37. }
  38. }
  40. while(forward >= start){
  41. arr[last--]= copy[forward --];
  42. }
  44. while(behand > mid){
  45. arr[last--]= copy[behand --];
  46. }
  48. //拷贝到copy数组
  49. for(int i = start; i <=end; i++){
  50. copy[i]= arr[i];
  51. }
  53. }
5. 插入排序

时间复杂度：最好O(n)，平均和最外情况O(n2)
空间复杂度：O(1)
稳定排序
原理：从数组第一个元素开始，依次比较前面已经排序的部分，插入合适的位置，前面排序部分比当前值大的部分向后移动一个。
实现：

  1. publicstaticvoid sort(int[] arr){
  2. int tmp;//每次排序，存储当前的值
  3. for(int i =1; i < arr.length; i++){
  4. tmp = arr[i];//保存当前值
  5. int j;
  6. for(j = i; j >= fromIndex && tmp < arr[j -1]; j --){//遇到比当前值大的元素，则元素后移一位
  7. arr[j]= arr[j-1];
  8. }
  9. arr[j]= tmp;|
  10. }
  11. }
6. 希尔排序

时间复杂度：平均情况O(n1.25)
空间复杂度：O(1)
不是稳定排序
原理：将无序数组分割为若干个子序列，子序列不是逐段分割的，而是相隔特定的增量的子序列，对各个子序列进行插入排序；然后再选择一个更小的增量，再将数组分割为多个子序列进行排序……最后选择增量为1，即使用直接插入排序，使最终数组成为有序。
实现：

  1. publicstaticvoid sort(int[] arr){
  2. //checkRange(arr.length, fromIndex, toIndex);
  3. int adder = arr.length /2;//增量
  4. while(adder >0){
  5. //从adder开始，每次排序均与前面的adder(当adder是1时就是插入排序)处的元素比较
  6. for(int i = adder ; i < arr.length; i++){
  7. int j;
  8. int tmp = arr[i];
  9. for(j = i; j >= adder && tmp < arr[j - adder]; j = j - adder){
  10. arr[j]= arr[j - adder];
  11. }
  12. arr[j]= tmp;
  13. }
  14. adder /=2;
  15. }
  16. }
7. 堆排序

时间复杂度：最好、平均和最坏情况均为O(nlogn)
空间复杂度：O(1)
不是稳定排序
原理：建立初始堆，从最后一个非叶结点开始，往前遍历，判断以该节点的开始的堆是否是符合，不符合则调整需要建立大顶堆，每次将子节点中较大地一个数往上移动，直到叶结点(堆：结点n的父节点为(n-1)/ 2，其左右子节点为2n+1和2n+2大根堆为根结点的值大于等于左右子结点的值)，然后依次将堆顶值与为排序的最后一个值交换，然后调整前面的值为大顶堆，每次将最大的值排好序。
实现：

  1. /**
  2. * 堆排序
  3. */
  4. publicstaticvoid sort(int[] arr){
  5. //建立初始堆，从最后一个非叶结点开始，往前遍历，判断以该节点的开始的堆是否是符合，不符合则调整
  6. //需要建立大顶堆，每次将子节点中较大地一个数往上移动，直到叶结点
  7. //节点n的父节点为(n-1)/ 2，其左右子节点为2*n+1和2*n+2
  8. //大根堆为根结点的值大于等于左右子结点的值
  9. for(int i =(arr.length -1-1)/2; i >=0; i--){
  10. adjustHeap(arr, i, arr.length-1);
  11. }
  12. //依次将堆顶值与为排序的最后一个值交换，然后调整前面的值为大顶堆
  13. for(int i = arr.length -1; i >=1; i--){
  14. //交换
  15. arr[0]^= arr[i];
  16. arr[i]^= arr[0];
  17. arr[0]^= arr[i];
  18. //调整
  19. adjustHeap(arr,0, i -1);
  20. }
  22. }
  24. /**
  25. * 调整为大顶堆
  26. * @param arr
  27. * @param i 以i为堆的堆顶
  28. * @param last 堆顶的最后一个结点的索引
  29. */
  30. privatestaticvoid adjustHeap(int[] arr,int i,intlast){
  31. //建立以i结点为根的堆，判断子结点是否大于该节点，并将较大地值拷贝，然后继续判断
  32. int tmp = arr[i];
  33. for(int j = i *2; j <=last; j *=2){
  34. //获得左右子树中较大的一个数的下标
  35. if(j <last&& arr[j]< arr[j+1]) j++;//存在右子结点且右子结点较大
  36. if(tmp >= arr[j])break;//根结点比较大，则完成
  37. //将较大的值作为根
  38. arr[i]= arr[j];
  39. i = j;//继续往下判断，j的位置的值是最初的根结点
  40. }
  41. arr[i]= tmp;//最后确定的位置，没有子结点或者比子结点的值大；
  42. }





posted @ 2016-07-25 14:03  峰扬迪  阅读(185)  评论(0)    收藏  举报