java数组排列_Java数组排序

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

/**

* DELL

* 2021/1/18

* 10:44

*/

public class Sort {

public static void main(String[] args) {

int[] arr= {10,55,28,65,1,3,7,5,6,22};

//选择排序

System.out.print(Arrays.toString(selectionSoft(arr)));

//冒泡排序

System.out.print(Arrays.toString(bubble(arr)));

//快速排序

System.out.print(Arrays.toString(quick(arr)));

//直接插入

System.out.print(Arrays.toString(drirectInsertSort(arr)));

//二分法插入

System.out.print(Arrays.toString(tDivSort(arr)));

//希尔排序

System.out.print(Arrays.toString(shellSort(arr)));

//堆排序

System.out.print(Arrays.toString(heapSort(arr)));

//归并排序

System.out.print(Arrays.toString(mergeSort(arr)));

//基数排序

System.out.print(Arrays.toString(radixSort(arr)));

}

/*

* 简单选择排序

*选择排序原理：

* 将数组中每个元素与第一个元素比较，如果这个元素小于第一个元素，

* 则交换这两个元素循环第 1 条规则，找出最小元素，放于第 1 个位置经过 n-1 轮比较完成排序

* */

public static int[] selectionSoft(int[] initArr){

// i表示第一个比较位置，j表示第一个比较位置后面的所有位置

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

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

if(initArr[j] < initArr[i]){

// 交换基本思想 a = a + b;

// b = a - b;

// a = a - b;

// initArr[j] = initArr[j] + initArr[i];

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

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

int temp = initArr[j];

initArr[j] = initArr[i];

initArr[i] = temp;

}

}

}

return initArr;

}

/*

* 冒泡排序

* 冒泡排序原理：

* 比较相邻的元素，将小的放到前面。

* */

public static int[] bubble(int[] initArr){

// i表示比较次数，j表示比较位置

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

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

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

int temp = initArr[j];

initArr[j] = initArr[i];

initArr[i] = temp;

}

}

}

return initArr;

}

/*

*快速排序

* 基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,

* 一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

* */

private static int[] quick(int[] a) {

if(a.length>0){

quickSort(a,0,a.length-1);

}

return a;

}

private static void quickSort(int[] a, int low, int high) {

if(low

int middle = getMiddle(a,low,high);

quickSort(a, 0, middle-1);

quickSort(a, middle+1, high);

}

}

private static int getMiddle(int[] a, int low, int high) {

int temp = a[low];//基准元素

while(low

//找到比基准元素小的元素位置

while(low=temp){

high--;

}

a[low] = a[high];

while(low

low++;

}

a[high] = a[low];

}

a[low] = temp;

return low;

}

/*

* 直接插入排序

* 基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置

* (从后向前找到合适位置后)，直到全部插入排序完为止。

* */

public static int[] drirectInsertSort (int[] arr){

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

//待插入元素

int temp = arr[i];

int j;

for (j = i-1; j>=0; j--) {

//将大于temp的往后移动一位

if(arr[j]>temp){

arr[j+1] = arr[j];

}else{

break;

}

}

arr[j+1] = temp;

}

return arr;

}

/*

*二分法插入排序

* 基本思想：二分法插入排序的思想和直接插入一样，只是找合适的插入位置的方式不同，这里是按二分法找到合适的位置，可以减少比较的次数。

* */

private static int[] tDivSort(int[] a) {

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

int temp = a[i];

int left = 0;

int right = i-1;

int mid = 0;

while(left<=right){

mid = (left+right)/2;

if(temp

right = mid-1;

}else{

left = mid+1;

}

}

for (int j = i-1; j >= left; j--) {

a[j+1] = a[j];

}

if(left != i){

a[left] = temp;

}

}

return a;

}

/*

*希尔排序

* 基本思想：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。

* 所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，

* 取第二个增量d2

* 即所有记录放在同一组中进行直接插入排序为止。该方法实质上是一种分组插入方法。

* */

public static int[] shellSort(int[] a){

int d = a.length;

while(true){

d = d / 2;

for(int x=0;x

for(int i=x+d;i

int temp = a[i];

int j;

for(j=i-d;j>=0&&a[j]>temp;j=j-d){

a[j+d] = a[j];

}

a[j+d] = temp;

}

}

if(d == 1){

break;

}

}

return a;

}

/*

*堆排序

*堆排序是一种树形选择排序，是对直接选择排序的有效改进。

*堆的定义下：具有n个元素的序列 (h1,h2,...,hn),当且仅当满足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=2i+1) (i=1,2,...,n/2)时称之为堆。

*在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素(即第一个元素)必为最大项(大顶堆)。完全二 叉树可以很直观地表示堆的结构。堆顶为根，

*其它为左子树、右子树。

*思想:初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，

* 这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。

* 依此类推，直到只有两个节点的堆，并对 它们作交换，最后得到有n个节点的有序序列。从算法描述来看，

* 堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函 数组成。

* 一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

* */

public static int[] heapSort(int[] a) {

int arrayLength=a.length;

//循环建堆

for(int i=0;i

//建堆

buildMaxHeap(a,arrayLength-1-i);

//交换堆顶和最后一个元素

swap(a,0,arrayLength-1-i);

}

return a;

}

//对data数组从0到lastIndex建大顶堆

public static void buildMaxHeap(int[] data, int lastIndex){

//从lastIndex处节点(最后一个节点)的父节点开始

for(int i=(lastIndex-1)/2;i>=0;i--){

//k保存正在判断的节点

int k=i;

//如果当前k节点的子节点存在

while(k*2+1<=lastIndex){

//k节点的左子节点的索引

int biggerIndex=2*k+1;

//如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在

if(biggerIndex

//若果右子节点的值较大

if(data[biggerIndex]

//biggerIndex总是记录较大子节点的索引

biggerIndex++;

}

}

//如果k节点的值小于其较大的子节点的值

if(data[k]

//交换他们

swap(data,k,biggerIndex);

//将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值

k=biggerIndex;

}else{

break;

}

}

}

}

//交换

private static void swap(int[] data, int i, int j) {

int tmp=data[i];

data[i]=data[j];

data[j]=tmp;

}

/*

*归并排序

* 基本思想:归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，

* 每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

* */

public static int[] mergeSort(int[] a) {

//归并排序

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

return a;

}

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

if(left

int middle = (left+right)/2;

//对左边进行递归

mergeSort(a, left, middle);

//对右边进行递归

mergeSort(a, middle+1, right);

//合并

merge(a,left,middle,right);

}

}

private static void merge(int[] a, int left, int middle, int right) {

int[] tmpArr = new int[a.length];

int mid = middle+1; //右边的起始位置

int tmp = left;

int third = left;

while(left<=middle && mid<=right){

//从两个数组中选取较小的数放入中间数组

if(a[left]<=a[mid]){

tmpArr[third++] = a[left++];

}else{

tmpArr[third++] = a[mid++];

}

}

//将剩余的部分放入中间数组

while(left<=middle){

tmpArr[third++] = a[left++];

}

while(mid<=right){

tmpArr[third++] = a[mid++];

}

//将中间数组复制回原数组

while(tmp<=right){

a[tmp] = tmpArr[tmp++];

}

}

/*

* 基数排序

* 基本思想：将所有待比较数值(正整数)统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，

* 依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

* */

private static int[] radixSort(int[] array) {

//找到最大数，确定要排序几趟

int max = 0;

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

if(max

max = array[i];

}

}

//判断位数

int times = 0;

while(max>0){

max = max/10;

times++;

}

//建立十个队列

List queue = new ArrayList();

for (int i = 0; i < 10; i++) {

ArrayList queue1 = new ArrayList();

queue.add(queue1);

}

//进行times次分配和收集

for (int i = 0; i < times; i++) {

//分配

for (int j = 0; j < array.length; j++) {

int x = array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);

ArrayList queue2 = queue.get(x);

queue2.add(array[j]);

queue.set(x,queue2);

}

//收集

int count = 0;

for (int j = 0; j < 10; j++) {

while(queue.get(j).size()>0){

ArrayList queue3 = queue.get(j);

array[count] = queue3.get(0);

queue3.remove(0);

count++;

}

}

}

return array;

}

}