R语言排序算法代码

##bubble
rm(list = ls())
#vec<-c(2,5,3,9,6,1,7)
 vec<-c(6,2,4,1,5,9)
bubblesort = function(vec){
  n = length(vec)
  for(i in 1:(n-1)) {
    for(j in (i+1):n){
      if(vec[i]>=vec[j]){
        temp<-vec[i]
         vec[i]<-vec[j]
          vec[j]<-temp
      }
    }
  }
  return(vec)
}
bubblesort(vec)


##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-1 
        }
        vector[left]<-vector[right]
         while(left< right && vector[left]<=markvakue) {
           left=left+1
         }
        vector[right]<-vecotr[left]
      }
     vector[left]<-markvalue
     vector<-quicksort(vector,small,left-1)
     vector<-quicksort(vector,right+1,big)
     return(vector)
   }
}




#插入排序
insertsort<-function(vector) {
  n = length(vector)
   for(i in 2:n) {
     temp<-vector[i]
     j<-i-1
     while(vector[j]>temp && j>0) {
       vector[j+1]<-vector[j]
       j<-j-1
       vector[j+1]<-temp
     }
   }
  return(vector)
}

##希尔排序
shellsort <- function(dt) {
  n = length(dt)
  separate = floor(n/2)
   while(separate > 0) {
     for(i in 1:separate ) {
       j = i+separate 
       while(j <= n) {
         m = j-separate 
         temp <- dt[j]
          while(m>0) {
            if (dt[m] >temp) {
              dt[m+separate ] <- dt[m]
              dt[m] = temp
            }
            m = m-separate 
          }
          j = j+separate 
       }
     }
     separate = floor(separate /2)
   }
  return(dt)
}


#选序排序
selectsort = function(d) {
  n = length(d)
   for(i in 1:(n-1)) {
     mind<-i
      for(j in (i+1):n) {
        if(d[mind]>d[j]) {
          mind<-j
        }
      }
     temp <- d[i]
     d[i]<- d[mind]
     d[mind] <- temp
   }
  return(d)
}

#归并排序

combine <- function(leftset,rightset) {

m = 1

  n = 1
  dtemp = c()
  while(m <= length(leftset) && n <= length(rightset)) {
     if(leftset[m] <= rightset[n]) {
       dtemp = append(dtemp,leftset[m])
       m = m+1
     } else {
       dtemp = append(dtemp,rightset[n]) 
       n = n+1
     }
  }
  if(m>length(leftset)&&n==length(rightset)) {
    dtemp <- append(dtemp,rightset[n:length(rightset)])
  } else if (m == length(leftset)&&n>length(rightset)) {
    dtemp = append(dtemp,leftset[m:length(leftset)])
  }
   return(dtemp)
}


mergesort = function(vector) {
  size = length(vector)
  if(size == 1) {
    return(vector)
  }
  cut = ceiling(size/2)
  leftset = mergesort(vector[1:cut])
  rigthset = mergesort(vector[(cut+1):size])
  vector = combine(leftset,rightset)
  return(vector)
}




##堆排法
adjustheap <- function(vector,k,n) {
  left = 2*k
  right = 2*k+1
  max = k
  if(k<=n/2) {
    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) {
  for(i in (n/2):1) {
    vector <- adjustheap(vector,i,n) 
  }
  return(vector)
}
heapsort = function(vector) {
  n = length(vector)
  vector = createheap(vector,n)
  for(i in 1:n) {
    temp = vector[n-i+1]
    vector[n-i+1] <- vector[1]
    vector[1] <- temp
    vector <-adjustheap(vector,1,n-i)
  }
  return(vector)
}