数据结构基础部分（一）

数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。
简而言之，数据结构就是设计数据以何种方式组织并存储在计算机中。
比如： 列表、集合与字典都是一种数据结构

栈

# -*- coding: utf-8 -*-

class Stack:
	def __init__(self):
		self.stack = []
	def push(self,element):
		self.stack.append(element)
	def pop(self):
		return self.stack.pop()
	#
	def get_top(self):
		if len(self.stack) > 0:
			return self.stack[-1]
		else:
			return None
	def is_empty(self):
		return len(self.stack) == 0

# stack = Stack()
# stack.push(1)
# stack.push(2)
# stack.push(3)
# print(stack.pop)   # 证明后进先出问题

def brace_match(s):
	match = {"}":"{", "]":"[", ")":"("}
	stack = Stack()
	for ch in s:
		if ch in {"(", "[", "{"}:
			stack.push(ch)
		else:  # ch in {"}", "]", ")"}
			if stack.is_empty():  # 判断栈是不是空
				return False
			elif stack.get_top() == match[ch]:  # 栈顶的元素是否和要找的元素匹配
				stack.pop()
			else: # stack.get_top() != match[ch] # 如果栈顶位置和其不匹配
				return False
	# 栈空了
	if stack.is_empty():
		return True
	else: # 栈还有值
		return False
print(brace_match(("[{()}(){()}[]({}){}]")))
print(brace_match("[{]"))

队列

# -*- coding: utf-8 -*-
class Queue:
	def __init__(self, size):
		self.queue = [0 for _ in range(size)] # 创建好一个大小为100的队列
		self.size = size
		self.rear = 0   # 队尾指针
		self.front = 0  # 队首指针
	def push(self, element):  # 进栈
		if not self.is_filled():
			self.rear = (self.rear+1) % self.size
			self.queue[self.rear] = element
		else:
			raise IndexError("Queue is filled")
	def pop(self):  # 出栈
		if not self.is_empty():
			self.front = (self.front + 1) % self.size
			return self.queue[self.front]
		else:
			raise IndexError("Queue is empty.")

	# 判断队空
	def is_empty(self):
		return self.rear == self.front
	# 判断队满
	def is_filled(self):
		return (self.rear + 1) % self.size == self.front

# 测试
q = Queue(5)
for i in range(4):
	q.push(i)
print(q.pop())
q.push(4)

# -*- coding: utf-8 -*-
maze = [
	[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
	[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
	[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
	[1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
	[1, 0, 1, 1, 1, 0, 0, 0, 0, 1],
	[1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
	[1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
	[1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
	[1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
	[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]

dirs = [
	lambda x,y: (x+1, y),
	lambda x,y: (x-1, y),
	lambda x,y: (x, y-1),
	lambda x,y: (x, y+1)
]

def maze_path(x1,y1,x2,y2):
	stack = []
	stack.append((x1,y1))
	while(len(stack)>0):
		curNode = stack[-1] # 当前的节点
		if curNode[0] == x2  and  curNode[1] == y2:
			#走到终点
			for p in stack:
				print(p)
			return True
		# x,y 四个方向 x-1,y; x+1,y; x,y-1; x,y-1; x,y+1
		for dir in dirs:
			nextNode = dir(curNode[0], curNode[1])
			# 如果下一个节点能走
			if maze[nextNode[0]][nextNode[1]] == 0:
				stack.append(nextNode)
				maze[nextNode[0]][nextNode[1]] = 2 # 2 表示为已经走过
				break
		else:
			maze[nextNode[0]][nextNode[1]] = 2
			stack.pop()
	else:
		print("没有路")
		return False

maze_path(1, 1, 8, 8)

链表

# -*- coding: utf-8 -*-
class Node:
	def __init__(self, item):
		self.item = item
		self.next = None

# 简单创建链表
# a = Node(1)
# b = Node(2)
# c = Node(3)
# a.next = b
# b.next = c
#
# print(a.next.item)


def create_linklist_head(li):
	head = Node(li[0])
	for element in li[1:]:
		node = Node(element)
		node.next = head
		head = node
	return head

def creat_linklist_tail(li):
	head = Node(li[0])
	tail = head
	for element in li[1:]:
		node = Node(element)
		tail.next = node
		tail = node
	return head


def print_linklist(lk):
	while lk:
		print(lk.item, end=",")
		lk = lk.next

lk = create_linklist_head([1, 2, 3])
print_linklist(lk)

lk = creat_linklist_tail([1, 2, 3, 6, 8])
print_linklist(lk)

贪心算法

goods = [(60, 10),(100, 20),(120, 30)]  # 每个商品元组表示(价格, 重量)
goods.sort(key=lambda x: x[0]/x[1], reverse=True)

def fractional_backpack(goods, w):
    m = [0 for _ in range(len(goods))]
    total_v = 0
    for i, (prize, weight) in enumerate(goods):
        if w >= weight:
            total_v += prize
            w -= weight
        else:
            m[i] = w / weight
            total_v += m[i] * prize
            w = 0
            break
    return total_v, m

print(fractional_backpack(goods, 50))

(240.0, [0, 0, 0.6666666666666666])

from functools import cmp_to_key

li = [32, 94, 128, 1286, 6, 71]

def xy_cmp(x, y):
    if x+y < y+x:
        return 1
    elif x+y > y+x:
        return -1
    else:
        return 0

def number_join(li):
    li = list(map(str, li))


    li.sort(key=cmp_to_key(xy_cmp))
    return "".join(li)

print(number_join(li))

94716321286128