这里只是为了《算法导论》的复习，写的代码
class Solution {
public int[] sortArray(int[] nums) {
if(nums.length <=1)return nums;
//qSort(nums,0,nums.length-1);
//selectSort(nums);
// insertSort(nums);
// shellSort(nums);
// bucketSort(nums);
// countSort(nums);
// mergeSort(nums,0,nums.length-1);
heapSort(nums);
return nums;
}
/**
快速排序
**/
class Solution {
public List<Integer> sortArray(int[] nums) {
List<Integer> list = new ArrayList<>();
quicksort(nums,0,nums.length - 1);
for (int num : nums) {
list.add(num);
}
return list;
}
public void quicksort(int []nums,int l,int r){
if(l >= r){
return ;
}
int p = partition(nums,l,r);
quicksort(nums,l,p - 1);
quicksort(nums,p + 1,r);
}
public int partition(int[] nums,int l,int r){
int x = nums[r];
int i = l;
int j = l;
while (i < r){
if(nums[i] < x){
int tem = nums[i];
nums[i] = nums[j];
nums[j] = tem;
j ++;
}
i ++;
}
int tem = nums[i];
nums[i] = nums[j];
nums[j] = tem;
return j;
}
}
/**
选择排序
**/
void selectSort(int[] arr){
int min;
for(int i = 0;i<arr.length;i++){
min = i;
for(int j = i;j<arr.length;j++){
if(arr[j] < arr[min]){
min = j;
}
}
if(min != i) {
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}
/**
*
* 插入排序：数列前面部分看为有序，依次将后面的无序数列元素插入到前面的有序数列中，初始状态有序数列仅有一个元素，即首元素。在将无序数列元素插入有序数列的过程中，采用了逆序遍历有序数列，相较于顺序遍历会稍显繁琐，但当数列本身已近排序状态效率会更高。
*
* 时间复杂度：O(N2) 稳定性：稳定
* @param arr
*/
public void insertSort(int arr[]){
for(int i = 1; i < arr.length; i++){
int rt = arr[i];
for(int j = i - 1; j >= 0; j--){
if(rt < arr[j]){
arr[j + 1] = arr[j];
arr[j] = rt;
}else{
break;
}
}
}
}
/**
* 希尔排序 - 插入排序的改进版。为了减少数据的移动次数，在初始序列较大时取较大的步长，通常取序列长度的一半，此时只有两个元素比较，交换一次；之后步长依次减半直至步长为1，即为插入排序，由于此时序列已接近有序，故插入元素时数据移动的次数会相对较少，效率得到了提高。
*
* 时间复杂度：通常认为是O(N3/2) ，未验证 稳定性：不稳定
* @param arr
*/
void shellSort(int arr[]){
int d = arr.length >> 1;
while(d >= 1){
for(int i = d; i < arr.length; i++){
int rt = arr[i];
for(int j = i - d; j >= 0; j -= d){
if(rt < arr[j]){
arr[j + d] = arr[j];
arr[j] = rt;
}else break;
}
}
d >>= 1;
}
}
/**
* 桶排序 - 实现线性排序，但当元素间值得大小有较大差距时会带来内存空间的较大浪费。首先，找出待排序列中得最大元素max，申请内存大小为max + 1的桶（数组）并初始化为0；然后，遍历排序数列，并依次将每个元素作为下标的桶元素值自增1；
* 最后，遍历桶元素，并依次将值非0的元素下标值载入排序数列（桶元素>1表明有值大小相等的元素，此时依次将他们载入排序数列），遍历完成，排序数列便为有序数列。
*
* 时间复杂度：O(x*N) 稳定性：稳定
* @param arr
*/
void bucketSort(int[] arr){
int[] bk = new int[50000 * 2 + 1];
for(int i = 0; i < arr.length; i++){
bk[arr[i] + 50000] += 1;
}
int ar = 0;
for(int i = 0; i < bk.length; i++){
for(int j = bk[i]; j > 0; j--){
arr[ar++] = i - 50000;
}
}
}
/**
* 基数排序 - 桶排序的改进版，桶的大小固定为10，减少了内存空间的开销。首先，找出待排序列中得最大元素max，并依次按max的低位到高位对所有元素排序；
* 桶元素10个元素的大小即为待排序数列元素对应数值为相等元素的个数，即每次遍历待排序数列，桶将其按对应数值位大小分为了10个层级，桶内元素值得和为待排序数列元素个数。
* @param arr
*/
void countSort(int[] arr){
int[] bk = new int[19];
Integer max = Integer.MIN_VALUE;
for(int i = 0; i < arr.length; i++){
if(max < Math.abs(arr[i])) max = arr[i];
}
if(max < 0) max = -max;
max = max.toString().length();
int [][] bd = new int[19][arr.length];
for(int k = 0; k < max; k++) {
for (int i = 0; i < arr.length; i++) {
int value = (int)(arr[i] / (Math.pow(10,k)) % 10);
bd[value+9][bk[value+9]++] = arr[i];
}
int fl = 0;
for(int l = 0; l < 19; l++){
if(bk[l] != 0){
for(int s = 0; s < bk[l]; s++){
arr[fl++] = bd[l][s];
}
}
}
bk = new int[19];
fl = 0;
}
}
/**
* 归并排序 - 采用了分治和递归的思想，递归&分治-排序整个数列如同排序两个有序数列，依次执行这个过程直至排序末端的两个元素，再依次向上层输送排序好的两个子列进行排序直至整个数列有序（类比二叉树的思想，from down to up）。
*
* 时间复杂度：O(NlogN) 稳定性：稳定
* @param arr
*/
void mergeSortInOrder(int[] arr,int bgn,int mid, int end){
int l = bgn, m = mid +1, e = end;
int[] arrs = new int[end - bgn + 1];
int k = 0;
while(l <= mid && m <= e){
if(arr[l] < arr[m]){
arrs[k++] = arr[l++];
}else{
arrs[k++] = arr[m++];
}
}
while(l <= mid){
arrs[k++] = arr[l++];
}
while(m <= e){
arrs[k++] = arr[m++];
}
for(int i = 0; i < arrs.length; i++){
arr[i + bgn] = arrs[i];
}
}
void mergeSort(int[] arr, int bgn, int end)
{
if(bgn >= end){
return;
}
int mid = (bgn + end) >> 1;
mergeSort(arr,bgn,mid);
mergeSort(arr,mid + 1, end);
mergeSortInOrder(arr,bgn,mid,end);
}
/**
* 堆排序 - 堆排序的思想借助于二叉堆中的最大堆得以实现。首先，将待排序数列抽象为二叉树，并构造出最大堆；然后，依次将最大元素（即根节点元素）与待排序数列的最后一个元素交换（即二叉树最深层最右边的叶子结点元素）；
* 每次遍历，刷新最后一个元素的位置（自减1），直至其与首元素相交，即完成排序。
*
* 时间复杂度：O(NlogN) 稳定性：不稳定
*
* @param arr
*/
void heapSort(int[] nums) {
int size = nums.length;
for (int i = size/2-1; i >=0; i--) {
adjust(nums, size, i);
}
for (int i = size - 1; i >= 1; i--) {
int temp = nums[0];
nums[0] = nums[i];
nums[i] = temp;
adjust(nums, i, 0);
}
}
void adjust(int []nums, int len, int index) {
int l = 2 * index + 1;
int r = 2 * index + 2;
int maxIndex = index;
if (l<len&&nums[l]>nums[maxIndex])maxIndex = l;
if (r<len&&nums[r]>nums[maxIndex])maxIndex = r;
if (maxIndex != index) {
int temp = nums[maxIndex];
nums[maxIndex] = nums[index];
nums[index] = temp;
adjust(nums, len, maxIndex);
}
}
}
万恶的归并排序
弄了一个多小时
class Solution {
public int[] sortArray(int[] nums) {
// heapsort
getx(0, nums.length - 1, nums);
return nums;
}
public void getx(int l, int r, int[] nums) {
if (l >= r) {
return;
}
int mid = ((r + l) >> 1);
getx(l, mid, nums);
getx(mid + 1,r, nums);
mergeSortInOrder(nums,l, r,mid);
// 从l 到 mid 归并
}
public void mergeSortInOrder(int []nums,int l, int r, int mid) {
mid ++; //错误出现在这里，我以为传进来的mid为右边的起点，其实应该是mid + 1才是
// 左边 l - mid
// 右边 mid + 1 - r
int lenleft = mid - l + 1;
int lenright = r - mid + 2;
int left[] = new int[lenleft];
int right[] = new int[lenright];
for (int i = l; i < mid; i++) {
left[i - l] = nums[i];
}
for (int i = mid; i <= r; i++) {
right[i - mid] = nums[i];
}
right[lenright - 1] = Integer.MAX_VALUE;
left[lenleft - 1] = Integer.MAX_VALUE;
int index = l;
int il = 0;
int ir = 0;
while (index <= r){
if(left[il] <= right[ir]){
nums[index] = left[il ++];
}else{
nums[index] = right[ir ++];
}
index ++;
}
}
}
快速排序实现
理解了就很简单
class Solution {
public int[] sortArray(int[] nums) {
quicksort1(nums,0,nums.length - 1);
return nums;
}
public void quicksort1(int []nums,int p ,int r){
if(p < r){
int q = patition(nums,p,r);
quicksort1(nums,p,q - 1);
quicksort1(nums,q + 1,r);
}
}
public int patition(int[] nums, int p, int r) {
int key = nums[r];
int i = p;
while (p < r) {
if (nums[p] <= key) {
int tem = nums[p];
nums[p] = nums[i];
nums[i] = tem;
i++;
}
p ++;
}
int tem = nums[r];
nums[r] = nums[i];
nums[i] = tem;
return i;
}
}
堆排序
/**
* 堆排序：Java
*
* @author skywang
* @date 2014/03/11
*/
public class HeapSort {
/*
* (最大)堆的向下调整算法
*
* 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
* 其中，N为数组下标索引值，如数组中第1个数对应的N为0。
*
* 参数说明：
* a -- 待排序的数组
* start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
* end -- 截至范围(一般为数组中最后一个元素的索引)
*/
public static void maxHeapDown(int[] a, int start, int end) {
int c = start; // 当前(current)节点的位置
int l = 2*c + 1; // 左(left)孩子的位置
int tmp = a[c]; // 当前(current)节点的大小
for (; l <= end; c=l,l=2*l+1) {
// "l"是左孩子，"l+1"是右孩子
if ( l < end && a[l] < a[l+1])
l++; // 左右两孩子中选择较大者，即m_heap[l+1]
if (tmp >= a[l])
break; // 调整结束
else { // 交换值
a[c] = a[l];
a[l]= tmp;
}
}
}
/*
* 堆排序(从小到大)
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组的长度
*/
public static void heapSortAsc(int[] a, int n) {
int i,tmp;
// 从(n/2-1) --> 0逐次遍历。遍历之后，得到的数组实际上是一个(最大)二叉堆。
for (i = n / 2 - 1; i >= 0; i--)
maxHeapDown(a, i, n-1);
// 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
for (i = n - 1; i > 0; i--) {
// 交换a[0]和a[i]。交换后，a[i]是a[0...i]中最大的。
tmp = a[0];
a[0] = a[i];
a[i] = tmp;
// 调整a[0...i-1]，使得a[0...i-1]仍然是一个最大堆。
// 即，保证a[i-1]是a[0...i-1]中的最大值。
maxHeapDown(a, 0, i-1);
}
}
/*
* (最小)堆的向下调整算法
*
* 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
* 其中，N为数组下标索引值，如数组中第1个数对应的N为0。
*
* 参数说明：
* a -- 待排序的数组
* start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
* end -- 截至范围(一般为数组中最后一个元素的索引)
*/
public static void minHeapDown(int[] a, int start, int end) {
int c = start; // 当前(current)节点的位置
int l = 2*c + 1; // 左(left)孩子的位置
int tmp = a[c]; // 当前(current)节点的大小
for (; l <= end; c=l,l=2*l+1) {
// "l"是左孩子，"l+1"是右孩子
if ( l < end && a[l] > a[l+1])
l++; // 左右两孩子中选择较小者
if (tmp <= a[l])
break; // 调整结束
else { // 交换值
a[c] = a[l];
a[l]= tmp;
}
}
}
/*
* 堆排序(从大到小)
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组的长度
*/
public static void heapSortDesc(int[] a, int n) {
int i,tmp;
// 从(n/2-1) --> 0逐次遍历每。遍历之后，得到的数组实际上是一个最小堆。
for (i = n / 2 - 1; i >= 0; i--)
minHeapDown(a, i, n-1);
// 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
for (i = n - 1; i > 0; i--) {
// 交换a[0]和a[i]。交换后，a[i]是a[0...i]中最小的。
tmp = a[0];
a[0] = a[i];
a[i] = tmp;
// 调整a[0...i-1]，使得a[0...i-1]仍然是一个最小堆。
// 即，保证a[i-1]是a[0...i-1]中的最小值。
minHeapDown(a, 0, i-1);
}
}
public static void main(String[] args) {
int i;
int a[] = {20,30,90,40,70,110,60,10,100,50,80};
System.out.printf("before sort:");
for (i=0; i<a.length; i++)
System.out.printf("%d ", a[i]);
System.out.printf("\n");
heapSortAsc(a, a.length); // 升序排列
//heapSortDesc(a, a.length); // 降序排列
System.out.printf("after sort:");
for (i=0; i<a.length; i++)
System.out.printf("%d ", a[i]);
System.out.printf("\n");
}
}
扫一扫
402
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
