'+++++SW 일일 공부+++++/SW Expert Aademy'에 해당되는 글 40건

###단축키

new_list = old_list   주소의 복사, 얕은 복사
new_list = old_list[:]   슬라이싱, 깊은 복사
new_list = []
new_list.extend(old_list)
  extend() : 리스트를 추가하는 함수 깊은 복사
new_list = list(old_list)   list(), 깊은 복사
import copy
new_list = copy.copy(old_list)
  copy 활용, 깊은 복사
new_list = [i for i in old_list]   리시트 함축, 깊은 복사
import copy
new_list = copy.deepcopy(old_list)
  리시트원소까지도 깊은 복사
가장느림
addtoFirst()   연결 리스트의 앞쪽에 원소를 추가하는 연산
addtoLast()   연결 리스트의 뒤쪽에 원소를 추가하는 연산
add()   연결 리스트의 특정 위치에 원소를 추가하는 연산
delete()   연결 리스트의 특정 위치에 있는 원소를 삭제하는 연산
get()   연결 리스트의 특정 위치에 있는 원소를 리턴하는 연산

### 첫노드 삭제 알고리즘

def deleteFirst():
	global Head
    if Head == None:
    	print('error')
    else:
    	Head = Head.link

# 노드삭제알고리즘

def delete(pre):
	if pre == None or pre.link == None:
    	print('error')
    else:
    	pre.link = pre.link.link

# 분활과정의 알고리즘

def merge_sort(m):
	if len(m) <= 1:
    	return m
    mid = len(m) //2
    left = m[:mid]
    right = m[mid:]
    
    left = merge_sort(left)
    right = merge_sort(right)
    
    return merge(left,right)
    

# 병합과정의 알고리즘

def merge(left, right):
	result = []
    while len(left) > 0 and len(right) > 0 :
    	if left[0] <= right[0] :
        	result.append(left.pop(0))
        else :
        	result.append(right.pop(0))
    if len(left) > 0 :
    	result.extent(left)
    if len(right) > 0 :
    	result.extend(right)
    return result

# push / pop 연산의 알고리즘

def push(i):
	global top
    top = Node(i, top)
    
def pop():
	global top
    
    if top == None:
    	print("error")
    else:
    	data = top.data
        top = top.link
        return data

 

'+++++SW 일일 공부+++++ > SW Expert Aademy' 카테고리의 다른 글

Queue 에대하여  (0) 2020.04.22
SW 분할 정복  (0) 2020.04.19
SW 백트래킹 미로찾기  (0) 2020.04.19
SW 계산방법  (0) 2020.04.19
트리구조의 모든 집합 구하기 시프트 활용  (0) 2020.04.09
블로그 이미지

Or71nH

,

###Q 를이용한 너비 우선 탐색

def BFS(G, v):
	visited = [0]*n
    queue = []
    queue.append(v) 
    while queue :
    	t = queue.pop(0)
        if not visite[t] :
        	visitedt] = True
            visit(t)
        for i in G[t] :
        	if not visited[i] :
        		queue.append(i)

 

###선형Q

enQueue(item) 큐의 뒤쪽 rear 다음)에 원소를 삽입하는 연산 def enQueue(item) :
    global rear
    if isFull() : print("Queue_Full")
    else :
        rear +=1
        Q[rear] = item
deQueue() 큐의 앞쪽(front)에서 원소를 삭제하고 반환하는 연산 def deQueue(item) :
    global front
    if isEmpty() : print("Queue_Empty")
    else : 
        front +=1
        return Q[front]
createQueue() 공백 상태의 큐를 생성하는 연산  
isEmpty() 큐가 공백상태인지를 확인하는 연산 def isEmpty():
    return front ==rear
isFull() 큐가 포화상태인지를 확인하는 연산 def isFull():
    return rear == len(Q) -1
aQpeek() 큐의 앞쪽(front)에서 원소를 삭제 없이 반환하는 연산 def Qpeek():
    if isEmpty() : print("Queue_Empty")
    else:return Q[front+1]

### 원형 Queue

enQueue(item) 큐의 뒤쪽 rear 다음)에 원소를 삽입하는 연산 def enQueue(item) :
    global rear
    if isFull() : print("Queue_Full")
    else : 
        rear = (rear +1) % len(cQ)
        cQ[rear] = item
deQueue() 큐의 앞쪽(front)에서 원소를 삭제하고 반환하는 연산 def deQueue(item) :
    global front
    if isEmpty() : print("Queue_Empty")
    else : 
        front = (front + 1)% len(cQ)
        return cQ[front]
delet() 삭제하려 할때 def delet():
    global front
    if isEmpty():
        print("Queue_Empty")
    else :
        front = (front + 1) % len(cQ)
createQueue() 공백 상태의 큐를 생성하는 연산  
isEmpty() 큐가 공백상태인지를 확인하는 연산 def isEmpty():
    return front ==rear
isFull() 큐가 포화상태인지를 확인하는 연산 def isFull():
    return rear +1 % len(cQ)== fornt
aQpeek() 큐의 앞쪽(front)에서 원소를 삭제 없이 반환하는 연산 def Qpeek():
    if isEmpty() : print("Queue_Empty")
    else:return Q[front+1]

### 원형큐

def isEmpty():
	return front ==rear
    
def isFull():
	return(rear+1) %len(cQ) ==front
    
def enQueue(item):
	global rear
    if isFull():
    	print("Queue_Full")
    else :
    	rear = (rear +1) %len(cQ)
        cQ[rear] = item
        
def deQueue():
	global front
    if isEmpty():
    	print("Queue_Empty")
    else:
    	front = (front +1) %len(cQ)
        return cQ[front]

cQ_SIZE = 3
cQ =[0]*cQ_SIZE

front = rear = 0

enQueue('A')
enQueue('B')
enQueue('C')
print(deQueue())
print(deQueue())
print(deQueue())

### 간단형

def isEmpty():
	return len(queue) == 0
    
def isFull():
	return(rear+1) %len(cQ) ==front
    
def enQueue(item):
	queue.append(item)
        
def deQueue():
    if isEmpty():
    	print("Queue_Empty")
    else:
    	return queue.pop(0)
def Qpeek():
	if isEmpty():
		print("Queue_Empty")
    else:
    	retrun queue[0]
     
queue =[]

enQueue('A')
enQueue('B')
enQueue('C')
print(deQueue())
print(deQueue())
print(deQueue())


### 연결Queue

enQueue(item) 큐의 뒤쪽 rear 다음)에 원소를 삽입하는 연산 def enQueue(item) :
    global front, rear
    new Node = Node(item)

    if isEmpty() : 
         front = newNode
    else :
        rear.next = newNode
    rear = newNode
deQueue() 큐의 앞쪽(front)에서 원소를 삭제하고 반환하는 연산 def deQueue() :
    global front, rear
    if isEmpty() :
        print("Queue_Empty")
        return None
    
    item = front.item
    front = front.next
    if isEmpty():
        rear = None
    return item
createQueue() 공백 상태의 큐를 생성하는 연산 포인트만 생성 
fornt = None
rear = None
isEmpty() 큐가 공백상태인지를 확인하는 연산 def isEmpty():
    return front ==rear

### 파이썬 연결Q

class Node:
	def __init__(self, itme, n=Node):
    	self.item =item
        self.next = n
        
def enQueue(item):
	flobal frontrear
    newNode = Node(item)
    if front ==None :
    	front = newNode
    else:
    	rear.next = newNode
    rear = newNode


def isEmpty():
	return front ==None

def deQueue():
	gloval front, rear
    if isEmpty():
    	print("Queue_Empty")
        return None
    
    item = front.item
    front = front.next
    if front == None:
    	rear = None
    return item

def Qpeek():
	return front.item
    
def printQ():
	f = front
    s = ""
    while f:
    	s += f.item + ""
        f = f.next
    return s
    
front = None
rear = None

enQueue('A')
enQueue('B')
enQueue('C')
printQ()
print(deQueue())
print(deQueue())
print(deQueue())

###신기한거

queue.Queue(maxsize) 선입선출 쿠 객체를 생성  
queue.LifoQueue(maxsize) 스택개념의 후입 선출 큐객체 생성  
queue.PriorityQueue(maxsize) 우선순위 큐 객체를 생성, 입력되는 아이템의 형식은 순위 아이템의 튜플로 입력되며 , 우선순위는 숫자가 작을 수록 높은 순위를 가짐  
qsize() 큐객체에 입력된 아이템의 개수를 반환  
put(item[, block[, timeout]]) 큐 객체에 아이템을 입력  
get([block[, timeout]]) 생성된 큐 객체 특성에 맞추어 아이템 1개를 반환  
emnpty() 큐객체가 비어있으면 True 리턴  
full() 큐객체가 꽉차있으면 True 리턴  
import queue

q = queue.Queue()
q.put('A')
q.put('B')
q.put('C')

while not q.empty():
	print(q.get())

'+++++SW 일일 공부+++++ > SW Expert Aademy' 카테고리의 다른 글

링크드 리스트  (0) 2020.05.21
SW 분할 정복  (0) 2020.04.19
SW 백트래킹 미로찾기  (0) 2020.04.19
SW 계산방법  (0) 2020.04.19
트리구조의 모든 집합 구하기 시프트 활용  (0) 2020.04.09
블로그 이미지

Or71nH

,
def Power(Base, Exponent):
	if Exponent == 0 or Base == 0 :
    	return 1
    if Exponent % 2 == 0 :
    	NewBase = Power(Base, Exponent/2)
        return NewBase * NewBase
    else:
    	NewBase = Power(Base, (Exponent-1)/2)
        return (NewBase * NewBase) * Base
        

### 퀵 정렬

def quickSort(a, begin, end):
	if begin < end:
    	p = partition(a , begin, end)
        quickSort(a, begin, p-1)
        quickSort(a, p+1, end)

### 피봇 알고리즘

def partition (a, begin, end) :
	pivot = (begin + end) //2
    L = begin
    R = end
    while L < R :
    	while(a[L]<a[pivot] and L<R) : L += 1
        while(a[R]>=a[pivot] and L<R) : R -= 1
        if L < R :
    	    if L == pivot : pivot = R
        	a[L], a[R] = a[R], a[L]
     a[pivot], a[R] = a[R], a[pivot]
     return R
     

 

'+++++SW 일일 공부+++++ > SW Expert Aademy' 카테고리의 다른 글

링크드 리스트  (0) 2020.05.21
Queue 에대하여  (0) 2020.04.22
SW 백트래킹 미로찾기  (0) 2020.04.19
SW 계산방법  (0) 2020.04.19
트리구조의 모든 집합 구하기 시프트 활용  (0) 2020.04.09
블로그 이미지

Or71nH

,
def checknode (v) : #node
	if promising(v):
		if there is a solution at v :
        	write the solution
        else :
        	for u in each child of v :
            	checknode(u)

power Set 

어떤 집합의 공집합과 자기자신을 포함한 모든 부분집합

구하고자 하는 어떤 집합의 원소 개수가 n 일 경우 부분집합의 개수는 2 ^n 이나옴

 

### 백트래킹 방법

def backtrack(a, k, input) :
	global MAXCANDUDATES
    c = [0]*MAXCANDIDATES
    
    if k = input :
    	process_solution(a, k)
    else:
    	k+=1
        ncandidates = construct_candidates(a, k, input, c)
        for i in range(ncandidates):
        	a[k] = c[i]
            backtrack(a,k,input)

def construck_candidates(a, k, input, c):
	c[0] = True
    c[1] = False
    return 2
    
MAXCANDIDATES = 100
NMAX = 100
a = [0] * NMAX
backtrack(a, 0, 3)

### 순열백트래킹

def backtrack(a, k, input) :
	global MAXCANDUDATES
    c = [0]*MAXCANDIDATES
    
    if k = input :
    	for i in range(1,k+1):
        	print(a[i], end=" ")
        print()
    else:
    	k+=1
        ncandidates = construct_candidates(a, k, input, c)
        for i in range(ncandidates):
        	a[k] = c[i]
            backtrack(a,k,input)

def construck_candidates(a, k, input, c):
	in_perm = [False]*NMAX
    
    for i in range(1,k):
    	in_perm[a[i]] = True
        
    ncandidates = 0 
    for i in range(1, input+1):
    	if in_perm[i] == False:
        	c[ncandidates] = i
            ncandidates += 1
        return ncandidates

 

'+++++SW 일일 공부+++++ > SW Expert Aademy' 카테고리의 다른 글

Queue 에대하여  (0) 2020.04.22
SW 분할 정복  (0) 2020.04.19
SW 계산방법  (0) 2020.04.19
트리구조의 모든 집합 구하기 시프트 활용  (0) 2020.04.09
stack  (0) 2020.03.26
블로그 이미지

Or71nH

,

###단축키

icp(in-coming priority)    
isp(in-stack priority)    
if (icp > isp) push()
else pop()
   
eval() 위의 수식을 제공함  

### 정보

중위표기식 후위표기식

 

1단계 ((A*B)-(C/D))

2단계 ((AB)*(CD)/)-

3단계 AB*CD/-

 

이렇게 순서를정해주는 식을 만들 수 있다

'+++++SW 일일 공부+++++ > SW Expert Aademy' 카테고리의 다른 글

SW 분할 정복  (0) 2020.04.19
SW 백트래킹 미로찾기  (0) 2020.04.19
트리구조의 모든 집합 구하기 시프트 활용  (0) 2020.04.09
stack  (0) 2020.03.26
객체지향  (0) 2020.02.11
블로그 이미지

Or71nH

,