七大排序算法java实现

/**

* 1.插入排序算法

* @param int[]  未排序数组

* @return
int[]  排完序数组

*

* 插入排序的基本思想是在遍历数组的过程中,假设在序号 i 之前的元素即 [0..i-1] 都已经排好序,

* 本趟需要找到 i 对应的元素 x 的正确位置 k ,并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位,

* 为元素 x “腾位置”,最后将 k 对应的元素值赋为 x

*

* 一般情况下,插入排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1)

*/

public int[] sortInsert(int[] array){

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

int temp = array[i];

int j;

for(j=i-1;j >= 0 && temp< array[j]; j--){

array[j + 1] = array[j];

}

array[j + 1] = temp;

}

return array;

}

/**

* 2.选择排序算法

* @param int[]  未排序数组

* @return
int[]  排完序数组

*

* 选择排序的基本思想是遍历数组的过程中,以 i 代表当前需要排序的序号,则需要在剩余的 [i…n-1] 中找出其中的最小值,

* 然后将找到的最小值与 i 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程,所以人们形象地称之为选择排序。

* 选择排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1)

*/

public int[] sortSelect(int[] arr){

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

int miniPost = i;

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

if (arr[m] < arr[miniPost]) {

miniPost = m;

}

}

if (arr[i] > arr[miniPost]) {

int temp;

temp = arr[i];

arr[i] = arr[miniPost];

arr[miniPost] = temp;

}

}

return arr;

}

/**

* 3.冒泡排序算法

* @param int[]  未排序数组

* @return
int[]  排完序数组

*

* 冒泡排序是將比較大的數字沉在最下面,较小的浮在上面

*

*/

public int[] sortBubble(int[] array){

int temp;

// 第一层循环:表明比较的次数, 比如 length 个元素,比较次数为 length-1 次(肯定不需和自己比)

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

for (int j = array.length - 1; j > i; j--) {

if (array[j] < array[j - 1]) {

temp = array[j];

array[j] = array[j - 1];

array[j - 1] = temp;

}

}

}

return array;

}

/**

* 4.快速排序算法

* @param int[]  未排序数组

* @return
int[]  排完序数组

* 通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,

* 则可以分别对这两部分记录继续进行排序,已达到整个序列有序的目的

* 本质就是,找一个基位(枢轴,分水岭,作用是左边的都比它小,右边的都比它大.可随机,取名base

* 首先从序列最右边开始找比base小的,如果小,换位置,从而base移到刚才右边(比较时比base小)的位置(记为临时的high位),这样base右边的都比base大

* 然后,从序列的最左边开始找比base大的

* ,如果大,换位置,从而base移动到刚才左边(比较时比base大)的位置(记为临时的low位),这样base左边的都比base小

* 循环以上两步,直到 low == heigh, 这使才真正的找到了枢轴,分水岭. 返回这个位置,分水岭左边和右边的序列,分别再来递归

*

*/

public int[] sortQuick(int[] array){

return quickSort(array, 0, array.length-1);

}

private  int[] quickSort(int[] arr, int low, int heigh) {

if (low < heigh) {

int division = partition(arr, low, heigh);

quickSort(arr, low, division - 1);

quickSort(arr, division + 1, heigh);

}

return arr;

}

// 分水岭,基位,左边的都比这个位置小,右边的都大

private int partition(int[] arr, int low, int heigh) {

int base = arr[low]; //用子表的第一个记录做枢轴(分水岭)记录

while (low < heigh) {  //从表的两端交替向中间扫描

while (low < heigh && arr[heigh] >= base) {

heigh--;

}

// base 赋值给 当前 heigh 位,base 挪到(互换)到了这里,heigh位右边的都比base大

swap(arr, heigh, low);

while (low < heigh && arr[low] <= base) {

low++;

}

// 遇到左边比base值大的了,换位置

swap(arr, heigh, low);

}

// now low = heigh;

return low;

}

private  void swap(int[] arr, int a, int b) {

int temp;

temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

}

/**

* 5.合并排序算法

* @param int[]  未排序数组

* @return
int[]  排完序数组

*

* 归并排序采用的是递归来实现,属于“分而治之”,将目标数组从中间一分为二,之后分别对这两个数组进行排序,

* 排序完毕之后再将排好序的两个数组“归并”到一起,归并排序最重要的也就是这个“归并”的过程,

* 归并的过程中需要额外的跟需要归并的两个数组长度一致的空间

*/

private int[] sort(int[] nums, int low, int high) {

int mid = (low + high) / 2;

if (low < high) {

// 左边

sort(nums, low, mid);

// 右边

sort(nums, mid + 1, high);

// 左右归并

merge(nums, low, mid, high);

}

return nums;

}

private void merge(int[] nums, int low, int mid, int high) {

int[] temp = new int[high - low + 1];

int i = low;// 左指针

int j = mid + 1;// 右指针

int k = 0;

// 把较小的数先移到新数组中

while (i <= mid && j <= high) {

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

temp[k++] = nums[i++];

} else {

temp[k++] = nums[j++];

}

}

// 把左边剩余的数移入数组

while (i <= mid) {

temp[k++] = nums[i++];

}

// 把右边边剩余的数移入数组

while (j <= high) {

temp[k++] = nums[j++];

}

// 把新数组中的数覆盖nums数组

for (int k2 = 0; k2 < temp.length; k2++) {

nums[k2 + low] = temp[k2];

}

}

public int[] sortMerge(int[] array) {

return sort(array, 0, array.length - 1);

}

/**

* 6.希尔排序算法

* @param int[]  未排序数组

* @return
int[]  排完序数组

*

* 希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。希尔排序的思想是将一个大的数组“分而治之”,

* 划分为若干个小的数组,以 gap 来划分,比如数组 [1, 2, 3, 4, 5, 6, 7, 8] ,如果以 gap = 2 来划分,

* 可以分为 [1, 3, 5, 7] 和 [2, 4, 6, 8] 两个数组(对应的,如 gap = 3 ,

* 则划分的数组为: [1, 4, 7] 、 [2, 5, 8] 、 [3, 6] )然后分别对划分出来的数组进行插入排序,

* 待各个子数组排序完毕之后再减小 gap 值重复进行之前的步骤,直至 gap = 1 ,即对整个数组进行插入排序,

* 此时的数组已经基本上快排好序了,所以需要移动的元素会很小很小,解决了插入排序在处理大规模数组时较多移动次数的问题

*

* 希尔排序是插入排序的改进版,在数据量大的时候对效率的提升帮助很大,数据量小的时候建议直接使用插入排序就好了。

*/

public int[] sortShell(int[] array) {

// 取增量

int step = array.length / 2;

while (step >= 1) {

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

int temp = array[i];

int j = 0;

// 跟插入排序的区别就在这里

for (j = i - step; j >= 0 && temp < array[j]; j -= step) {

array[j + step] = array[j];

}

array[j + step] = temp;

}

step /= 2;

}

return array;

}

/**

* 7.堆排序算法

* @param int[]  未排序数组

* @return
int[]  排完序数组

*

* 本质就是先构造一个大顶堆,parent比children大,root节点就是最大的节点

* 把最大的节点(root)与尾节点(最后一个节点,比较小)位置互换

* 剩下最后的尾节点,现在最大,其余的,从第一个元素开始到尾节点前一位,构造大顶堆递归

*

*/

public int[] sortHeap(int[] array) {

buildHeap(array);// 构建堆

int n = array.length;

int i = 0;

for (i = n - 1; i >= 1; i--) {

swap(array, 0, i);

heapify(array, 0, i);

}

return array;

}

private void buildHeap(int[] array) {

int n = array.length;// 数组中元素的个数

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

heapify(array, i, n);

}

private void heapify(int[] A, int idx, int max) {

int left = 2 * idx + 1;// 左孩子的下标(如果存在的话)

int right = 2 * idx + 2;// 左孩子的下标(如果存在的话)

int largest = 0;// 寻找3个节点中最大值节点的下标

if (left < max && A[left] > A[idx])

largest = left;

else

largest = idx;

if (right < max && A[right] > A[largest])

largest = right;

if (largest != idx) {

swap(A, largest, idx);

heapify(A, largest, max);

}

}

// 建堆函数,认为【s,m】中只有 s

// 对应的关键字未满足大顶堆定义,通过调整使【s,m】成为大顶堆=====================================================

public static void heapAdjust(int[] array, int s, int m) {

// 用0下标元素作为暂存单元

array[0] = array[s];

// 沿孩子较大的结点向下筛选

for (int j = 2 * s; j <= m; j *= 2) {

// 保证j为较大孩子结点的下标,j < m 保证 j+1 <= m ,不越界

if (j < m && array[j] < array[j + 1]) {

j++;

}

if (!(array[0] < array[j])) {

break;

}

// 若S位较小,应将较大孩子上移

array[s] = array[j];

// 较大孩子的值变成S位的较小值,可能引起顶堆的不平衡,故对其所在的堆进行筛选

s = j;

}

// 若S位较大,则值不变;否则,S位向下移动至2*s、4*s、。。。

array[s] = array[0];

}

时间: 2024-11-05 12:09:51

七大排序算法java实现的相关文章

常见的七大排序算法Java实现

/** * @author Javen * @Email [email protected] * 2015年12月9日 */ public class Sorting { static int[] array = new int[]{11, 31, 12, 5, 34, 30, 26, 38, 36, 18}; public static void main(String[] args) { //插入排序 System.out.println(array2String(sortInsert(ar

排序算法Java实现

排序算法Java实现 排序算法的分类: 内部排序,在排序过程中,全部记录放在内存中,称为内部排序: 外部排序,在排序过程中需要使用外部存储(磁盘),则称为外部排序. 主要介绍内部排序: 插入排序:直接插入排序.二分法插入排序.希尔排序 选择排序:简单选择排序.堆排序 交换排序:冒泡排序.快速排序 归并排序 基数排序 插入排序 直接插入排序 基本思想:对于给定的一组记录,初始时假设第一个记录自成一个有序序列,其余记录为无序序列.接着从第二个记录开始,按照记录的大小依次将当前处理的记录插入到其之前的

经典排序算法(Java实现)

以下程序均将数据封装于DataWrap数据包装类中,如下所示: 1 //数据包装类 2 class DataWrap implements Comparable<DataWrap> 3 { 4 int data; 5 String flag; 6 public DataWrap(int data,String flag) 7 { 8 this.data = data; 9 this.flag = flag; 10 } 11 //重写compareTo方法 12 public int compa

数据结构排序算法Java实现

闲的无聊又拿起了大学的数据结构的书看起来 <数据结构(c语言版)>严蔚敏 吴伟民编著. 里面有几个排序算法,感觉挺好玩的,就想着写出来玩玩. package test.sort; /** * @Title: TODO * @Description: TODO * @author: * @date: 2014-8-10 上午11:20:43 * */ public class quickSort { private static int datas[] = {23,42,12,45,56,63,

七大排序算法(冒泡,选择,插入,希尔,快速,合并,堆排序)的java实现

冒泡排序 思路:就是每次将最大或最小的元素放到数组的最后,so easy!时间复杂度为(O(n^2)) public class BubbleSort { public static void bubbleSort(int[] a) { for (int j = 1; j < a.length; j++) { for (int i = 0; i < a.length - j; i++) { if (a[i] > a[i + 1]) { int temp = a[i]; a[i] = a[

排序算法Java版,以及各自的复杂度,以及由堆排序产生的top K问题

常用的排序算法包括: 冒泡排序:每次在无序队列里将相邻两个数依次进行比较,将小数调换到前面, 逐次比较,直至将最大的数移到最后.最将剩下的N-1个数继续比较,将次大数移至倒数第二.依此规律,直至比较结束.时间复杂度:O(n^2) 选择排序:每次在无序队列中"选择"出最大值,放到有序队列的最后,并从无序队列中去除该值(具体实现略有区别).时间复杂度:O(n^2) 直接插入排序:始终定义第一个元素为有序的,将元素逐个插入到有序排列之中,其特点是要不断的 移动数据,空出一个适当的位置,把待插

八大排序算法JAVA实现(时间复杂度O(n*logn)篇)

本文讲述时间复杂度为n*logn的排序算法:归并排序.快速排序.堆排序以及希尔排序的原理.Java实现以及变形应用. 一.归并排序 原理:把两个有序数列合并为一个有序数列.需递归实现. Java实现: 1 public int[] mergeSort(int[] a, int n) 2 { 3 return doMergeSort(a, n, 0, n - 1); 4 } 5 public int[] doMergeSort(int[] a, int n, int start, int end)

九大排序算法Java实现

之前学习数据结构与算法时花了三天时间整理九大排序算法,并采用Java语言来实现,今天第一次写博客,刚好可以把这些东西从总结的文档中拿出来与大家分享一下,同时作为自己以后的备忘录. 1.排序算法时间复杂度.稳定性分类: 2.排序算法问题描述与实现 2.1冒泡排序(交换排序-稳定) [问题描述]对于一个int数组,请编写一个冒泡排序算法,对数组元素排序. 问题分析:冒泡排序,顾名思义,从前往后遍历,每次遍历在末尾固定一个最大值. 易错点:每次内层循环结束都会在末尾确定一个元素的位置,因此内层循环的判

八大排序算法Java(转)

目录(?)[-] 概述 插入排序直接插入排序Straight Insertion Sort 插入排序希尔排序Shells Sort 选择排序简单选择排序Simple Selection Sort 选择排序堆排序Heap Sort 交换排序冒泡排序Bubble Sort 交换排序快速排序Quick Sort 归并排序Merge Sort 桶排序基数排序Radix Sort 总结 概述 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序