package com.hqy.test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Sort {
private int[] array;
private int currentsize;
public Sort(int max){
array=new int[max];
currentsize=0;
}
public void increatment(){
currentsize++;
}
/**
* @Description: 1.冒泡排序原理:它重复地走访过要排序的数列,一次进行相邻两个元素的比较,如果他们的顺序错误就把他们交换过来。
* 每一次排序都选出一个未排序序列中最大的元素。
*
*/
public void bubbelSort(){
int temp;
for(int out=array.length-1;out>0;out--){
for(int in=0;in<out;in++){
if(array[in]>array[in+1]){
temp=array[in];
array[in]=array[in+1];
array[in+1]=temp;
}
}
}
}
/**
* @Description: 2.插入排序:对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
* 步骤:
1、从第一个元素开始,该元素可以认为已经被排序
2、取出下一个元素,在已经排序的元素序列中从后向前扫描
3、如果该元素(已排序)大于新元素,将该元素移到下一位置
4、重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
5、将新元素插入到该位置中
6、重复步骤2
*/
public void insertSort(){
int temp,in,out;
for(out=1;out<array.length;out++){
temp=array[out];
in=out;
while(in>0&&array[in-1]>temp){
array[in]=array[in-1];
in-=1;
}
array[in]=temp;
}
}
/**
* @Description: 3.选择排序:首先在未排序序列中找到最小元素,存放到排序序列的起始位置,
* 然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。
*
*/
public void selectSort(){
int min,temp,in,out;
for(out=0;out<array.length;out++){
min=out;
for(in=out;in<array.length;in++){
if(array[in]<array[min]){
min=in;
}
}
temp=array[min];
array[min]=array[out];
array[out]=temp;
}
}
/**
* @Description: 4.快速排序:主要是找”枢纽“,运用递归进行排序
*
*/
public void quickSort(){
requickSort(0,array.length-1);
}
public void requickSort(int low,int high){
if(high-low<1){
return;
}
int povit=getPovit(low,high,array[high]);
requickSort(low, povit-1);
requickSort(povit+1, high);
}
private int getPovit(int low, int high, int povit) {
// TODO Auto-generated method stub
int lowptr=low-1;
int highptr=high;
int temp;
while(true){
while(array[++lowptr]<povit);
while(highptr>0&&array[--highptr]>povit);
if(lowptr>=highptr)break;
temp=array[lowptr];
array[lowptr]=array[highptr];
array[highptr]=temp;
}
temp=array[lowptr];
array[lowptr]=array[high];
array[high]=temp;
return lowptr;
}
/**
* @Description: 5.希尔排序:也称递减增量排序算法,是插入排序的一种高速而稳定的改进版本。
*
希尔排序是基于插入排序的以下两点性质而提出改进方法的:
1、插入排序在对几乎已经排好序的数据操作时, 效率高, 即可以达到线性排序的效率
2、但插入排序一般来说是低效的, 因为插入排序每次只能将数据移动一位
*
*/
public void shellSort(){
int in,out,h,temp;
h=1;
while(h<array.length/3){
h=3*h+1;
}
while(h>0){
for(out=h;out<array.length;out++){
in=out;
while(in>h-1&&array[in]<array[in-h]){
temp=array[in];
array[in]=array[in-h];
array[in-h]=temp;
in-=h;
}
}
h=(h-1)/3;
}
}
/**
* @Description: 6.归并排序:归并排序(Merge sort,也称:合并排序)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。
*
步骤:
1、申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
2、设定两个指针,最初位置分别为两个已经排序序列的起始位置
3、比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
4、重复步骤3直到某一指针达到序列尾
5、将另一序列剩下的所有元素直接复制到合并序列尾
*
*/
public void mergeSort(){
int a[]=new int[array.length];
remergeSort(a, 0,array.length-1);
}
private void remergeSort(int[] a, int left, int right) {
// TODO Auto-generated method stub
if(left==right){
return;
}
int mid=(left+right)/2;
remergeSort(a, left, mid);
remergeSort(a,mid+1,right);
merge(a,left,mid+1,right);
}
private void merge(int[] a, int left, int highptr, int right) {
// TODO Auto-generated method stub
int i=0;
int leftptr=left;
int mid=highptr-1;
int n=right-left+1;
while(leftptr<=mid && highptr<=right){
if(array[leftptr]<array[highptr]){
a[i++]=array[leftptr++];
}else{
a[i++]=array[highptr++];
}
}
while(leftptr<=mid){
a[i++]=array[leftptr++];
}
while(highptr<=right){
a[i++]=array[highptr++];
}
for(int k=0;k<n;k++){
array[left+k]=a[k];
}
}
/**
* @Description: 7.堆排序:堆积排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。
* 堆是一个近似完全二叉树的结构,并同时满足堆性质:即子结点的键值或索引总是小于(或者大于)它的父节点。
*
*/
public void heapSort(){
//建堆
for(int i=currentsize/2-1;i>=0;i--){
trickdown(i);
}
//排序
for(int k=array.length-1;k>=0;k--){
int temp=remove();
array[k]=temp;
}
}
public int remove(){
int temp=array[0];
array[0]=array[--currentsize];
trickdown(0);
return temp;
}
public void trickdown(int index){
int largeChild;
int temp=array[index];
while(index<currentsize/2){
int leftChild=index*2+1;
int rightChild=leftChild+1;
//注意if语句里rightChild的范围:即如果largeChild=rightChild;必须在if条件成立的语句块中,因为rightChild可能越界
if(rightChild<currentsize && array[leftChild]<array[rightChild]){
largeChild=rightChild;
}else{
largeChild=leftChild;
}
// System.out.println("smallChild:"+smallChild);
if(temp>=array[largeChild]){
break;
}
array[index]=array[largeChild];
index=largeChild;
}
array[index]=temp;
}
public void display(){
for(int i=0;i<array.length;i++){
System.out.print(array[i]+" ");
}
System.out.println();
}
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
int max=10;
Sort sort=new Sort(max);
System.out.println("冒泡排序:");
for(int i=0;i<10;i++){
sort.array[i]=(int)(java.lang.Math.random()*100);
}
sort.display();
sort.bubbelSort();
sort.display();
System.out.println("******************************");
System.out.println("插入排序:");
for(int i=0;i<max;i++){
sort.array[i]=(int)(java.lang.Math.random()*100);
}
sort.display();
sort.insertSort();
sort.display();
System.out.println("******************************");
System.out.println("选择排序:");
for(int i=0;i<max;i++){
sort.array[i]=(int)(java.lang.Math.random()*100);
}
sort.display();
sort.selectSort();
sort.display();
System.out.println("******************************");
System.out.println("快速排序:");
for(int i=0;i<max;i++){
sort.array[i]=(int)(java.lang.Math.random()*100);
}
sort.display();
sort.quickSort();
sort.display();
System.out.println("******************************");
Sort sort2=new Sort(12);
System.out.println("希尔排序:");
for(int i=0;i<12;i++){
sort2.array[i]=(int)(java.lang.Math.random()*100);
}
sort2.display();
sort2.shellSort();
sort2.display();
System.out.println("******************************");
Sort sort3=new Sort(10);
System.out.println("归并排序:");
for(int i=0;i<10;i++){
sort3.array[i]=(int)(java.lang.Math.random()*100);
}
sort3.display();
sort3.mergeSort();
sort3.display();
System.out.println("******************************");
Sort sort4=new Sort(10);
System.out.println("堆排序:");
for(int i=0;i<10;i++){
sort4.array[i]=(int)(java.lang.Math.random()*100);
sort4.increatment();
}
sort4.display();
sort4.heapSort();
sort4.display();
System.out.println("******************************");
}
public static String getString() throws IOException{
InputStreamReader inputStreamReader=new InputStreamReader(System.in);
BufferedReader bfBufferedReader=new BufferedReader(inputStreamReader);
String string=bfBufferedReader.readLine();
return string;
}
public static int getInt() throws IOException{
String string=getString();
return Integer.parseInt(string);
}
}
java排序总结 笔记
最新推荐文章于 2021-07-31 17:04:51 发布