공부하자 동진아

n = input()

for i in range(int(n), 0 ,-1):
    print(' ' * (i - 1), end='')
    print('*' * (int(n) - i + 1))

더블 링크드 리스트 기본 구조

  - 이중 링크드 리스트라고도 한다.

  - 장점

      • 양방향으로 연결 노드 탐색이 양쪽으로 모두 가능하다.

      • 링크드 리스트의 항상 앞에서부터 검색해야 되는 단점을 보완

  - 노드는 앞뒤로 주소를 가지고 있으므로 앞에서부터 검색할지 뒤에서 부터 검색할지 판단해서

    검색 속도를 빠르게 할 수 있다.

이중 링크드 리스트 구현

class Node:								# 노드 생성
	def __init__(self, data):
		self.prev = None
        self.data = data
        self.next = None

class NodeMgmt:
	def __init__(self, data):
		self.head = Node(data)
		self.tail = self.head
        
	def insert(self, data):				# 노드 추가
		if self.head == None:
			self.head = Node(data)
			self.tail = self.head
		else:
			node = self.head
			while node.next:			# while문이 계속 반복이 된다면 주소가 계속 존재함
				node = node.next		# 작업을 하는 이유는 노드의 끝을 찾기 위해
			new = Node(data)
			node.next = new
			new.prev = node
			self.tail = new
            
	def desc(self):
		node = self.head
		while node:
			print(node.data)
			node = node.next
            
	def search_from_head(self, data):	# 앞에서부터 검색
		if self.head == None:
			return False

		node = self.head
		while node:
			if node.data == data:
				return node
			else:
				node = node.prev
		return False
        
	def search_from_tail(self, data):	# 뒤에서부터 검색
		if self.head == None:
			return False

		node = self.tail
		while node:
			if node.data == data:
				return node
			else:
				node = node.prev
		return False

	def insert_before(self, data, before_data):		# before_data 값 앞에 데이터 생성
		if self.head == None:
			self.head = Node(data)
			return True
		else:
			node = self.tail
			while node.data != before_data:
				node = node.prev
				if node == None:
					return False
			new  = Node(data)
			before_new = node.prev
			before_new.next = new
			new.prev = before_new
			new.next = node
			node.prev = new
			return True
            
	def insert_after(self, data, after_data):		# after_data 값 뒤에 데이터 생성
		if self.head == None:
			self.head = Node(data)
			return True
		else:
			node = self.head
			while node.data != after_data:
				node = node.next
				if node == None:
					return False
			new  = Node(data)
			after_new = node.next
			new.next = after_new
			new.prev = node
			node.next = new
			if new.next == None:
				self.tail = new
			return True
    

링크드 리스트 구조

  - 연결 리스트라고도 함

  - 배열은 순차적으로 연결된 공간에 데이터를 나열하는 데이터 구조

  - 링크드 리스트는 떨어진 곳에 존재하는 데이터를 화살표로 연결해서 관리하는 데이터 구조

  - 링크드 리스트 기본 구조와 용어

      • 노드(Node) : 데이터 저장 단위 (데이터 값, 포인터)로 구성, 하나의 데이터

      • 포인터(pointer) : 각 노드 안에서, 다음이나 이전의 노드와의 연결 정보를 가지고 있는 공간

링크드 리스트의 장단점

  - 장점

      • 미리 데이터 공간을 할당하지 않아도 된다. (배열은 미리 데이터 공간을 할당)

  - 단점

      • 연결을 위한 별도 데이터 공간이 필요하므로, 저장 공간 효율이 높지 않다.

      • 연결 정보를 찾는 시간이 필요하므로 접근 속도가 느리다.

      • 중간 데이터 삭제 시, 앞뒤 데이터의 연결을 재구성해야 하는 부가적인 작업이 필요하다.

파이썬 객체지향 프로그래밍으로 링크드 리스트 구현 : 노드 생성, 추가, 삭제, 검색

class Node:		# 노드 생성
	def __init__(self, data):
		self.data = data
		self.next = None

class NodeMgmt:
	def __init__(self, data):		# 맨 앞에 값을 지정
		self.head = Node(data)

	def add(self, data):			# 데이터 추가
		if self.head == '':
			self.head = Node(data)
		else:
			node = self.head
			while node.next:
				node = node.next
			node.next = Node(data)	# 노드 연결

	def desc(self):					# 해당 전체 링크드 리스트 출력
		node = self.head
		while node:
			print(node.data)
			node = node.next

	def delete(self, data):			# 데이터 삭제
		if self.head =='':
			print('해당 값을 가진 노드가 없습니다.')
			return
            
		if self.head.data == data:	# head 삭제
			temp = self.head
			self.head = self.head.next
			del temp
		else:
			node = self.head
			while node.next:		# head가 아닌 노드 삭제
				if node.next.data == data:
					temp = node.next
					node.next = node.next.next
					del temp
					return
				else:
					node = node.next

	def search_node(self, data):	# 노드 삭제
		node = self.head
		while node:
			if node.data == data:
				return node
			else:
				node = node.next

import sys

n = int(sys.stdin.readline())

for i in range(0, n):
    for j in range(0, i+1):
        print('*', end='')		# end=''를 사용하면 줄바꿈 없이 출력된다.
    print(end='\n')