def linear_search(list, find_key):
    for i in range(len(list)):
        if list[i] == find_key:
            return i
    return "not find"


def binary_search(list, find_key):
    mid = len(list)//2
    while True:
        if list[mid] == find_key:
            return mid
        elif list[mid] < find_key:
            mid += mid/2
            if mid >= len(list):
                mid = len(list)-1
        else:
            mid -= mid/2
            if mid/2 == 0:
                mid = 0


class binary_tree:
    value = 0
    left = None
    right = None

    def __init__(self, value):
        self.value = value

    def get_value(self):
        return self.value

    def get_left(self):
        return self.left

    def get_right(self):
        return self.right

    def input_value(self, value):
        if self.value > value:
            if self.left is None:
                new_binary_tree = binary_tree(value)
                self.left = new_binary_tree
                return self.left
            else:
                return True
        else:
            if self.right is None:
                new_binary_tree = binary_tree(value)
                self.right = new_binary_tree
                return self.right
            else:
                return False


def binary_tree_create(list):
    root = binary_tree(list[0])
    for i in range(len(list)):
        if list[i] != root.get_value():
            now_obj = root
            while True:
                temp_obj = now_obj.input_value(list[i])
                if isinstance(temp_obj, binary_tree):
                    break
                else:
                    if temp_obj is True:
                        now_obj = now_obj.get_left()
                    else:
                        now_obj = now_obj.get_right()

    return root


def binary_tree_search(node, value, depth):

    temp_value = node.get_value()
    if temp_value == value:
        return temp_value, depth
    elif temp_value > value:
        if isinstance(node.get_left(), binary_tree) is False:
            return "not find"
        return binary_tree_search(node.get_left(), value, depth+1)
    else:
        if isinstance(node.get_right(), binary_tree) is False:
            return "not find"
        return binary_tree_search(node.get_right(), value, depth+1)


temp_list = [33, 11, 99, 1, 22, 88, 55, 44, 66, 77]


print(linear_search(temp_list, 77))
print(binary_search(temp_list, 77))
root = binary_tree_create(temp_list)
print(binary_tree_search(root, 77, 0))

이진트리는 트리 형식으로 만들어야 함으로 쪼금 길다.

선형 탐색 O(n)

이진 탐색 O( logn) 단 정렬이 되 있어야 함

이진 트리 O( logn) 

파이썬을 간단하게 짠 정렬들... 원리만 알면 구하기 쉬움.

def bubble(list):
    for i in range(len(list)):
        for j in range(len(list)):
            if list[i] < list[j]:
                list[i], list[j] = list[j], list[i]

    return list


def selection(list):
    for i in range(len(list)):
        min_temp = i
        for j in range(i, len(list)):
            if list[min_temp] > list[j]:
                min_temp = j
        list[i], list[min_temp] = list[min_temp], list[i]

    return list


def insertion(list):
    for i in range(len(list)):
        if i+1 < len(list):
            pin = i+1
            for j in reversed(range(0, pin)):
                if list[j] > list[pin]:
                    list[pin], list[j] = list[j], list[pin]
                    pin = j
                else:
                    break
    return list


def quicksort(list):
    if len(list) <= 1:
        return list

    pivot = list[len(list)//2]
    small = []
    many = []
    equal = []
    for x in list:
        if x < pivot:
            small.append(x)
        elif x > pivot:
            many.append(x)
        else:
            equal.append(x)

    return quicksort(small)+equal+quicksort(many)


def mergesort(list):
    if len(list) <= 1:
        return list

    helf = len(list)/2
    left = mergesort(list[:helf])
    right = mergesort(list[helf:])

    return_list = []
    left_x = 0
    right_x = 0
    while left_x < len(left) and right_x < len(right):
        if left[left_x] < right[right_x]:
            return_list.append(left[left_x])
            left_x += 1
        else:
            return_list.append(right[right_x])
            right_x += 1

    return_list += left[left_x:]
    return_list += right[right_x:]

    return return_list


temp_list = [33, 11, 99, 1, 22, 88, 55, 44, 66, 77]


print(bubble(temp_list))
print(selection(temp_list))
print(insertion(temp_list))
print(quicksort(temp_list))
print(mergesort(temp_list))

버블   O(n^2)

선택   O(n^2)

삽입  O(n^2) but 버블/선택 보단 빠르고 메모리를 적게 먹음

퀵     최적 O(nlogn)     최악 O(n^2)

머지  O(nlogn)

- 이 세상에서 이십년 동안 존 재하면서 습득한 상식을 알고 싶다면 그 일에 이십년을 들여야 한다. 이에 상응하는 자기발견적방법론을 그 보다더 짧은 시간내에 조립할 방도는 없다. 경험은 알고림적으로 압축할 수 없기 때문이다.

sf소설로 유명한 테드창의 작품

우리가 AI를 어떻게 발전시키고 이용해 나가는가에 대해서 상상한 작품이다. 꽤나 현실적으로 다가오는 부분이 많은데 AI를 꼭 좋은 일에만 쓰진 않는다는 것이다. 

마지막까지 인간이 되지 못하는 AI들을 주인공이 위와 같이 한 말이 너무나 맘에 와 닿는다. 

한 인간이 되기 위해선 그 한인간만큼의 삶을 살아야 한다는것.

그리고 그만큼의 삶동안은 어떤 생물이든 존경받아야 한다는것.

까칠하게 힐링!

내용은 정말 짧은데...이게 실화라는게 더욱 당혹스럽게 하는책.

한사람이 자연을/ 사람들의 인생을 바꿀수 있다는게 가능하다는걸.

한사람의 조금만한 생각이 많은것을 변화시킬수 있다는것을 깨닫게 된다.

신과 영혼/ 죽음과 삶에 대해서 논리 정연하게 정리한 책.

솔직히 이 책을 2년전에 사고 방치 했다가 이번에 읽긴 했지만......

어렵다..ㅜㅡㅜ

꼼꼼하게 생각해야 할것이 너무 많아서 요약도 불가능할 정도.

정말 꼭 한번 맘먹고 읽어보시면 후회는 없을책

이제 코딩을 시작하는 학생들에게 추천.

대부분 코드컨벤션 이라 하면 낙타/헝가리안 을 주축으로 여러 회사 컨벤션을 참고하라 하는데

그건의 근본이 되는 것은 잘 알려주지 않는다(정확히는 잘 아는 사람도 별로 없는거 같다.)

이 책을 읽으면 확실히 어느 정도의 컨벤션은 잡을수 있을꺼라 생각한다. 

쉽게 쓰여지기도 했고 여러 언어에 걸쳐서 쓰여져서 지금까지 본 컨센션 문서중에 가장 좋은 느낌이 들었다.

추천!