码迷,mamicode.com
首页 > 编程语言 > 详细

选择,冒泡,插入,归并,快速排序(java实现)

时间:2016-04-25 06:26:19      阅读:180      评论:0      收藏:0      [点我收藏+]

标签:

首先从简单的开始。(结果从小到大),其中快速排序和选择排序是不稳定的。

1.选择排序

 选择排序的优点主要是交换的次数较少,最坏情况下的时间复杂度为O(n2),最好情况下也是O(n2)

public static void sort(int[] num){
    for(int i = 0;i < num.length;i++){
        int k = 0;
        for(int j = i + 1;j < num.length;j++){
            if(num[k] > num[j]){
               int temp = k;
               k = j;
               j = temp;
            }
        }
        if( k != i){
            int temp = num[k];
            num[k] = num[i];
            num[i] = temp;
          }
    }       
       
}                                  

 

2.冒泡排序


冒泡排序在最坏的情况下算法复杂度为O(n2),最好的情况下为O(n)

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

            }

            if (swap == 0) {
                break;
            }
        }

    }

 

 

3.插入排序

插入排序在基本有序的情况下比较快,最坏情况下的时间复杂度为O(n2),最好的情况下为O(n)

public static void sort(int[] nums) {
        int length = nums.length;

        for (int i = 1; i < length; i++) {
            for (int j = i; j > 0 && nums[j] < nums[j - 1]; j--) {
                int temp = nums[j];
                nums[j] = nums[j - 1];
                nums[j - 1] = temp;
            }
        }
    }

 

4.归并排序

归并排序稍微有了难度,时间复杂度为O(nlogn)

public static void sort(int[] nums, int low, int high) {
        int mid = low + (high - low) / 2;
        if (low < high) {
            sort(nums, low, mid);
            sort(nums, mid + 1, high);
            merge(nums, low, mid, high);
        }
    }

    public static void merge(int[] nums, int low, int mid, int high) {
        int[] temps = new int[high - low + 1];
        int i = low;
        int j = mid + 1;
        int k = 0;

        while (i <= mid && j <= high) {
            if (nums[i] < nums[j]) {
                temps[k++] = nums[i++];
            } else {
                temps[k++] = nums[j++];
            }
        }

        while (i <= mid) {
            temps[k++] = nums[i++];
        }

        while (j <= high) {
            temps[k++] = nums[j++];
        }

        for (int k2 = 0; k2 < temps.length; k2++) {
            nums[low + k2] = temps[k2];
        }
    }

 

5.快速排序

快速排序的时间复杂度为O(nlogn)

 

public static void sort(int[] nums, int low, int high) {
        if (low < high) {
            int position = partition(nums, low, high);
            sort(nums, low, position);
            sort(nums, position + 1, high);
        }
    }

    public static int partition(int[] nums, int low, int high) {
        int i = low, j = high;
        int x = nums[low];

        while (i < j) {
            while (i < j && nums[j] >= x) {
                j--;
            }

            if (i < j) {
                nums[i] = nums[j];
                i++;
            }

            while (i < j && nums[i] < x) {
                i++;
            }

            if (i < j) {
                nums[j] = nums[i];
                j--;
            }
        }

        nums[i] = x;
        return i;
    }

 

选择,冒泡,插入,归并,快速排序(java实现)

标签:

原文地址:http://www.cnblogs.com/lizhenwei0219/p/5429084.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!