各种排序算法的JAVA实现

来源：互联网发布：趣味性软件使用教程编辑：程序博客网时间：2024/05/01 09:13

冒泡排序：

/**
* 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
* 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
* 针对所有的元素重复以上的步骤，除了最后一个。
* 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
*
*/
public static void bubbleSort(int[] array)
{
int temp = 0;
int length =array.length;
for(int i = 0 ; i < length-1; i ++)
{
for(int j = 0 ;j < length-1-i ; j++)
{
if(numbers[j] > numbers[j+1]) //交换两数位置
{
temp = numbers[j];
numbers[j] = numbers[j+1];
numbers[j+1] = temp;
}
}
}
}

快速排序：

/**

*取一个基准元素（一般为第一个数），执行一次代码，将它放在数组正确的位置，左边都比这个数小，右边都比这个数大

*将剩下的数组分成左右两部分分别执行

private static void quick(int[] a)
{
if (a.length > 0)
{
quickSort(a, 0, a.length - 1);
}
}

private static void quickSort(int[] a, int low, int high)
{
if (low < high)
{ // 如果不加这个判断递归会无法退出导致堆栈溢出异常
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 < high)
{
// 找到比基准元素小的元素位置
while (low < high && a[high] >= temp)
{
high--;
}
a[low] = a[high];
while (low < high && a[low] <= temp)
{
low++;
}
a[high] = a[low];
}
a[low] = temp;
return low;
}

归并排序:

/**

*思想是两个有序数组整合为一个数组，然后进行递归，直到每个元数组只有一个元素，然后再进行整合。

public static 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;
}

public static 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];
}
}

希尔排序

int[] a = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 1 };
System.out.println("排序之前：");
for (int i = 0; i < a.length; i++)
{
System.out.print(a[i] + " ");
}
// 希尔排序
int d = a.length;
while (true)
{
d = d / 2;
for (int x = 0; x < d; x++)
{
for (int i = x + d; i < a.length; i = i + d)
{
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;
}
}
System.out.println();
System.out.println("排序之后：");
for (int i = 0; i < a.length; i++)
{
System.out.print(a[i] + " ");
}

0 0