[학습 총화 - Haaskell - 2] Haskell 중요 데이터 구조: List

Haskell 중요 데이터 구조 - List
Table of Contents

1 Haskell 기본 지식

2 Haskell 중요 데이터 구조 - List

2.1 리스트 기본 지식

2.2 리스트 관련 함수

2.3 List 특성 을 이용 하여 프로그램 작성

1 하 스 켈 기본 지식
2 Haskell 중요 데이터 구조 - List
2.1 기본 지식 목록

List 표시

예 1 기본 요소 가 정수 인 List

ghci>let tList = [1,2,3,4]
ghci>tList 
[1,2,3,4]

예 2 기본 요소 가 List 인 List

ghci>[[1,2],[3],[4,5,6]]
[[1,2],[3],[4,5,6]]

예 3 기본 요소 가 문자 인 List, 즉 문자열

ghci>['h','e','l','l','o']
"hello"

예 4 리스트 열거 표시

ghci>[1..10]
[1,2,3,4,5,6,7,8,9,10]
ghci>['a'..'e']
"abcde"
ghci>[2,4..10]
[2,4,6,8,10]
ghci>[5..2]
[]
ghci>[5,4..2]
[5,4,3,2]

예 5 List 의 설명 표시

ghci>[x | x <- [1..10], x > 3, x < 7]
[4,5,6]
ghci>[x + y | x <- [1,2,3], y <- [4,5]]
[5,6,6,7,7,8]

예 6 List 가 뭔 지 List 가 같은 유형의 요소 가 붙 어 있어 요.

ghci>3:[4,5]
[3,4,5]
ghci>3:4:[5]
[3,4,5]
ghci>3:4:5:[]
[3,4,5]

List 기본 동작

목록 연결

ghci>[1,2,3] ++ [4,5]
[1,2,3,4,5]

List 요소 에 대한 접근

ghci>[4,2,1] !! 2
1
ghci>[4,2,1] !! 1
2
ghci>[4,2,1] !! 0
4
ghci>"hi,jack" !! 2
','

List 의 비교

List 의 비교 방식 은 사전 순서에 따라

ghci>[1,2] > [2,3]
False
ghci>[1,2] > [1,1]
True
ghci>[1,2,3] > [1,2]
True
ghci>[1,2,-1] > [1,2]
True
ghci>[1,2] > [1,2,3]
False

2.2 관련 함수 목록

head

ghci>head [3,1,4]
3

tail

ghci>tail [3,1,4]
[1,4]

init

ghci>init [3,1,4]
[3,1]

last

ghci>last [3,1,4]
4

length

ghci>length [3,1,4]
3

null

ghci>null [3,1,4]
False
ghci>null []
True

reverse

ghci>reverse [1,2,3,4]
[4,3,2,1]

take

ghci>take 2 [3,1,5]
[3,1]
ghci>take 1 [3,1,5]
[3]
ghci>take 0 [3,1,5]
[]

drop

ghci>drop 2 [3,1,5]
[5]
ghci>drop 1 [3,1,5]
[1,5]
ghci>drop 0 [3,1,5]
[3,1,5]

maximum

ghci>maximum [1,5,2,3]
5

sum

ghci>sum [1,2,3]
6
ghci>sum [1..10]
55

product

ghci>product [4,2,5]
40

elem

ghci>3 `elem` [6,7,8]
False
ghci>6 `elem` [6,7,8]
True
ghci>7 `elem` [6,7,8]
True
ghci>elem 3 [6,7,8]
False
ghci>elem 6 [6,7,8]
True
ghci>elem 7 [6,7,8]
True

cycle

ghci>cycle [5,2,8]
[5,2,8,5,2,8,5,2,8,5,2,8,...] --      
ghci>take 5 (cycle [5,2,8])
[5,2,8,5,2]
ghci>take 10 (cycle [5,2,8])
[5,2,8,5,2,8,5,2,8,5]

repeat

ghci>repeat 3
3,3,3,...
ghci>take 5 (repeat 3)
[3,3,3,3,3]

replicate

ghci>replicate 2 10
[10,10]
ghci>replicate 3 10
[10,10,10]

2.3 List 특성 을 이용 하여 프로그램 을 작성 하 다

List 설명 표시 방법

예 1

boomBang xs = [ if x < 3 then "BOOM" else "BANG" | x <- xs ]

ghci>:l listProg.hs
[1 of 1] Compiling Main             ( listProg.hs, interpreted )
Ok, modules loaded: Main.
ghci>boomBang [1..5]
["BOOM","BOOM","BANG","BANG","BANG"]
ghci>boomBang [0..4]
["BOOM","BOOM","BOOM","BANG","BANG"]

예 2

cartesianproduc xs ys = [ [x,y] | x <- xs, y <- ys]

ghci>cartesianproduc [3,2] [1,5,6]
[[3,1],[3,5],[3,6],[2,1],[2,5],[2,6]]

예 3

removeNonUppercase xs = [ x | x <- xs, x `elem` ['A'..'Z'] ]

ghci>removeUppercase "SDFAasdfRQf"
"SDFARQ"

List 와 패턴 일치 (Pattern Matching)

예 1

head' [] = error "empty list can not be head"
head' (x:_) = x

ghci>head' []
*** Exception: empty list can not be head
ghci>head' "dafs"
'd'
ghci>head' [3,4,1]
3

예 2

tell [] = "This is a empty list"
tell (x:[]) = "This list have only one element:" ++ show x
tell (x:y:[]) = "This list have two elemtn: " ++ show x ++ " and " ++ show y
tell (x:y:_) = "This is a long list"

ghci>tell []
"This is a empty list"
ghci>tell [3]
"This list have only one element:3"
ghci>tell [3,4]
"This list have two elemtn: 3 and 4"
ghci>tell [3,4,5,6]
"This is a long list"
ghci>tell "sdfa"
"This is a long list"
ghci>tell "sd"
"This list have two elemtn: 's' and 'd'"

예 3

abbrev firstName lastName = [f] ++ "." ++ [l]
  where (f:_) = firstName
        (l:_) = lastName

ghci>abbrev "Tom" "Hacks"
"T.H"
ghci>abbrev "Alan" "Kay"
"A.K"

예 4

describeList ls = "This list is "
                  ++ case ls of []  -> "empty"
                                [x] -> "a singleton list"
                                xs -> "a long list"

ghci>describeList []
"This list is empty"
ghci>describeList "a"
"This list is a singleton list"
ghci>describeList "hello"
"This list is a long list"

List 와 재 귀 (Recursion)

예 1

maxElem [] = error "Empty List have no max element"
maxElem [x] = x
maxElem (x:xs) = max x (maxElem xs)

ghci>maxElem []
*** Exception: Empty List have no max element
ghci>maxElem [1]
3
ghci>maxElem [3,2,6,1]
6

예 2

replicate' n x
  | n <= 0 = []
  | otherwise = x : replicate' (n-1) x

ghci>replicate' 0 2
[]
ghci>replicate' 5 2
[2,2,2,2,2]

예 3

take' n _
  | n <= 0 = []
take' _ [] = []
take' n (x:xs) = x : take' (n-1) xs

ghci>take' (-3) [1,2]
[]
ghci>take' 4 [1..10]
[1,2,3,4]

예 4

reverse' [] = []
reverse' (x:xs) = reverse' xs ++ [x]

ghci>reverse' []
[]
ghci>reverse' [1..10]
[10,9,8,7,6,5,4,3,2,1]

예 5

elem' x [] = False
elem' x (y:xs)
  | x == y = True
  | otherwise = elem' x xs

ghci>elem' 5 [2,5,7]
True
ghci>elem' 5 [2,7]
False

quicksort

quickSort [] = []
quickSort (x:xs) =
  let smallerPart = [a | a <- xs, a <= x]
      largerPart = [a | a <- xs, a > x]
  in quickSort smallerPart ++ [x] ++ quickSort largerPart

[a | a < = x, a < - xs] 형식 으로 쓰 지 않도록 주의 하 십시오. a 가 도 메 인 에 없 음 을 알려 줍 니 다. 먼저 a < - xs 를 써 야 a < = x 의 성립 여 부 를 결정 할 수 있 습 니 다.

ghci>quickSort [2,6,1,8,4]
[1,2,4,6,8]
ghci>quickSort []
[]