数据结构和算法

数据结构和算法

算法

• 算法衡量标准 最坏时间复杂度
• 大O记法

数据结构

顺序表

• 内存中连续存储，需占用大量内存，每次插入和删除都需要将其他元素顺序移动。
• 比如python基本数据类型list

链表

• 分单向链表，双向链表，单向循环链表。
• 内存中分散存储，每个节点由元素和链接组成。
• 常见单向链表操作，如下

# 创建节点
class SingleNode(object):
    def __init__(self, elem):
        self.elem = elem
        self.next = None


# 链表操作
class SingleList(object):
    def __init__(self, node=None):
        self.head = node

    # 链表是否为空
    def empty(self):
        return self.head == None

    # 链表长度
    def length(self):
        count = 0
        cur = self.head
        while cur != None
            count += 1
            cur = cur.next
        return count

    # 遍历链表
    def travel(self):
       cur = self.head
       while cur != None:
           print(cur.elem)
           cur = cur.next

    # 头部添加元素
    def add(self, elem):
        node = SingleNode(elem)
        node.next = self.head
        self.head = node

    # 尾部添加元素
    def append(self, elem):
        node = SingleNode(elem)
        if self.empty():
            self.head = node
            return
        else:
            cur = self.head
            while cur.next != None:
                cur = cur.next
            cur.next = node
    
    # 指定位置插入元素
    def insertelem(self, posi, elem):
        node = SingleNode(elem)
        index = 0
        pre = self.head
        while True:
            # 要插入位置posi的前一个位置posi-1
            if index == posi-1:
                break
            pre = pre.next
            index += 1
        node.next = pre.next
        pre.next = node

堆栈

class Stack(object):
    """栈"""
    def __init__(self):
         self.items = []

    def is_empty(self):
        """判断是否为空"""
        return self.items == []

    def push(self, item):
        """加入元素"""
        self.items.append(item)

    def pop(self):
        """弹出元素"""
        return self.items.pop()

    def peek(self):
        """返回栈顶元素"""
        return self.items[len(self.items)-1]

    def size(self):
        """返回栈的大小"""
        return len(self.items)

队列

class Queue(object):
    """队列"""
    def __init__(self):
        self.items = []

    def is_empty(self):
        return self.items == []

    def enqueue(self, item):
        """进队列"""
        self.items.insert(0,item)

    def dequeue(self):
        """出队列"""
        return self.items.pop()

    def size(self):
        """返回大小"""
        return len(self.items)

搜索之二分查找法

• 二分查找的前提，有序表

# 非递归实现
def binaryFind(alist, item):
    while True:
        if len(alist) == 0:
            return False

        index = len(alist) // 2
        mid = alist[index]
        if item == mid:
            return True
        elif item < mid:
            alist = alist[:index]
        else:
            alist = alist[index+1:]
# 递归实现
def binaryFind(alist, item):
    if len(alist) == 0:
        return False
    index = len(alist) // 2
    if item == alist[index]:
        return True
    elif item < alist[index]:
        return binaryFind(alist[:index], item)
    else:
        return binaryFind(alist[index+1:], item)

Golang 版本

• 二分查找

// 非递归
package main

import "fmt"

func main() {
	a := find([]int{2, 5, 7, 9, 10}, 99)
	fmt.Println(a)
}

func find(list []int, item int) bool {
	for {
		if len(list) <= 0 {
			return false
		}

		index := len(list) / 2
		
		if list[index] == item {
			return true
		} else if list[index] > item {
			list = list[:index]
		} else {
			list = list[index+1:]
		}
	}
}


// 递归
package main

import "fmt"

func main() {
	a := find([]int{2, 5, 7, 9, 10}, 99)
	fmt.Println(a)
}

func find(list []int, item int) bool {
	if len(list) <= 0 {
		return false
	}

	index := len(list) / 2

	if list[index] == item {
		return true
	} else if list[index] > item {
		return find(list[:index], item)
	} else {
		return find(list[index+1:], item)
	}
}