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

###단축키

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

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

###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

### 원형 Queue

### 원형큐

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

### 파이썬 연결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())

###신기한거

import queue

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

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

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
     

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

###단축키

### 정보

중위표기식 후위표기식

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

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

3단계 AB*CD/-

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