Haskell 自定义排序

注意处理相同的元素

1快排

qsort []=[]

qsort (h:t)=(qsort(filter (<h) t) )++(num (h:t)) ++(qsort(filter (>h) t))
num (h:t)=filter (==h) (h:t)



2冒泡

(1)



bubble_once [] = [] 
bubble_once [x] = [x] 
bubble_once (x : y : zs) | x < y     = y : bubble_once (x : zs) 
                          | otherwise = x : bubble_once (y : zs) 
  
bubble_sort [] = [] 
bubble_sort list = x : bubble_sort xs 
                    where (x : xs) = (reverse . bubble_once) list 



(2)不reverse的例子，不过，++ 和init的操作效率不高，估计和你的差不多： 


bb [] =[] 

bb [x] = [x] 
bb (x:y:xs) | x > y = y: bb (x:xs) 
             | otherwise = x: bb (y:xs) 
                              
bubsort [] = [] 
bubsort xs = let z = bb xs in bubsort (init z) ++ [last z]





（3）选择排序

import Data.List 
select_sort ::Ord a => [a]->[a] 
select_sort [] = [] 
select_sort l =  
     let  
         m = maximum l  
         num = elemIndexNum m  l  
         list0 = numElemList num m 
     in  
         list0 ++ select_sort (filter (<m) l) 
  
--列表中某特定元素的个数 


elemIndexNum ::Ord a => a ->[a]->Int 
elemIndexNum x xs= length $ elemIndices x xs 
  
--相当于python中的[x]*num 
numElemList ::Ord a => Int->a ->[a] 
numElemList 0 x=[] 
numElemList num x= x : numElemList (num-1) x  



插入排序

insert :: Int -> [Int] -> [Int]
insert x [] = [x]
insert x (y:ys)
        | x < y = x:y:ys
        | otherwise = y : insert x ys
 
insertSort :: [Int] -> [Int]
insertSort [] = []
insertSort (x:xs) = insert x (insertSort xs)
归并排序

merge :: [Int] -> [Int] -> [Int]
merge xs [] = xs
merge [] ys = ys
merge (x:xs) (y:ys)
        | x > y = y:merge (x:xs) ys
        | otherwise = x:merge xs (y:ys)
 
mergeSort :: [Int] -> [Int]
mergeSort [] = []
mergeSort [x] = [x]
mergeSort list = merge (mergeSort a) (mergeSort b)
       where 
           (a,b) = splitAt (div (length list)2) list
快速排序

quickSort :: [Int] -> [Int]
quickSort [] = []
quickSort (x:xs) = quickSort [a|a<-xs,a<=x] ++ [x] ++ quickSort [a|a<-xs,a>x]
冒泡排序

swaps :: [Int] -> [Int]
swaps [] = []
swaps [x] = [x]
swaps (x1:x2:xs)
       | x1 > x2 = x2 : swaps(x1:xs)
       | otherwise = x1 : swaps(x2:xs)
 
bubbleSort :: [Int] -> [Int]
bubbleSort xs
           | swaps xs == xs =xs
           | otherwise = bubbleSort $ swaps xs
选择排序

selectFromOri :: Int -> [Int] -> [Int]
selectFromOri _ [] = []
selectFromOri x (y:ys)
           | x == y =ys
           | otherwise = y:selectFromOri x ys
 
 
selectSort :: [Int] -> [Int]
selectSort [] = []
selectSort xs = mini : selectSort xs'
        where
            mini = minimum xs
            xs' = selectFromOri mini xs