java 数据结构 常见的排序算法

/*所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。*/

package cn.hncu.sort;

public class sortMethods {

public static void main(String[] args) {

int[] number={ 21, 25, 49, 25, 16, 8 ,-101,3,50,-5};

// bubble(number);//冒泡算法:

// bubble2(number);//冒泡算法：算法最佳

// select(number);//选择排序

// insert(number);//插入排序

// myInsert(number);复杂的插入排序

//insert2(number);

//shell(number);

// quickSort(number, 0, number.length-1);

mergeSort(number, 0, number.length-1);

print(number);

}

//输出

private static void print(int[] number) {

for(int x:number){

System.out.print(x+"\t");

}

}

//交换

private static void temp(int[] number, int i, int j) {

// number[i]=number[i]+number[j];//利用加法进行交换，仅限于基本数据类型

// number[j]=number[i]-number[j];

// number[i]=number[i]-number[j];

int temp=number[i];//利用第三个变量

number[i]=number[j];

number[j]=temp;

// number[i]^=number[j];//异或,整形

// number[j]^=number[i];

// number[i]^=number[j];

}

//冒泡排序:普通 T(n)=O(n²) S(n)=O(1)

private static void bubble(int[] number) {

for(int i=0;i<number.length-1;i++){

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

if(number[i]>number[j]){

temp(number,i,j);

}

}

}

}

//冒泡排序:算法最佳

private static void bubble2(int[] number) {

for(int i=0;i<number.length-1;i++){

boolean flag=true;

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

if(number[i]>number[j]){

temp(number,i,j);

flag=false;

}

}

if(flag){

return;

}

}

}

//选择排序 T(n)=O(n²) S(n)=O(1)

private static void select(int[] number) {

for(int i=0;i<number.length-1;i++){

int k=i;//注意

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

if(number[k]>number[j]){

k=j;

}

}

if(k!=i){

temp(number, i, k);

}

}

}

//直接插入排序 :直接插入排序是一种稳定的排序方法

//直接插入排序最大的优点是简单，在记录数较少时，是比较好的办法。

private static void insert(int[] number) {//插入排序:不太理解，但是简便

for(int i=0;i<number.length-1;i++){

int temp=number[i+1];

int j=i;

while(number[j]>temp){

number[j+1]=number[j];

if(--j<0){

break;

}

}

number[j+1]=temp;

}

}

//我喜欢用的插入排序算法：但是不简便,而且不好，负载太多交换了很多次多

private static void myInsert(int[] number) {

for(int i=0;i<number.length-1;i++){

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

if(number[i+1]<number[j]){

temp(number, i+1, j);

}

}

}

}

//二分插入排序 ：

//二分查找：找到中间元素，如果中间元素比当前元素大，

//则当前元素要插入到中间元素的左侧；否则，中间元素比当前元素小，则当前元素要插入到中间元素的右侧。

//二分查找优化的插入排序

private static void insert2(int[] number){

for(int i=0;i<number.length-1;i++)
{

int temp=number[i+1];

int low=0;

int high=i;

int mid;

while(low<=high){

mid=(low+high)/2;

if(number[mid]>temp){

high=mid-1;

}else{

low=mid+1;

}

}

//经过上面的二分查找，得到新元素的位置是：high+1

//把[high+1,i]区间内的所有元素往后移一个位置

for(int j=i;j>high;j--){

number[j+1]=number[j];

}

number[high+1]=temp;

}

}

//希尔排序 ：分组后n值减小，n²更小，而T(n)=O(n²),所以T(n)从总体上看是减小了。

private static void shell(int[] number){

for(int gap=number.length/2;gap>0;){//每次减少gap/2

for(int i=0;i<number.length-gap;i++){//number.length-gap次

for(int j=i;j<number.length-gap;j+=gap){//number.length-gap次换

if(number[j]>number[j+1]){

temp(number, j, j+1);

}

}

}

//for循环的修改代码有点复杂，直接写在for()里面不方便，因此单独拿出来放在这里

if(gap>1){

gap=(gap+1)/2;//防止基数

}else if(gap==1){

break;

}

}

}

//快速排序 最好情况（每次总是选到中间值作枢轴）T(n)=O(nlogn)

//最坏情况（每次总是选到最小或最大元素作枢轴）T(n)=O(n²)

private static void quickSort(int[] number,int p,int r){

if(p<r){

int q=partition(number,p,r);//划分为两部分 a[p:r] ==> a[p:q-1], a[q], a[q+1:r]

quickSort(number, p, q-1);

quickSort(number, q+1, r);

}

}

private static int partition(int[] number, int p, int r) {

int i=p;

int j=r+1;

int x=number[p];//第1个元素为枢轴

while(true){

//在左侧定位到比枢轴大的数

//在右侧定位到比枢轴小的数

while(number[++i]<x&&i<r);

while(number[--j]>x);//这里不要防范，因为一定有一个数等于x

if(i>=j){

break;

}

temp(number, i, j);

}

temp(number, p,j);

return j;

}

//归并排序 T(n)=O(nlogn) S(n)=O(n)

private static void mergeSort(int[] number,int left,int right){

if(left<right){

//1先分解

//把整个数组分解成：[left,mid] 和 [mid+right]

int mid=(left+right)/2;

mergeSort(number, left, mid);

mergeSort(number, mid+1, right);

int[] b=new int[number.length];

merge(number,b,left,mid,right);

copyArray(number,b,left,right);

}

}

private static void copyArray(int[] number, int[] b, int left, int right) {

for(int i=left;i<=right;i++){

number[i]=b[i];

}

}

private static void merge(int[] number, int[] b, int left, int mid, int right) {//注意等于号

int p=left;

int r=mid+1;

int i=left;//游标，遍历合并后结果数组。指定当前判断之后所选中的元素应该放在哪个位置

while(p<=mid&&r<=right){

if(number[p]>number[r]){

b[i++]=number[r++];

}else{

b[i++]=number[p++];

}

}

if(p>mid){

for( int j=r;j<=right;j++){

b[i++]=number[j];

}

}else{

for (int j = p; j <=mid; j++) {

b[i++] = number[j];

}

}

}

}