一些常用的排序法

本文就是介绍一些常见的排序算法。排序是一个非常常见的应用场景，很多时候，我们需要根据自己需要排序的数据类型，来自定义排序算法，但是排序有很多种，如：插入排序、选择排序、冒泡排序、快速排序（重点）、堆排序、归并排序等等，我们只介绍一些常用的基础排序算法，包括：插入排序、选择排序、冒泡排序、快速排序。

一、直接插入排序

原理：从待排序的数中选出一个来，插入到前面的合适位置。

public class InsertSort { 

static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 }; 

public static void insertSort() { 
int tmp, j = 0; 
for (int k = 0; k < data.length; k++) {//-----1----- 
tmp = data[k]; 
j = k - 1; 
while (j >= 0 && tmp < data[j]) {//-----2----- 
data[j + 1] = data[j]; 
j--; 
} 
data[j + 1] = tmp;//------3------- 
} 
} 

public static void main(String[] args) { 
print(); 
System.out.println(); 
insertSort(); 
System.out.println(); 
print(); 
} 

static void print() { 
for (int i = 0; i < data.length; i++) { 
System.out.print(data[i] + " "); 
} 
} 

} 

 

二、选择排序
与直接插入排序正好相反，选择排序是从待排序的数中选出最小的放在已经排好的后面，这个算法选数耗时。

public class SelectSort {

	static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };

	public static void selectSort() {
		int i, j, k, tmp = 0;
		for (i = 0; i < data.length - 1; i++) {
			k = i;
			for (j = i + 1; j < data.length; j++)
				if (data[j] < data[k])
					k = j;
			if (k != i) {
				tmp = data[i];
				data[i] = data[k];
				data[k] = tmp;
			}
		}
	}
	public static void main(String[] args) {
		print();
		System.out.println();
		selectSort();
		System.out.println();
		print();
	}

	static void print() {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + " ");
		}
	}

}

三、快速排序

快速排序简称快排，是一种比较快的排序，适合基本无序的数据。下面我说下快排的思路：

设置两个指针：i和j，分别指向第一个和最后一个，i像后移动，j向前移动，选第一个数为标准（一般这样做，当然快排的关键就是这个“标准”的选取），从后面开始，找到第一个比标准小的数，互换位置，然后再从前面，找到第一个比标准大的数，互换位置，第一趟的结果就是标准左边的都小于标准，右边的都大于标准（但不一定有序），分成两拨后，继续递归的使用上述方法，最终有序！代码如下：

 

package com.xtfggef.algo.sort;

public class QuickSortTest {

	static class QuickSort {

		public int data[];

		private int partition(int array[], int low, int high) {
			int key = array[low];
			while (low < high) {
				while (low < high && array[high] >= key)
					high--;
				array[low] = array[high];
				while (low < high && array[low] <= key)
					low++;
				array[high] = array[low];
			}
			array[low] = key;
			return low;
		}

		public int[] sort(int low, int high) {
			if (low < high) {
				int result = partition(data, low, high);
				sort(low, result - 1);
				sort(result + 1, high);
			}
			return data;
		}
	}

	static void print(int data[]) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + " ");
		}
	}

	public static void main(String[] args) {
		int data[] = { 20, 3, 10, 9, 186, 99, 200, 96, 3000 };
		print(data);
		System.out.println();
		QuickSort qs = new QuickSort();
		qs.data = data;
		qs.sort(0, data.length - 1);
		print(data);
	}
}

四、冒泡排序

冒泡排序是一种很简单，不论是理解还是时间起来都比较容易的一种排序算法，思路简单：小的数一点一点向前起泡，最终有序。

public class BubbleSort {  
  
    static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };  
  
    public static void bubbleSort() {  
        int i, j, tmp = 0;  
        for (i = 0; i < data.length - 1; i++) {  
            for (j = data.length - 1; j > i; j--) {  
                if (data[j] < data[j - 1]) {  
                    tmp = data[j];  
                    data[j] = data[j - 1];  
                    data[j - 1] = tmp;  
                }  
            }  
        }  
    }  
  
    public static void main(String[] args) {  
        print();  
        System.out.println();  
        bubbleSort();  
        System.out.println();  
        print();  
    }  
  
    static void print() {  
        for (int i = 0; i < data.length; i++) {  
            System.out.print(data[i] + " ");  
        }  
    }  
  
}