几种经典排序算法的R语言描述

1.数据准备

# 测试数组
vector = c(,,,,,,,,,,,,,,)
vector
 
##  []                                

2.R语言内置排序函数

在R中和排序相关的函数主要有三个:sort(),rank(),order()。

• sort(x)是对向量x进行排序，返回值排序后的数值向量;
• rank()是求秩的函数，它的返回值是这个向量中对应元素的“排名”;
• order()的返回值是对应“排名”的元素所在向量中的位置。

sort(vector)
##  []
order(vector)
##  []
rank(vector)
##  []                        

3.冒泡排序

冒泡排序是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

# bubble sort
bubbleSort = function(vector) {
  n = length(vector)
  :(n-)) {
    ):n) {
      if(vector[i]>=vector[j]){
        temp = vector[i]
        vector[i] = vector[j]
        vector[j] = temp
        }
      }
    }
  return(vector)
}
bubbleSort(vector)
 
##  []                                

4.快速排序

基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

# quick sort
quickSort = function(vector, small, big) {
  left = small
  right = big
  if (left >= right) {
    return(vector)
  }else{
    markValue = vector[left]
    while (left < right) {
      while (left < right && vector[right] >= markValue) {
        right = right -
      }
      vector[left] = vector[right]
      while (left < right && vector[left] <= markValue) {
        left = left +
      }
      vector[right] = vector[left]
    }
  vector[left] = markValue
  vector = quickSort(vector, small, left - )
  vector = quickSort(vector, right + , big)
  return(vector)
  }
}
quickSort(vector,,)
 
##  []                                

5 插入排序

有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

# insert sort
insertSort = function(vector){
  n = length(vector)
  :n){
    markValue = vector[i]
    j=i-
    ){
      if(vector[j]>markValue){
        vector[j+] = vector[j]
        vector[j] = markValue
      }
      j=j-
    }
  }
  return(vector)
}
insertSort(vector)
 
##  []                                

6.希尔排序

希尔排序是插入排序的一种,也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

# shell sort
shellSort = function(vector){
   n = length(vector)
   separate = floor(n/)
   ){
     :separate){
       j = i+separate
       while(j<=n){
         m= j- separate
         markVlaue = vector[j]
         ){
           if(vector[m]>markVlaue){
             vector[m+separate] = vector[m]
             vector[m] = markVlaue
           }
           m = m-separate
         }
         j = j+separate
       }
     }
     separate = floor(separate/)
   }
   return(vector)
}
shellSort(vector)
 
##  []                                

7.选择排序

选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法.

# select sort
selectSort = function(vector){
  n = length(vector)
  :(n-)){
    minIndex = i
    ):n){
      if(vector[minIndex]>vector[j]){
        minIndex = j
      }
    }
    temp = vector[i]
    vector[i] = vector[minIndex]
    vector[minIndex] = temp
  }
  return(vector)
}
selectSort(vector)
 
##  []                                

8.堆排序

堆排序是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。

# heap sort
adjustHeap = function(vector,k,n){
  left = *k
  right = *k+
  max = k
  ){
    if(left<=n&&vector[left]>=vector[max]){
      max = left
    }
    if(right<=n&&vector[right]>=vector[max]){
      max = right
    }
    if(max!=k){
      temp = vector[k]
      vector[k] = vector[max]
      vector[max] = temp
      vector = adjustHeap(vector,max,n)
    }
  }
  return(vector)
}
createHeap = function(vector,n){
  ):){
    vector = adjustHeap(vector,i,n)
  }
  return(vector)
}
heapSort = function(vector){
  n = length(vector)
  vector = createHeap(vector,n)
  :n){
    temp = vector[n-i+]
    vector[n-i+] = vector[]
    vector[] = temp
    vector = adjustHeap(vector,,n-i)
  }
  return(vector)
}

9.归并排序

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

# merge sort
combine = function(leftSet,rightSet){
  m =
  n =
  vectorTemp = c()
  while (m<=length(leftSet)&&n<=length(rightSet)) {
    if(leftSet[m]<=rightSet[n]){
      vectorTemp = append(vectorTemp,leftSet[m])
      m = m+
    }else{
      vectorTemp = append(vectorTemp,rightSet[n])
      n = n+
    }
  }
  if(m>length(leftSet)&&n==length(rightSet)){
    vectorTemp = append(vectorTemp,rightSet[n:length(rightSet)])
  }else if(m==length(leftSet)&&n>length(rightSet)){
    vectorTemp = append(vectorTemp,leftSet[m:length(leftSet)])
  }
  return(vectorTemp)
}
mergeSort = function(vector){
  size = length(vector)
  ){
    return(vector)
  }
    cut = ceiling(size/)
    leftSet = mergeSort(vector[:cut])
    rightSet = mergeSort(vector[(cut+):size])
    vector = combine(leftSet,rightSet)
    return(vector)
}

本文链接：http://www.cnblogs.com/homewch/p/5927280.html

//

//