Merge pull request #2 from wangzheng0822/master

merged by upstream

c-cpp/05_array/array.c

@@ -0,0 +1,95 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct array {
+	int size;
+	int used;
+	int *arr;
+};
+
+void dump(struct array *array)
+{
+	int idx;
+
+	for (idx = 0; idx < array->used; idx++)
+		printf("[%02d]: %08d\n", idx, array->arr[idx]);
+}
+
+void alloc(struct array *array)
+{
+	array->arr = (int *)malloc(array->size * sizeof(int));
+}
+
+int insert(struct array *array, int elem)
+{
+	int idx;
+	if (array->used >= array->size)
+		return -1;
+
+	for (idx = 0; idx < array->used; idx++) {
+		if (array->arr[idx] > elem)
+			break;
+	}
+
+	if (idx < array->used)
+		memmove(&array->arr[array->used], &array->arr[idx],
+			(array->used - idx) * sizeof(int));
+
+	array->arr[idx] = elem;
+	array->used++;
+	return idx;
+}
+
+int delete(struct array *array, int idx)
+{
+	if (idx < 0 || idx >= array->used)
+		return -1;
+
+	memmove(&array->arr[idx], &array->arr[idx+1],
+		(array->used - idx) * sizeof(int));
+	array->used--;
+	return 0;
+}
+
+int search(struct array *array, int elem)
+{
+	int idx;
+
+	for (idx = 0; idx < array->used; idx++) {
+		if (array->arr[idx] == elem)
+			return idx;
+		if (array->arr[idx] > elem)
+			return -1;
+	}
+
+	return -1;
+}
+
+int main()
+{
+	int idx;
+	struct array ten_int = {10, 0, NULL};
+
+	alloc(&ten_int);
+	if (!ten_int.arr)
+		return -1;
+	insert(&ten_int, 1);
+	insert(&ten_int, 3);
+	insert(&ten_int, 2);
+	printf("=== insert 1, 3, 2\n");
+	dump(&ten_int);
+
+	idx = search(&ten_int, 2);
+	printf("2 is at position %d\n", idx);
+	idx = search(&ten_int, 9);
+	printf("9 is at position %d\n", idx);
+
+	printf("=== delete [6] element \n");
+	delete(&ten_int, 6);
+	dump(&ten_int);
+	printf("=== delete [0] element \n");
+	delete(&ten_int, 0);
+	dump(&ten_int);
+	return 0;
+}

c-cpp/06_linkedlist/list_isPalindrome/LinkList.cpp

@@ -0,0 +1,148 @@
+#include "LinkList.h"
+
+void CreateListHead(LinkList *&L,ElemType a[],int n)
+{
+	int i;
+	LinkList *s;
+	L = (LinkList *)malloc(sizeof(LinkList));
+	L->next = NULL;
+	for(i = 0;i < n;i++)
+	{
+		s=(LinkList*)malloc(sizeof(LinkList));
+		s->data = a[i];
+		s->next = L->next;
+		L->next = s;
+	}
+}
+void CreateListTail(LinkList *&L,ElemType a[],int n)
+{
+	int i;
+	LinkList * s,* r;
+	L = (LinkList *)malloc(sizeof(LinkList));
+	r = L;
+	for(i = 0;i < n;i++)
+	{
+		s = (LinkList *)malloc(sizeof(LinkList));
+		s->data = a[i];
+		r->next = s;
+		r = s;
+	}
+	r->next = NULL; 
+}
+void InitList(LinkList *&L)
+{
+	L=(LinkList *)malloc(sizeof(LinkList));
+	L->next = NULL;
+}
+void DestroyList(LinkList *&L)
+{
+	LinkList * pre = L,*p = L->next;
+	while(p!=NULL)
+	{
+		free(pre);
+		pre = p;
+		p = L->next;
+	}
+	free(pre);
+}
+bool ListEmpty(LinkList *L)
+{
+	return(L->next==NULL); 
+}
+int ListLength(LinkList *L)
+{
+	int n = 0;
+	LinkList * p = L;
+	while(p->next!=NULL)
+	{
+		n++;
+		p=p->next;
+	}
+	return(n);
+}
+void ShowList(LinkList *L)
+{
+	LinkList * p = L->next;//Ö¸Ïò¿ªÊ¼½Úµã
+	while(p!=NULL)
+	{
+		printf(" %c ",p->data);
+		p = p->next; 
+	} 
+	printf("\n");
+}
+bool GetListElem(LinkList *L,int i,ElemType &e)
+{
+	int j = 0;
+	LinkList *p = L;
+	while(j<i&&p!=NULL)
+	{
+		j++;
+		p=p->next;
+	}
+	if(p==NULL)
+		return false;
+	else
+	{
+		e=p->data;
+		return true;
+	}
+}
+int LocateElem(LinkList*L,ElemType e)
+{
+	int i=1;
+	LinkList *p = L->next;
+	while(p!=NULL&&p->data!=e){
+		p=p->next;
+		i++;
+	}
+	if(p==NULL)
+	{
+		return(0);
+	}
+	else
+		return(i);
+}
+bool ListInsert(LinkList *&L,int i,ElemType e)
+{
+	int j=0;
+	LinkList *p =L,*s;
+	while(j<i-1&&p!=NULL)
+	{
+		j++;
+		p=p->next;
+	}
+	if(p==NULL)
+	{
+		return false;
+	}
+	else
+	{
+		s= (LinkList*)malloc(sizeof(LinkList));
+		s->data = e;
+		s->next = p->next;
+		p->next = s;
+		return true;
+	}
+}
+bool ListDelete(LinkList *&L,int i,ElemType &e)
+{
+	int j=0;
+	LinkList * p =L,*q;
+	while(j<i-1&&p!=NULL)
+	{
+		j++;
+		p=p->next;
+	}
+	if(p==NULL)
+		return false;
+	else
+	{
+		q=p->next;
+		if(q==NULL)
+			return false;
+		e=q->data;
+		p->next=q->next;
+		free(q);
+		return true;
+	}
+}

c-cpp/06_linkedlist/list_isPalindrome/LinkList.h

@@ -0,0 +1,24 @@
+#ifndef LINKLIST_H
+#define LINKLIST_H
+
+#include <stdlib.h>
+#include <stdio.h>
+typedef char ElemType;
+typedef struct LNode 
+{
+	ElemType data;
+	struct LNode*next;
+}LinkList;
+
+void CreateListHead(LinkList *&L,ElemType a[],int n);
+void CreateListTail(LinkList *&L,ElemType a[],int n);
+void InitList(LinkList *&L);
+void DestroyList(LinkList *&L);
+bool ListEmpty(LinkList *L);
+int ListLength(LinkList *L);
+void ShowList(LinkList *L);
+bool GetListElem(LinkList *L,int i,ElemType &e);
+int LocateElem(LinkList*L,ElemType e);
+bool ListInsert(LinkList *&L,int i,ElemType e);
+bool ListDelete(LinkList *&L,int i,ElemType &e);
+#endif

c-cpp/06_linkedlist/list_isPalindrome/main.cpp

@@ -0,0 +1,40 @@
+#include"LinkList.h"
+char array1[]= {'a','b','c','b','a'};
+bool isPalindrome(LinkList * list,int length);
+int main()
+{
+	LinkList * list;
+
+	int length = sizeof(array1)/sizeof(array1[0]);
+	InitList(list);
+	CreateListTail(list,array1,length);//用尾插法创建一个单链表
+	if(isPalindrome(list,length))
+		printf("isPalindrome\n");
+	else
+		printf("isNotPalindrome\n");
+	return 0;
+}
+bool isPalindrome(LinkList * list,int length)
+{
+	int i;
+	char buff1[length],buff2[length];
+	ElemType e;
+	for(i=1; i<=length; i++) 
+	{
+		GetListElem(list,i,e);//遍历获取链表元素并放入数组中 
+		buff1[i-1]=e;//正向数组 
+		buff2[length-i]=e;//反向数组 
+	}
+	i=0;
+	while(i<=length) {
+		if(buff1[i]==buff2[i])//比较 
+		{
+			i++; 
+		} 
+		else 
+		{
+			return false;
+		}
+	}
+	return true;
+}

c-cpp/06_linkedlist/single_list.c

@@ -0,0 +1,176 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+struct single_list {
+	struct single_list *next;
+	int val;
+};
+
+struct single_list_head {
+	struct single_list *head;
+};
+
+bool is_empty(struct single_list_head *head)
+{
+	return head->head == NULL;
+}
+
+void dump(struct single_list_head *head)
+{
+	struct single_list *tmp = head->head;
+	int idx = 0;
+
+	while (tmp) {
+		printf("[%02d]: %08d\n", idx++, tmp->val);
+		tmp = tmp->next;
+	}
+}
+
+void insert(struct single_list **prev, struct single_list *elem)
+{
+	if (!prev)
+		return;
+
+	if (*prev)
+		elem->next = *prev;
+	*prev = elem;
+}
+
+void insert_head(struct single_list_head *head, struct single_list *elem)
+{
+	insert(&head->head, elem);
+}
+
+struct single_list* delete(struct single_list **prev)
+{
+	struct single_list *tmp;
+
+	if (!prev)
+		return NULL;
+
+	tmp = *prev;
+	*prev = (*prev)->next;
+	tmp->next = NULL;
+
+	return tmp;
+}
+
+struct single_list* delete_head(struct single_list_head* head)
+{
+	return delete(&head->head);
+}
+
+struct single_list** search(struct single_list_head* head, int target)
+{
+	struct single_list **prev, *tmp;
+
+	for (prev = &head->head, tmp = *prev;
+	     tmp && (tmp->val < target);
+	     prev = &tmp->next, tmp = *prev)
+		;
+
+	return prev;
+}
+
+void reverse(struct single_list_head* head)
+{
+	struct single_list_head tmp;
+	struct single_list *elem;
+
+	while (!is_empty(head)) {
+		elem = delete_head(head);
+		insert_head(&tmp, elem);
+	}
+
+	head->head = tmp.head;
+}
+
+bool is_cyclic(struct single_list_head* head)
+{
+	struct single_list *s1, *s2;
+
+	s1 = s2 = head->head;
+
+	while(s1 && s2) {
+		s1 = s1->next;
+		s2 = s2->next ? s2->next->next:s2->next;
+
+		if (s1 == s2)
+			return true;
+	}
+	return false;
+}
+
+struct single_list* middle(struct single_list_head* head)
+{
+	struct single_list *s1, *s2;
+	struct single_list pseudo_head;
+
+	pseudo_head.next = head->head;
+	s1 = s2 = &pseudo_head;
+
+	while (true) {
+		if (!s2 || !s2->next)
+			return s1;
+		s1 = s1->next;
+		s2 = s2->next->next;
+	}
+
+	return NULL;
+}
+
+int main()
+{
+	struct single_list_head head = {NULL};
+	struct single_list lists[10];
+	struct single_list **prev;
+	int idx;
+
+	for (idx = 0; idx < 10; idx++) {
+		lists[idx].val = idx;
+		lists[idx].next = NULL;
+	}
+
+	insert_head(&head, &lists[6]);
+	insert_head(&head, &lists[5]);
+	insert_head(&head, &lists[4]);
+	insert_head(&head, &lists[1]);
+	insert_head(&head, &lists[0]);
+
+	printf("=== insert 0, 1, 4, 5, 6\n");
+	dump(&head);
+
+	prev = search(&head, 2);
+	insert(prev, &lists[2]);
+	printf("=== insert 2\n");
+	dump(&head);
+
+	printf("middle elem is %d\n", middle(&head)->val);
+
+	prev = search(&head, 2);
+	if ((*prev) && ((*prev)->val == 2))
+		printf("The list contains 2\n");
+	else
+		printf("The list not contains 2\n");
+
+	delete(prev);
+	prev = search(&head, 2);
+	printf("After remove 2\n");
+	if ((*prev) && ((*prev)->val == 2))
+		printf("The list contains 2\n");
+	else
+		printf("The list not contains 2\n");
+	dump(&head);
+
+	printf("After reverse \n");
+	reverse(&head);
+	dump(&head);
+
+	printf("middle elem is %d\n", middle(&head)->val);
+
+	lists[0].next = &lists[6];
+	printf("list is%s cyclic\n", is_cyclic(&head)?"":" not");
+
+	return 0;
+}
+

javascript/06_linkedlist/SinglyLinkedList.js

@@ -0,0 +1,94 @@
+/**
+ * 1）单链表的插入、删除、查找操作；
+ * 2）链表中存储的是int类型的数据；
+ */
+class Node {
+  constructor (element) {
+    this.element = element
+    this.next = null
+  }
+}
+
+class LinkedList {
+  constructor () {
+    this.head = new Node('head')
+  }
+  // 根据value查找节点
+  findByValue (item) {
+    let currentNode = this.head
+    while (currentNode !== null && currentNode.element !== item) {
+      currentNode = currentNode.next
+    }
+    console.log(currentNode)
+    return currentNode === null ? -1 : currentNode
+  } 
+  
+  // 根据index查找节点
+  findByIndex (index) {
+    let currentNode = this.head
+    let pos = 0
+    while (currentNode !== null && pos !== index) {
+      currentNode = currentNode.next
+      pos++
+    }
+    console.log(currentNode)
+    return currentNode === null ? -1 : currentNode
+  } 
+  
+  // 指定元素向后插入
+  insert (newElement, element) {
+    const currentNode = this.findByValue(element)
+    if (currentNode === -1) {
+      console.log('未找到插入位置')
+      return
+    }
+    const newNode = new Node(newElement)
+    newNode.next = currentNode.next
+    currentNode.next = newNode
+  } 
+  
+  // 查找前一个
+  findPrev (item) {
+    let currentNode = this.head
+    while (currentNode.next !== null && currentNode.next.element !== item) {
+      currentNode = currentNode.next
+    }
+    if (currentNode.next === null) {
+      return -1
+    }
+    return currentNode
+  } 
+  
+  // 根据值删除
+  remove (item) {
+    const desNode = this.findByValue(item)
+    if (desNode === -1) {
+      console.log('未找到元素')
+      return
+    }
+    const prevNode = this.findPrev(item)
+    prevNode.next = desNode.next
+  } 
+  
+  // 遍历显示所有节点
+  display () {
+    let currentNode = this.head
+    while (currentNode !== null) {
+      console.log(currentNode.element)
+      currentNode = currentNode.next
+    }
+  }
+}
+// Test
+const LList = new LinkedList()
+LList.insert('chen', 'head')
+LList.insert('curry', 'chen')
+LList.insert('sang', 'head')
+LList.insert('zhao', 'head')
+console.log('-------------remove item------------')
+LList.remove('curry', 'chen')
+LList.display()
+console.log('-------------find by item------------')
+LList.findByValue('chen')
+console.log('-------------find by index------------')
+LList.findByIndex(2)

javascript/07_linkedlist/LinkedListAlgo.js

@@ -0,0 +1,221 @@
+/**
+ * 1) 单链表反转
+ * 2) 链表中环的检测
+ * 3) 两个有序的链表合并
+ * 4) 删除链表倒数第n个结点
+ * 5) 求链表的中间结点
+ *
+ */
+class Node {
+    constructor(element) {
+        this.element = element
+        this.next = null
+    }
+}
+
+class LinkedList {
+    constructor() {
+        this.head = new Node('head')
+    }
+    // 根据value查找节点 
+    findByValue(item) {
+        let currentNode = this.head
+        while (currentNode !== null && currentNode.element !== item) {
+            currentNode = currentNode.next
+        }
+        return currentNode === null ? -1 : currentNode
+    }
+    // 根据index查找节点 
+    findByIndex(index) {
+        let currentNode = this.head
+        let pos = 0
+        while (currentNode !== null && pos !== index) {
+            currentNode = currentNode.next
+            pos++
+        }
+        return currentNode === null ? -1 : pos
+    }
+    // 指定元素向后插入
+    insert(newElement, element) {
+        const currentNode = this.findByValue(element)
+        if (currentNode === -1) {
+            console.log('未找到插入位置')
+            return
+        }
+        const newNode = new Node(newElement)
+        newNode.next = currentNode.next
+        currentNode.next = newNode
+    }
+    // 查找前一个
+    findPrev(item) {
+        let currentNode = this.head
+        while (currentNode.next !== null && currentNode.next.element !== item) {
+            currentNode = currentNode.next
+        }
+        if (currentNode.next === null) {
+            return -1
+        }
+        return currentNode
+    }
+    // 根据值删除
+    remove(item) {
+        const desNode = this.findByValue(item)
+        if (desNode === -1) {
+            console.log('未找到元素')
+            return
+        }
+        const prevNode = this.findPrev(item)
+        prevNode.next = desNode.next
+    }
+    // 遍历显示所有节点
+    display() {
+        let currentNode = this.head
+        while (currentNode !== null) {
+            console.log(currentNode.element)
+            currentNode = currentNode.next
+        }
+    }
+
+    // 尾插法 反转单链表
+    reverseList() {
+        const root = new Node('head')
+        let currentNode = this.head.next
+        while (currentNode !== null) {
+            const next = currentNode.next
+            currentNode.next = root.next
+            root.next = currentNode
+            currentNode = next
+        }
+        this.head = root
+    }
+
+    // 自己一开始瞎想的。差距啊
+    reverseList2() {
+        let currentNode = this.head.next
+        let reverseList = new LinkedList()
+        const tempArr = []
+        if (currentNode === null || currentNode.next === null) {
+            console.log('节点数小于3，不反转')
+            return
+        }
+        while (currentNode !== null) {
+            tempArr.push(currentNode)
+            currentNode = currentNode.next
+        }
+        for (let i = tempArr.length - 1; i >= 0; i--) {
+            const key = i === tempArr.length - 1 ? 'head' : tempArr[i + 1].element
+            reverseList.insert(tempArr[i].element, key)
+        }
+        reverseList.display()
+        return reverseList
+    }
+    // 环验证
+    checkCircle() {
+        let fast = this.head.next
+        let slow = this.head
+        while (fast !== null && fast.next !== null) {
+            fast = fast.next.next
+            slow = slow.next
+            if (slow === fast) return true
+        }
+        return false
+    }
+    // 删除倒数第k个节点
+    removeByIndexFromEnd(index) {
+        let pos = 1
+        this.reverseList()
+        let currentNode = this.head.next
+        while (currentNode !== null && pos < index) {
+            currentNode = currentNode.next
+            pos++
+        }
+        if (currentNode === null) {
+            console.log('无法删除最后一个节点或者该节点不存在')
+            return false
+        }
+        this.remove(currentNode.element)
+        this.reverseList()
+    }
+    // 求中间节点
+    findMiddleNode() {
+        let fast = this.head
+        let slow = this.head
+        while (fast.next !== null && fast.next.next !== null) {
+            fast = fast.next.next
+            slow = slow.next
+        }
+        console.log(slow)
+        return slow
+    }
+}
+
+
+const mergeSortedLists = (listA, listB) => {
+    if (!listA) {
+        return listB
+    }
+    if (!listB) {
+        return listA
+    }
+
+    let a = listA
+    let b = listB
+    let resultList = undefined
+    if (a.element < b.element) {
+        resultList = a
+        a = a.next
+    } else {
+        resultList = b
+        b = b.next
+    }
+    let currentNode = resultList
+    while (a !== null && b !== null) {
+        if (a.element < b.element) {
+            currentNode.next = a
+            a = a.next
+        } else {
+            currentNode.next = b
+            b = b.next
+        }
+        currentNode = currentNode.next
+    }
+
+    if (a != null) {
+        currentNode.next = a
+    } else {
+        currentNode.next = b
+    }
+    return resultList
+}
+
+// Test
+const LList = new LinkedList()
+LList.insert('chen', 'head')
+LList.insert('curry', 'chen')
+LList.insert('sang', 'head')
+LList.insert('zhao', 'head')
+console.log('-------------start reverse------------')
+LList.reverseList()
+LList.display()
+console.log('-------------check circle------------')
+console.log(LList.checkCircle())
+console.log('-------------remove the one before last ------------')
+LList.removeByIndexFromEnd(2)
+LList.display()
+
+const sortedList1 = new LinkedList()
+sortedList1.insert(9, 'head')
+sortedList1.insert(8, 'head')
+sortedList1.insert(7, 'head')
+sortedList1.insert(6, 'head')
+const sortedList2 = new LinkedList()
+sortedList2.insert(21, 'head')
+sortedList2.insert(20, 'head')
+sortedList2.insert(19, 'head')
+sortedList2.insert(18, 'head')
+console.log('-------------sort two list ------------')
+let sortedList = mergeSortedLists(sortedList1.head.next, sortedList2.head.next)
+while (sortedList !== null) {
+    console.log(sortedList.element)
+    sortedList = sortedList.next
+}

python/06_linkedlist/singly_linked_list.py

@@ -0,0 +1,139 @@
+"""
+    1) Insertion, deletion and search of singly-linked list;
+    2) Assumes int type for data in list nodes.
+
+    Author: Wenru
+"""
+from typing import Optional
+
+class Node:
+    
+    def __init__(self, data: int, next=None):
+        self.data = data
+        self._next = next
+    
+
+class SinglyLinkedList:
+
+    def __init__(self):
+        self._head = None
+    
+    def find_by_value(self, value: int) -> Optional[Node]:
+        p = self._head
+        while p and p.data != value:
+            p = p._next
+        
+        return p
+
+    def find_by_index(self, index: int) -> Optional[Node]:
+        p = self._head
+        position = 0
+        while p and position != index:
+            p = p._next
+            position += 1
+        
+        return p
+
+    def insert_value_to_head(self, value: int):
+        new_node = Node(value)
+        self.insert_node_to_head(new_node)
+    
+    def insert_node_to_head(self, new_node: Node):
+        if new_node:
+            new_node._next = self._head
+            self._head = new_node
+    
+    def insert_value_after(self, node: Node, value: int):
+        new_node = Node(value)
+        self.insert_node_after(node, new_node)
+    
+    def insert_node_after(self, node: Node, new_node: Node):
+        if not node or not new_node:
+            return
+        new_node._next = node._next
+        node._next = new_node
+
+    def insert_value_before(self, node: Node, value: int):
+        new_node = Node(value)
+        self.insert_node_before(node, new_node)
+
+    def insert_node_before(self, node: Node, new_node: Node):
+        if not self._head or not node or not new_node:
+            return
+        if self._head == node:
+            self.insert_node_to_head(new_node)
+            return
+        current = self._head
+        while current._next and current._next != node:
+            current = current._next
+        if not current._next:   # node is not even in the list
+            return
+        new_node._next = node
+        current._next = new_node
+
+    def delete_by_node(self, node: Node):
+        if not self._head or not node:
+            return
+        if node._next:
+            node.data = node._next.data
+            node._next = node._next._next
+            return
+        # node is the last one or not in the list
+        current = self._head
+        while current and current._next != node:
+            current = current._next
+        if not current:  # node not in the list
+            return 
+        current._next = None
+
+    def delete_by_value(self, value: int):
+        if not self._head or not value:
+            return
+        fake_head = Node(value+1)
+        fake_head._next = self._head
+        prev, current = fake_head, self._head
+        while current:
+            if current.data != value:
+                prev._next = current
+                prev = prev._next
+            current = current._next
+        if prev._next:
+            prev._next = None
+        self._head = fake_head._next  # in case head.data == value
+    
+    def __repr__(self) -> str:
+        nums = []
+        current = self._head
+        while current:
+            nums.append(current.data)
+            current = current._next
+        if len(nums) > 0:
+            return "->".join(str(num) for num in nums)
+        else:
+            return ""
+
+    def print_all(self):
+        current = self._head
+        if current:
+            print(f"{current.data}", end="")
+            current = current._next
+        while current:
+            print(f"->{current.data}", end="")
+            current = current._next
+        print("\n", flush=True)
+
+
+if __name__ == "__main__":
+    l = SinglyLinkedList()
+    for i in range(15):
+        l.insert_value_to_head(i)
+    node9 = l.find_by_value(9)
+    l.insert_value_before(node9, 20)
+    l.insert_value_before(node9, 16)
+    l.insert_value_before(node9, 16)
+    l.delete_by_value(16)
+    node11 = l.find_by_index(3)
+    l.delete_by_node(node11)
+    l.delete_by_node(l._head)
+    l.delete_by_value(13)
+    print(l)

python/07_linkedlist/linked_list_algo.py

@@ -0,0 +1,92 @@
+"""
+    1) Reverse singly-linked list
+    2) Detect cycle in a list
+    3) Merge two sorted lists
+    4) Remove nth node from the end
+    5) Find middle node
+
+    Author: Wenru
+"""
+
+from typing import Optional
+
+
+class Node:
+    
+    def __init__(self, data: int, next=None):
+        self.data = data
+        self._next = next
+
+# Reverse singly-linked list
+# 单链表反转
+# Note that the input is assumed to be a Node, not a linked list.
+def reverse(head: Node) -> Optional[Node]:
+    reversed_head = None
+    current = head
+    while current:
+        reversed_head, reversed_head._next, current = current, reversed_head, current._next
+    return reversed_head
+
+# Detect cycle in a list
+# 检测环
+def has_cycle(head: Node) -> bool:
+    slow, fast = head, head
+    while fast and fast._next:
+        slow = slow._next
+        fast = fast._next._next
+        if slow == fast:
+            return True
+    return False
+
+# Merge two sorted linked list
+# 有序链表合并
+def merge_sorted_list(l1: Node, l2: Node) -> Optional[Node]:
+    if l1 and l2:
+        p1, p2 = l1, l2
+        fake_head = Node(None)
+        current = fake_head
+        while p1 and p2:
+            if p1.data <= p2.data:
+                current._next = p1
+                p1 = p1._next
+            else:
+                current._next = p2
+                p2 = p2._next
+            current = current._next
+        current._next = p1 if p1 else p2
+        return fake_head._next
+    return p1 or p2
+
+# Remove nth node from the end
+# 删除倒数第n个节点。假设n大于0
+def remove_nth_from_end(head: Node, n: int) -> Optional[Node]:
+    fast = head
+    count = 0
+    while fast and count < n:
+        fast = fast._next
+        count += 1
+    if not fast and count < n:  # not that many nodes
+        return head
+    if not fast and count == n:
+        return head._next
+    
+    slow = head
+    while fast._next:
+        fast, slow = fast._next, slow._next
+    slow._next = slow._next._next
+    return head
+
+def find_middle_node(head: Node) -> Optional[Node]:
+    slow, fast = head, head
+    fast = fast._next if fast else None
+    while fast and fast._next:
+        slow, fast = slow._next, fast._next._next
+    return slow
+
+def print_all(head: Node):
+    nums = []
+    current = head
+    while current:
+        nums.append(current.data)
+        current = current._next
+    print("->".join(str(num) for num in nums))