Java排序法
快速排序法:
public class MyQuickSort {
public int[] theArray;
public int nElem;
public MyQuickSort(int max){
theArray = new int[max];
nElem = 0;
}
public void insert(int value){
theArray[nElem] = value;
nElem++;
}
public void display(){
for (int i = 0; i < nElem; i++) {
System.out.print(theArray[i]+" ");
}
System.out.println(" ");
}
public void quickSort(){
reQuickSort(0,nElem-1);
}
public void reQuickSort(int left,int right){
if(right - left < 0){
return;
}
int pivot = (left + right)/2;
int partition = partitionIt(left,right,pivot);
reQuickSort(left, partition-1);
reQuickSort(partition+1, right);
}
/**
* @param leftPtr 左边起始下标
* @param rightPtr 右边起始下标
* @param pivot 中间数的下标
* @return 中间数的下标
*/
public int partitionIt(int leftPtr,int rightPtr,int pivot){
int temp = theArray[pivot]; //得到中间数
theArray[pivot] = theArray[rightPtr]; //将最右边的数赋值给 中间变量
while (leftPtr!=rightPtr) {
//用最左边的数与中间数比较,若theArray[leftPtr] < temp, 则使leftPtr 递增,继续循环
//直到 theArray[leftPtr] < temp 不满足条件为止,则退出循环
while (leftPtr < rightPtr && theArray[leftPtr] < temp) {
leftPtr++;
}
if(leftPtr < rightPtr){ //若左边数的下标 小于 右边数的下标
theArray[rightPtr] = theArray[leftPtr]; //将 以leftPtr 为下标的值赋给 以rightPtr 为下标的值
rightPtr--; // rightPtr递减
}
//用递减后的 以rightPtr为下标的值 与temp 比较,若 theArray[rightPtr] > temp 则是rightPtr的值递减,继续循环
//直到 theArray[rightPtr] > temp 不满足条件为止,退出循环
while (leftPtr < rightPtr && theArray[rightPtr] > temp) {
rightPtr--;
}
if (leftPtr < rightPtr) {
theArray[leftPtr] = theArray[rightPtr]; //将 以rightPtr 为下表的值赋给 以leftPtr 为下表的值
leftPtr++; // leftPtr递增
}
}
theArray[leftPtr] = temp;
return leftPtr;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyQuickSort myQuickSort; //= new MyQuickSort(5);
int maxSize = 15;
myQuickSort = new MyQuickSort(maxSize);
// myQuickSort.insert(1);
// myQuickSort.insert(5);
// myQuickSort.insert(4);
// myQuickSort.insert(3);
// myQuickSort.insert(6);
for (int i = 0; i < maxSize; i++) {
int n = (int)(Math.random()*99);
myQuickSort.insert(n);
}
myQuickSort.display();
myQuickSort.quickSort();
myQuickSort.display();
}
}
希尔排序法:
package com.test;
/**
* @author Tiankj
* 希尔排序法
* 希尔排序法的原理:数据项移动的个数虽少,可是移动的距离很大,这样可以提高排序的效率。
* H 越大,移动的数据项越少,H 越小,移动的数据项越多;
* H减小的时候移动的数据项增多,但此时数据项已接近他们排序后最终的位置,这对于插入排序更有效。
*/
public class ShellSort {
private int[] theArry;
private int nElems;
public ShellSort(int max){
theArry = new int[max];
nElems = 0;
}
public void insert(int value){
theArry[nElems] = value;
nElems++;
}
public void display(){
System.out.print("A=");
for (int i = 0; i < nElems; i++) {
System.out.print(theArry[i]+" ");
}
System.out.println("");
}
public void shellSort(){
int inner,outer;
int temp;
int h = 1;
while(h<nElems/3){
h = h*3+1;
}
while(h>0){
for (outer = h; outer < nElems; outer++) {
temp = theArry[outer];
inner = outer;
while (inner>h-1 && theArry[inner-h]>=temp) {
theArry[inner] = theArry[inner-h]; //将相差 h 项的数据调换位置
inner -= h; //inner = inner - h
}
theArry[inner] = temp; //将 以 outer 为下标的数据项 与 以相差 h 的数据调换位置
}
h = (h-1)/3;
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int size = 10;
ShellSort shell;
shell = new ShellSort(size);
for(int i = 0; i < size; i++ ){
int n = (int)(Math.random()*99);
shell.insert(n);
}
shell.display();
shell.shellSort();
shell.display();
}
}
选择排序法:
package com.test;
/*
* 选择排序法
*
**/
public class SelectionSort {
/*
* 选择排序的基本思想是每次从待排数据中选择第n小的数据放到排序列表的第n个位置,假如共有N个数据待排,那么经过N-1次排序后,待排数据就已经按照从小到大的顺序排列了。
直接选择排序算法的思想比较简单:(假设数据放在一个数组a中,且数组的长度是N)
1:从a[0]-a[N-1]中选出最小的数据,然后与a[0]交换位置
2:从a[1]-a[N-1]中选出最小的数据,然后与a[1]交换位置(第1步结束后a[0]就是N个数的最小值)
3:从a[2]-a[N-1]中选出最小的数据,然后与a[2]交换位置(第2步结束后a[1]就是N-1个数的最小值)
以此类推,N-1次排序后,待排数据就已经按照从小到大的顺序排列了。
*
* */
public static int[] a={140,1,15,5,17,23,20,98,45,110,120,100};
public static void main(String[] args) {
for(int i= 0; i <= a.length-1; i++){
int min = i; //给min依次赋值为0,1,2,...,10
//进行了N-1次比较,但是只进行了一次交换
for(int j = i; j <= a.length-1; j++){ //j=0
if(a[min] > a[j]){ //比较出最小的 j=1 若a[0]>a[1]
min = j; //则a[0]=a[1],即将较小者放在数组的首位
}
}
if(min != i){//交换元素
int temp = a[i];
a[i] = a[min];
a[min] = temp;
}
}
for (int k = 0; k < a.length; k++) {
System.out.println(a[k]);
}
}
}
归并排序法:
package com.test;
public class DArray {
public int[] theArray;
public int nElems;
public DArray(int max){
theArray = new int[max];
nElems = 0;
}
public void insert(int value){
theArray[nElems] = value;
nElems++;
}
public void mergeSort(){
int[] workSpace = new int[nElems];
recMergeSort(workSpace, 0, nElems-1);
}
public void recMergeSort(int[] workSpace,int begin,int end){
if(begin == end){
return;
}else{
int mid = (begin+end)/2;
recMergeSort(workSpace, begin, mid);
recMergeSort(workSpace, mid+1, end);
merge(workSpace, begin,mid+1, end);
}
}
/**
* @author Administrator
* @param workSpace 空数组
* @param lowPtr 数组开始的下标
* @param highPtr 数组(begin+end)/2+1 的下标
* @param upper 数组结束的下标
*/
public void merge(int[] workSpace,int lowPtr,int highPtr,int upper){
int j = 0;
int lower = lowPtr; //开始下标,每次递归都在增加
int mid = highPtr - 1; //中间下标
int n = upper-lower+1;
while(lowPtr <= mid && highPtr <= upper){
if(theArray[lowPtr] < theArray[highPtr]){ //将两个数组的第一个进行比较
workSpace[j++] = theArray[lowPtr++];
}else {
workSpace[j++] = theArray[highPtr++];
}
}
while (lowPtr <= mid) { //把lowPtr 到 mid 部分剩余的往workSpace里面复制
workSpace[j++] = theArray[lowPtr++];
}
while (highPtr <= upper) { //把highPtr 到 upper 部分剩余的往workSpace里面复制
workSpace[j++] = theArray[highPtr++];
}
for (j = 0; j < n; j++) { //每次递归,都将两个数组合并成一个
theArray[lower+j] = workSpace[j];
System.out.println(workSpace[j]+" "+"j="+j+" n="+n);
}
}
public void display(){
for (int i = 0; i < nElems; i++) {
System.out.print(theArray[i]+" ");
}
}
public static void main(String[] args) {
int maxSize = 8;
DArray array;
array = new DArray(maxSize);
array.insert(3);
array.insert(1);
array.insert(7);
array.insert(5);
array.insert(4);
array.insert(3);
array.display();
array.mergeSort();
array.display();
}
}