排序算法

 

直接插入排序

void insertionSort(AnyType[] a)

{

　　int j;

　　for(int i = 0; i<a.length; i++) {

　　　　AnyType tmp = a[p];

　　　　for(j=p; j>0 && tmp.compareTo(a[j-1]) < 0; j--) {

　　　　　　a[j] = a[j-1];

　　　　a[j] = tmp;

　　}

}

　　

shell排序

void shellSort(AnyType[] a) {
　　int j;
　　for(int gap = a.length/2; gap > 0; gap /= 2) {
　　　　for(int i = gap; i < a.length; i++) {
　　　　AnyType tmp = a[i];
　　　　for(j = i; j>=gap && tmp.compareTo(a[j-gap]) < 0; j-=gap) {
　　　　　　a[j] = a[j-gap];
　　　　　　}
　　　　a[j] = tmp;
　　　　}
　　}
}

　　

直接选择排序

void directSort(AnyType[] a) {

　　for(int i = 0; i < a,length-1; i++) {

　　　　int min = a[i];

　　　　int k = i;

　　　　for(int j = i+1; j < a.length; j++) {

　　　　　　if(a[j] < min) {

　　　　　　　　min = a[j]

　　　　　　　　k = j;

　　　　　　}

　　　　}

　　　　a[k] = a[i];

　　　　a[i] = min;

　　}

}

　　

堆排序

private static int leftChild(int i) {
　　return 2 * i + 1;
}
void percDown(AnyType[] a, int i, int n) {
　　int child;
　　AnyType tmp;
　　for(tem = a[i]; leftChild(i) < n; i=child) {
　　　　child = leftChild(i);
　　　　if( child != n-1 && a[child].compareTo(a[child]) < 0) {
　　　　　　child++;
　　　　}
　　　　if( tmp.compareTo( a[child]) < 0) {
　　　　　　a[i] = a[child];
　　　　}
　　　　else {
　　　　　　break;
　　　　}
　　}
　　a[i] = tmp;
}
void heapSort(AnyType[] a) {
　　for(int i = a.length/2; i >= 0; i--) {
　　　　percDown(a, i, a.length);
　　}
　　for(int i=a.length-1; i>0; i--) {
　　　　swapReferences(a, 0, i);
　　　　percDown(a, 0, i);
　　}
}

　　

冒泡排序

void bubbleSort(AnyType[] a) {
　　boolean judge = true;
　　while(judge) {
　　　　judge = false;
　　　　for(int i=0; i<a.length-1; i++) {
　　　　　　if(a[i] > a[i+1]) {
　　　　　　int tmp = a[i];
　　　　　　a[i] = a[i+1];
　　　　　　a[i+1] = tmp;
　　　　　　judge = true;
　　　　　　}
　　　　　　continue;
　　　　}
　　}
}

　　

快速排序

static void quicksort(int n[], int left, int right) {

        int dp;
        if (left < right) {
            dp = partition(n, left, right);
            quicksort(n, left, dp - 1);
            quicksort(n, dp + 1, right);
        }
    }
 
    static int partition(int n[], int left, int right) {
        int pivot = n[left];
        while (left < right) {
            while (left < right && n[right] >= pivot)
                right--;
            if (left < right)
                n[left++] = n[right];
            while (left < right && n[left] <= pivot)
                left++;
            if (left < right)
                n[right--] = n[left];
        }
        n[left] = pivot;
        return left;
    }

　　

 归并排序

void mergeSort(AnyType[] a, AnyType[] tmpArray, int left, int right) {
	if(left < right) {
		int center = (left + right) / 2;
		mergeSort(a, tmpArray, left, center);
		mergeSort(a, tmpArray, center+1, right);
		merge(a, tmpArray, left, center + 1, right);
	}
}

void mergeSort(AnyType[] a) {
	AnyType[] tmpArray = (AnyType[]) new Comparable[a.length];
	mergeSort(a, tmpArraym, 0, a.length-1);
}

void merge(AnyType[] a, AnyType[] tmpArray, int leftPos, int rightPos, int rightEnd) {
	int leftEnd = rightPos - 1;
	int tmpPos = leftPos;
	int numElements = rightEnd - leftPos + 1;

	while( leftPos <= leftEnd && rightPos <= rightEnd) {
		if(a[leftPos].compareTo(a[rightPos]) <= 0) {
			tmpArray[tmpPos] = a[leftPos++];
		}else {
			tmpArray[tmpPos++] = a[rightPos++];
		}
	}

	while(leftPos <= leftEnd) {
		tmpArray[tmpPos++] = a[leftPos];
	}
	while(rightPos <= rightEnd) {
		tmpArray[tmpPos++] = a[rightPos++];
	}

	for(int i=0; i < numElements; i++, rightEnd--) {
		a[rightEnd] = tmpArray[rightEnd];
	}
}

基数排序

public class RadixSort
{
    public static void sort(int[] number, int d) //d表示最大的数有多少位
    {
        intk = 0;
        intn = 1;
        intm = 1; //控制键值排序依据在哪一位
        int[][]temp = newint[10][number.length]; //数组的第一维表示可能的余数0-9
        int[]order = newint[10]; //数组orderp[i]用来表示该位是i的数的个数
        while(m <= d)
        {
            for(inti = 0; i < number.length; i++)
            {
                intlsd = ((number[i] / n) % 10);
                temp[lsd][order[lsd]] = number[i];
                order[lsd]++;
            }
            for(inti = 0; i < 10; i++)
            {
                if(order[i] != 0)
                    for(intj = 0; j < order[i]; j++)
                    {
                        number[k] = temp[i][j];
                        k++;
                    }
                order[i] = 0;
            }
            n *= 10;
            k = 0;
            m++;
        }
    }
    public static void main(String[] args)
    {
        int[]data =
        {73, 22, 93, 43, 55, 14, 28, 65, 39, 81, 33, 100};
        RadixSort.sort(data, 3);
        for(inti = 0; i < data.length; i++)
        {
            System.out.print(data[i] + "");
        }
    }
}

　　

　　

　　

　　

 

转载于:https://www.cnblogs.com/zbPlayer/p/5641568.html