排序算法 python手搓

快排

def quick_sort(arr):
    """快速排序"""
    if len(arr) < 2:
        return arr
    # 选取基准，随便选哪个都可以，选中间的便于理解
    mid = arr[0]
    # 定义基准值左右两个数列
    left, right = [], []
    # 从原始数组中移除基准值
    arr.remove(mid)
    for item in arr:
        # 大于基准值放右边
        if item >= mid:
            right.append(item)
        else:
            # 小于基准值放左边
            left.append(item)
    # 使用迭代进行比较
    return quick_sort(left) + [mid] + quick_sort(right)

冒泡

def bubbleSort(arr):
    """冒泡排序"""
    for i in range(1, len(arr)):
        for j in range(0, len(arr)-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

归并

先将其都分为长度为2的，然后排序

#归并排序
def mergeSort(arr):
    import math
    if(len(arr)<2):
        return arr
    middle = math.floor(len(arr)/2)
    left, right = arr[0:middle], arr[middle:]
    return merge(mergeSort(left), mergeSort(right))
def merge(left,right):
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0));
        else:
            result.append(right.pop(0));
    while left:
        result.append(left.pop(0));
    while right:
        result.append(right.pop(0));
    return result

堆排序

#堆排序
def buildMaxHeap(arr):
    import math
    for i in range(math.floor(len(arr)/2),-1,-1):
        heapify(arr,i)
def heapify(arr, i):
    left = 2*i+1
    right = 2*i+2
    largest = i
    if left < arrLen and arr[left] > arr[largest]:
        largest = left
    if right < arrLen and arr[right] > arr[largest]:
        largest = right
    if largest != i:
        swap(arr, i, largest)
        heapify(arr, largest)
def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]
def heapSort(arr):
    global arrLen
    arrLen = len(arr)
    buildMaxHeap(arr)
    for i in range(len(arr)-1,0,-1):
        swap(arr,0,i)
        arrLen -=1
        heapify(arr, 0)
    return arr

插入排序

比现在的大，就和后移一位，直到找到比他小的，停下插入当前的

#插入排序
def insertionSort(arr):
    for i in range(len(arr)):
        preIndex = i-1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex+1] = arr[preIndex]
            preIndex-=1
        arr[preIndex+1] = current
    return arr

生产者消费者模型

public class Producer implements Runnable {
    private volatile boolean isRunning = true;
    private BlockingQueue<Integer> queue;                        // 内存缓冲区
    private static AtomicInteger count = new AtomicInteger();    // 总数，原子操作
    private static final int SLEEPTIME = 1000;
    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        int data;
        Random r = new Random();

        System.out.println("start producer id = " + Thread.currentThread().getId());
        try {
            while (isRunning) {
                // 模拟延迟
                Thread.sleep(r.nextInt(SLEEPTIME));

                // 往阻塞队列中添加数据
                data = count.incrementAndGet();               	// 构造任务数据
                System.out.println("producer " + Thread.currentThread().getId() + " create data：" + data
                        + ", size：" + queue.size());
                if (!queue.offer(data, 2, TimeUnit.SECONDS)) {
                    System.err.println("failed to put data：" + data);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupted();
        }
    }
    public void stop() {
        isRunning = false;
    }
}
//消费者
public class Consumer implements Runnable{
    private final BlockingQueue blockingQueue;

    public Consumer(BlockingQueue blockingQueue) {
        this.blockingQueue = blockingQueue;
    }
    @Override
    public void run() {
        while (true){
            try {
                System.out.println(blockingQueue.size());
                System.out.println("消费："+blockingQueue.take());
                Thread.sleep(2000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}
public static void main(String[] args){
        BlockingQueue blockingQueue = new LinkedBlockingQueue(5);
        Producer p = new Producer(blockingQueue);
        Consumer c = new Consumer(blockingQueue);
        Thread tp = new Thread(p);
        Thread tc= new Thread(c);
        tp.start();
        tc.start();
    }

二叉树遍历

// 前序遍历
    public static void preorder(TreeNode treeNode) {
        if (treeNode == null) return;
        System.out.print(treeNode.data + " ");
        preorder(treeNode.left);
        preorder(treeNode.right);
    }
    // 中序遍历
    public static void inorder(TreeNode treeNode) {
        if (treeNode == null) return;
        inorder(treeNode.left);
        System.out.print(treeNode.data + " ");
        inorder(treeNode.right);
    }
    // 后序遍历
    public static void postorder(TreeNode treeNode) {
        if (treeNode == null) return;
        postorder(treeNode.left);
        postorder(treeNode.right);
        System.out.print(treeNode.data + " ");
    }
    //广度优先
    public void BroadFirstSearch(TreeNode nodeHead){
        if (nodeHead==null)
            return;
        Queue<TreeNode>myQueue=new LinkedList<>();
        myQueue.add(nodeHead);
        while (!myQueue.isEmpty()){
            TreeNode treeNode=myQueue.poll();
            System.out.print(treeNode.data+" ");
            if (treeNode.left!=null){
                myQueue.add(treeNode.left);
            }
            if (treeNode.right!=null){
                myQueue.add(treeNode.right);
            }
        }
    }
    //深度优先，先进后出，先右边
    public void depthFirstSearch(TreeNode nodeHead){
        if (nodeHead==null)
            return;
        Stack<TreeNode>myStack=new Stack<>();
        myStack.add(nodeHead);
        while (!myStack.isEmpty()){
            TreeNode node=myStack.pop();
            System.out.print(node.data+" ");
            if (node.right!=null){
                myStack.push(node.right);
            }
            if (null!=node.left){
                myStack.push(node.left);
            }
        }
    }

// 前序遍历的非递归解法
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> lists = new ArrayList<>();
        if (root == null) return lists;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        TreeNode temp = null;
        while (!stack.isEmpty()) {
            temp = stack.pop();
            lists.add(temp.data);
            // 这里注意，要先压入右子节点，再压入左节点
            if (temp.right != null) {
                stack.push(temp.right);
            }
            if (temp.left != null) {
                stack.push(temp.left);
            }
        }
        return lists;
    }
    // 二叉树非递归的中序遍历
    public List<Integer> inorderTraversal(TreeNode root) {
        if (root == null) {
            return null;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = root, temp = null;
        List<Integer> lists = new ArrayList<>();
        // 判断条件：所有栈为空，且节点指向为空，即所有节点已经完成遍历
        while (!stack.isEmpty() || node != null) {
            // 向左搜索，寻找最左的节点，即中序遍历的第一个节点
            while (node != null) {
                stack.add(node);
                node = node.left;
            }
            // 对每一个节点进行判断
            if (!stack.empty()) {
                // 获取当前节点
                temp = stack.pop();
                // 遍历该节点
                lists.add(temp.data);
                // 如果该节点为内部节点，则按中序遍历的顺序，遍历其右子节点
                node = temp.right;
            }
        }
        return lists;
    }
    //后序非递归
    public List<Integer> postorderTraversal_(TreeNode root) {
        LinkedList<Integer> lists = new LinkedList<>();
        if (root == null) return lists;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        TreeNode temp = null;
        while (!stack.isEmpty()) {
            temp = stack.pop();
            lists.addFirst(temp.data);
            if (temp.left != null) {
                stack.push(temp.left);
            }
            if (temp.right != null) {
                stack.push(temp.right);
            }
        }
        return lists;
    }

#斐波那契数列
public int Fibonacci(int n) {
	// 正确性判断
	if (0 == n || 1 == n) {
		return n;
	}
	int nums1 = 0, nums2 = 1;
	int res = 0;
	for (int i = 2; i <= n; i++) {
		res = nums1 + nums2;
		nums1 = nums2;
		nums2 = res;
	}
	return res;
}

/**
 * 二分查找递归实现。
 *
 * @param srcArray 有序数组
 * @param start    数组低地址下标
 * @param end      数组高地址下标
 * @param key      查找元素
 * @return 查找元素不存在返回-1
 */
public static int binSearch(int srcArray[], int start, int end, int key) {
	int mid = (end - start) / 2 + start;
	if (srcArray[mid] == key) {
		return mid;
	}
	if (start >= end) {
		return -1;
	} else if (key > srcArray[mid]) {
		return binSearch(srcArray, mid + 1, end, key);
	} else if (key < srcArray[mid]) {
		return binSearch(srcArray, start, mid - 1, key);
	}
	return -1;
}