-
버블정렬
- 처음부터 끝까지 인접하는 인덱스의 값을 순차적으로 비교하면서 큰 숫자를 가장 끝으로 옮기는 알고리즘
num = [10, 2, 7, 21, 0]
print(f' not sorted nums: {num}')
length = len(num) -1
for i in range(length):
for j in range(length -1):
if num[j] > num[j+1]:
#temp = num[j]
#num[j] = num[j+1]
#num[j + 1] = temp
num[j], num[j+1] = num[j+1], num[j]
print(f'sorted num: {num}')Q. 학급에 20명. 학생들 키 순서대로 줄 세우기. 학생들의 키는 random 모듈 이용해서 170-185 사이 생성
<모듈>
import copy #깊은복사
def bubbleSort(ns, deepCopy= True):
if deepCopy:
cns = copy.copy(ns)
else:
cns = ns
length = len(cns) - 1
for i in range(length):
for j in range(length -i):
if cns[j] > cns[j +1]:
cns[j], cns[j+1] = cns[j+1], cns[j]
return cns
<실행문>
students = []
for i in range(20):
students.append(rd.randint(170,185))
print(f'students: {students}')
sortedStudents = sm.bubbleSort(students, deepCopy=False)
print(f'sortedStudents: {sortedStudents}')-
삽입정렬
- 정렬되어 있는 자료 배열과 비교해서 정렬 위치 찾음
nums = [5, 10, 2, 1, 0]
for i1 in range(1, len(nums)):
i2 = i1 - 1
cNum = nums[i1] #cNum = 10
while nums[i2] > cNum and i2 >= 0: # 오름차순
#while nums[i2] < cNum and i2 >= 0: #내림차순#
nums[i2 +1] = nums[i2]
i2 -= 1
nums[i2 + 1] = cNum
print(f'nums: {nums}') -모듈 이용 오름차순 정렬
<sortMod 모듈>
def sortNumber(ns, asc=True):
if asc:
for i1 in range(1, len(ns)):
i2 = i1 - 1
cNum = ns[i1]
while ns[i2] > cNum and i2 >= 0:
ns[i2 +1] = ns[i2]
i2 -= 1
ns[i2 +1] = cNum
else:
for i1 in range(1, len(ns)):
i2 = i1 -1
cNum = ns[i1]
while ns[i2] < cNum and i2 >= 0:
ns[i2 +1] = ns[i2]
i2 -= 1
ns[i2 + 1] = cNum
return ns
_________________________________________
<실행문>
import sortMod as sm
nums = [5, 10, 2, 1, 0]
result = sm.sortNumber(nums, asc=True)
print(f'nums: {nums}')
print(f'result: {result}')Q. 1-1000 난수 100개 생성하고 다음 요구사항을 만족하는 모듈
요구1) 생성된 난수들을 오르차순 또는 내림차순 정렬
요구2) 생성된 난수 중 최솟값, 최대값 반환 함수 구현
<sortMod 모듈>
class SortNumbers:
def __init__(self, ns, asc=True):
self.nums = ns
self.isAsc = asc
def isAscending(self, flag):
self.isAsc = flag
def setSort(self):
for i1 in range(len(self. nums)):
i2 = i1 - 1
cNum = self.nums[i1]
if self.isAsc:
while self.nums[i2]> cNum and i2 >= 0:
self.nums[i2 + 1] = self.nums[i2]
i2 -= 1
def getSortedNumbers(self):
return self.nums
def getMinNumber(self):
if self.isAsc:
return self.nums[0]
else:
return self.nums[len(self.nums) -1]
def getMaxNumber(self):
if self.isAsc:
return self.nums[len(self.nums) - 1]
else:
return self.nums[0]
_______________________________________________________
<실행문>
import random
import sortMod as sm
nums = random.sample(range(1, 1000), 100)
print(f'not sorted numbers: {nums}')
#객체 생성
sn = sm.SortNumbers(nums)
#오름차순(ascending)
sn.setSort()
sortedNumbers = sn.getSortedNumbers()
print(f'sortedNumbers by ASC: {sortedNumbers}')
#내림차순(descending)
sn.isAscending(False)
sn.setSort()
sortedNumbers = sn.getSortedNumbers()
print(f'sortedNumbers by DESC: {sortedNumbers}')
#최소와 최대값
print(f'minNumber: {sn.getMinNumber()}')
print(f'MaxNumber: {sn.getMaxNumber()}')-
선택정렬
- 주어진 리스트 중에 최소값을 찾아, 그 값을 맨 앞에 위치한 값과 교체하는 방식으로 자료 정렬하는 알고리즘
nums = [4, 2, 5, 1, 3]
for i in range(len(nums) -1):
minIdx = i
for j in range(i+1, len(nums)):
if nums[minIdx] > nums[j]:
minIdx = j
nums[i], nums[minIdx] = nums[minIdx], nums[i]
print(f' nums: {nums}')Q. 선택정렬 알고리즘을 이용해서 학생 20명 시험점수 오름차순과 내림차순 정렬하는 모듈. 시험점수는 50-100까지
<sortMod 모듈>
def sortNumber(ns, asc=True): # 함수 만들고(ns, 오름차순정렬)
if asc:
for i in range(len(ns), -1):
minIdx = i
for j in range(i+1, len(ns)):
if ns[minIdx] > ns[j]:
minIdx = j
ns[i], ns[minIdx] = ns[minIdx], ns[i]
else:
for i in range(len(ns), -1):
maxIdx = i
for j in range(i+1, len(ns)):
if ns[maxIdx] < ns[j]: #내림차순
maxIdx = j
ns[i], ns[maxIdx] = ns[maxIdx], ns[i]
return ns
____________________________________________________
<실행문>
import random
import sortMod as sm
import copy
scores = random.sample(range(50, 101), 20)
print(f'scores: {scores}')
result = sm.sortNumber(copy.deepcopy(scores))
print(f'result: {result}')
print(f'scores: {scores}')
result = sm.sortNumber(scores, asc=False)
print(f'result: {result}') -
최댓값
- 자료구조에서 가장 큰 값을 찾기
nums = [-2, 04, 5, 7, 10, 0, 8, 20, -11]
class MaxAlgorithm:
def __init__(self, ns):
self.nums = ns
self.maxNum = 0
def getMaxNum(self): #최대값 반환
self.maxNum = self.nums[0] #처음엔 max 값에 맨 앞의 값 부여
for n in self.nums:
if self.maxNum < n:
self.maxNum = n
return self.maxNum
ma = MaxAlgorithm([-2, -4, 5, 7, 10, 0, 8, 20, -11])
maxNum = ma.getMaxNum()
print(f'maxNum: {maxNum}')Q.리스트에서 아스키코드가 가장 큰 값을 찾는 알고리즘
class MaxAlgorithm:
def __init__(self, cs):
self.chars = cs
self.maxChar = 0
def getMaxChar(self):
self.maxChar = self.chars[0]
for c in self.chars:
if ord(self.maxChar) < ord(c):
self.maxChar = c
return self.maxChar
chars = ['c', 'x', 'Q', 'A', 'e', 'P', 'p']
mc = MaxAlgorithm(chars)
maxChar = mc.getMaxChar()
print(f'maxChar = {maxChar}')-
최솟값
- 자료구조에서 가장 작은 값 찾기
class MinAlgorithm:
def __init__(self, ns):
self.nums = ns
self.miinNum = 0
def getMinNum(self):
self.minNum = self.nums[0]
for n in self.nums:
if self.minNum > n:
self.minNum = n
return self.minNum
ma = MinAlgorithm([-2,-4, 5, 7, 10, 0, 8, 20, -11])
minNum = ma.getMinNum()
print(f'minNum: {minNum}') Q. 리스트에서 아스키코드가 가장 작은 값 찾는 알고리즘
class MinAlgorithm:
def __init__(self, cs):
self.chars = cs
self.minChar = 0
def getMinChar(self):
self.minChar = self.chars[0]
for c in self.chars:
if ord(self.minChar) > ord(c):
self.minChar = c
return self.minChar
chars = ['c', 'x', 'Q', 'A', 'e', 'P', 'p']
ma = MinAlgorithm(chars)
minChar = ma.getMinChar()
print(f'minChar: {minChar}')-
최빈값
- 데이터에서 빈도수가 가장 많은 데이터
class MaxAlgorithm:
def __init__(self, ns):
self.nums = ns
self.maxNum = 0
self.maxNumIdx = 0
def setMaxIdxAndNums(self):
self.maxNum = self.nums[0]
self.maxNumIdx = 0
for i, n in enumerate(self.nums):
if self.maxNum < n:
self.maxNum = n
self.maxNumIdx = i
def getMaxNum(self):
return self.maxNum
def getMaxNumIdx(self):
return self.maxNumIdx
nums = [1, 3, 7, 6, 7, 7, 7, 12, 12, 17]
maxAlo = MaxAlgorithm(nums)
maxAlo.setMaxIdxAndNums()
maxNum = maxAlo.getMaxNum()
print(f'maxNum: {maxNum}')
indexes = [0 for i in range(maxNum+1)]
print(f'indexed: {indexes}')
print(f'index length: {len(indexes)}')
for n in nums:
indexes[n] = indexes[n]+1
print(f'indexes: {indexes}')
maxAlo = MaxAlgorithm(indexes)
maxAlo.setMaxIdxAndNums()
maxNum = maxAlo.getMaxNum()
maxNumIdx = maxAlo.getMaxNum()
print(f'maxNum: {maxNum}')
print(f'maxNumIdx: {maxNumIdx}')
print(f'즉, {maxNumIdx}의 빈도수가 {maxNum}로 가장 높다')
파이팅