diff --git a/Code/CPP-Code/head/double_link_list.h b/Code/CPP-Code/head/double_link_list.h
new file mode 100644
index 0000000..b6f0957
--- /dev/null
+++ b/Code/CPP-Code/head/double_link_list.h
@@ -0,0 +1,101 @@
+#include <cstdio>
+#include <cstdlib>
+#include "head.h"
+
+// 单链表结点
+class DoubleLinkListNode {
+private:
+    // 数据
+    element_type _data{};
+    // 指针
+    DoubleLinkListNode *_prior, *_next{};
+public:
+    // 设置数据
+    bool SetData(element_type elem);
+
+    // 获取数据
+    element_type GetData() const;
+
+    // 设置prior
+    bool SetPrior(DoubleLinkListNode *prior)
+
+    // 获取prior
+    DoubleLinkList *GetPrior();
+
+    // 设置next
+    bool SetNext(DoubleLinkListNode *next);
+
+    // 获取next
+    DoubleLinkListNode *GetNext();
+
+    // 构造函数
+    DoubleLinkListNode();
+
+    explicit DoubleLinkListNode(element_type elem);
+
+    DoubleLinkListNode(element_type elem, DoubleLinkListNode *next);
+
+    DoubleLinkListNode(element_type elem, DoubleLinkListNode *prior, DoubleLinkListNode *next)
+
+    // 销毁
+    bool Destory();
+};
+
+bool DoubleLinkListNode::SetData(element_type elem) {
+    this._data = elem;
+    return true;
+}
+
+element_type DoubleLinkListNode::GetData() const {
+    return this._data;
+}
+
+bool DoubleLinkListNode::SetPrior(DoubleLinkListNode *prior) {
+    this._prior = prior;
+    return true;
+}
+
+DoubleLinkListNode *DoubleLinkListNode::GetPrior() const {
+    return this._prior;
+}
+
+bool DoubleLinkListNode::SetNext(DoubleLinkListNode *next) {
+    this._next=next;
+    return true;
+}
+
+DoubleLinkListNode *DoubleLinkListNode::GetNext() const {
+    return this._next;
+}
+
+DoubleLinkListNode::DoubleLinkListNode() {
+    this->SetPrior(nullptr);
+    this->SetNext(nullptr);
+    this->SetData(NULL);
+}
+
+DoubleLinkListNode::DoubleLinkListNode(element_type elem) {
+    this->SetPrior(nullptr);
+    this->SetNext(nullptr);
+    this->SetData(elem);
+}
+
+DoubleLinkListNode::DoubleLinkListNode(element_type elem, DoubleLinkListNode *next) {
+    this->SetPrior(nullptr);
+    this->SetNext(next);
+    this->SetData(elem);
+}
+
+DoubleLinkListNode::DoubleLinkListNode(element_type elem, DoubleLinkListNode *prior, DoubleLinkListNode *next) {
+    this->SetPrior(prior);
+    this->SetNext(next);
+    this->SetData(elem);
+}
+
+bool DoubleLinkListNode::Destroy{
+    free(this.GetPrior());
+    free(this.GetNext());
+    this->SetPrior(nullptr);
+    this->SetNext(nullptr);
+    this->SetData(NULL);
+};
\ No newline at end of file
diff --git a/Code/CPP-Code/head/head.h b/Code/CPP-Code/head/head.h
index 2e3e73e..cf10def 100644
--- a/Code/CPP-Code/head/head.h
+++ b/Code/CPP-Code/head/head.h
@@ -1,7 +1,7 @@
 // 初始化最大长度
 #define MAXSIZE 5
 // 定义默认值
-#define DEFAULTDATA '0'
+#define DEFAULTELEM '0'
 // 定义最大值
 //#define INFINITY 32767
 // 定义默认数据类型
diff --git a/Code/CPP-Code/head/link_list.h b/Code/CPP-Code/head/link_list.h
index ff0d44a..38dda47 100644
--- a/Code/CPP-Code/head/link_list.h
+++ b/Code/CPP-Code/head/link_list.h
@@ -5,502 +5,588 @@
 // 单链表结点
 class LinkListNode {
 private:
-	// 数据
-	element_type _data{};
-	// 指针
-	LinkListNode* _next{};
+    // 数据
+    element_type _data{};
+    // 指针
+    LinkListNode *_next{};
 public:
-	// 设置数据
-	bool SetData(element_type data);
-	// 获取数据
-	element_type GetData() const;
-	// 设置next
-	bool SetNext(LinkListNode* next);
-	// 获取next
-	LinkListNode* GetNext();
-	// 构造函数
-	LinkListNode();
-	explicit LinkListNode(element_type data);
-	LinkListNode(element_type data, LinkListNode* next);
-	// 销毁
-	bool Destory();
+    // 设置数据
+    bool SetData(element_type elem);
+
+    // 获取数据
+    element_type GetData() const;
+
+    // 设置next
+    bool SetNext(LinkListNode *next);
+
+    // 获取next
+    LinkListNode *GetNext();
+
+    // 构造函数
+    LinkListNode();
+
+    explicit LinkListNode(element_type elem);
+
+    LinkListNode(element_type elem, LinkListNode *next);
+
+    // 销毁
+    bool Destory();
 };
 
 class LinkList {
 private:
-	// 指针
-	LinkListNode* _next{};
-	// 链表长度
-	int _length{};
-	// 类型，真有头节点，假无头节点
-	bool _type{};
+    // 指针
+    LinkListNode *_next{};
+    // 链表长度
+    int _length{};
+    // 类型，真有头节点，假无头节点
+    bool _type{};
 protected:
-	// 设置链表类型
-	bool SetType(bool type);
+    // 设置链表类型
+    bool SetType(bool type);
+
 public:
-	// 设置next
-	bool SetNext(LinkListNode* next);
-	// 获取next
-	LinkListNode* GetNext();
-	// 长度自加1
-	bool SetLength();
-	// 设置长度
-	bool SetLength(int length);
-	// 获取长度
-	int GetLength() const;
-	// 获取链表类型
-	bool GetType() const;
-	// 构造函数
-	LinkList();
-	// 打印
-	virtual bool Print() = 0;
-	// 判空
-	bool Empty() const;
-	// 插入
-	virtual bool Insert(int index, element_type data) = 0;
-	// 前插入
-	bool PriorInsert(element_type* elem, int start, int length);
-	// 后插入
-	bool NextInsert(element_type* elem, int start, int length);
-	// 删除
+    // 设置next
+    bool SetNext(LinkListNode *next);
+
+    // 获取next
+    LinkListNode *GetNext();
+
+    // 长度自加1
+    bool SetLength();
+
+    // 设置长度
+    bool SetLength(int length);
+
+    // 获取长度
+    int GetLength() const;
+
+    // 获取链表类型
+    bool GetType() const;
+
+    // 构造函数
+    LinkList();
+
+    // 打印
+    virtual bool Print() = 0;
+
+    // 判空
+    bool Empty() const;
+
+    // 插入
+    virtual bool Insert(int index, element_type elem) = 0;
+
+    // 前插入
+    bool PriorInsert(element_type *elem, int start, int length);
+
+    // 后插入
+    bool NextInsert(element_type *elem, int start, int length);
+
+    // 删除
     element_type Delete(int index);
-	virtual element_type* Delete(int index, int length) = 0;
+
+    virtual element_type *Delete(int index, int length) = 0;
+
+    //按位查找
+    virtual element_type GetElem(int index);
+
+    // 按值查找
+    virtual int Locate(element_type elem);
+
+    // 销毁
+    virtual bool Destroy();
 };
 
 class LinkListWithHead : public LinkList {
 public:
-	// 构造函数
-	LinkListWithHead();
-	// 打印
-	bool Print() override;
-	// 插入
-	bool Insert(int index, element_type data) override;
-	// 删除
-    element_type * Delete(int index, int length) override;
+    // 构造函数
+    LinkListWithHead();
+
+    // 打印
+    bool Print() override;
+
+    // 插入
+    bool Insert(int index, element_type elem) override;
+
+    // 删除
+    element_type *Delete(int index, int length) override;
 };
 
 class LinkListWithoutHead : public LinkList {
 private:
-	// 数据
-	element_type _data{};
+    // 数据
+    element_type _data{};
 public:
-	// 设置数据
-	bool SetData(element_type data);
-	// 获取数据
-	element_type GetData() const;
-	// 构造函数
-	LinkListWithoutHead();
-	// 打印
-	bool Print() override;
-	// 插入
-	bool Insert(int index, element_type data) override;
-	// 删除
-    element_type * Delete(int index, int length) override;
+    // 设置数据
+    bool SetData(element_type elem);
+
+    // 获取数据
+    element_type GetData() const;
+
+    // 构造函数
+    LinkListWithoutHead();
+
+    // 打印
+    bool Print() override;
+
+    // 插入
+    bool Insert(int index, element_type elem) override;
+
+    // 删除
+    element_type *Delete(int index, int length) override;
+
+    // 按位查找
+    element_type GetElem(int index) override;
+
+    // 按值查找
+    int Locate(element_type elem) override;
+
+    // 销毁
+    bool Destroy() override;
 };
 
-bool LinkListNode::SetData(element_type data) {
-	this->_data = data;
-	return true;
-}
-
-element_type LinkListNode::GetData() const {
-	return this->_data;
-}
-
-bool LinkListNode::SetNext(LinkListNode* next) {
-	this->_next = next;
-	return true;
-}
-
-LinkListNode* LinkListNode::GetNext() {
-	return this->_next;
-}
-
-LinkListNode::LinkListNode() {
-	this->SetData(NULL);
-	this->SetNext(nullptr);
-}
-
-LinkListNode::LinkListNode(element_type data) {
-	this->SetData(data);
-	this->SetNext(nullptr);
-}
-
-LinkListNode::LinkListNode(element_type data, LinkListNode* next) {
-	this->SetData(data);
-	this->SetNext(next);
-}
-
-bool LinkListNode::Destory() {
-    // 循环删除next指向链表后续结点
-    while(this->GetNext()!= nullptr){
-        LinkListNode* node = this->GetNext();
-        this->SetNext(node->GetNext());
-        node->SetData(NULL);
-        node->SetNext(nullptr);
-    }
-    this->SetData(NULL);
-	this->SetNext(nullptr);
+bool LinkListNode::SetData(element_type elem) {
+    this->_data = elem;
     return true;
 }
 
-bool LinkList::SetNext(LinkListNode* next) {
-	this->_next = next;
-	return true;
+element_type LinkListNode::GetData() const {
+    return this->_data;
 }
 
-LinkListNode* LinkList::GetNext() {
-	return this->_next;
+bool LinkListNode::SetNext(LinkListNode *next) {
+    this->_next = next;
+    return true;
+}
+
+LinkListNode *LinkListNode::GetNext() {
+    return this->_next;
+}
+
+LinkListNode::LinkListNode() {
+    this->SetData(NULL);
+    this->SetNext(nullptr);
+}
+
+LinkListNode::LinkListNode(element_type elem) {
+    this->SetData(elem);
+    this->SetNext(nullptr);
+}
+
+LinkListNode::LinkListNode(element_type elem, LinkListNode *next) {
+    this->SetData(elem);
+    this->SetNext(next);
+}
+
+bool LinkListNode::Destory() {
+    if (this->GetNext() != nullptr) {
+        free(this->GetNext());
+    }
+    this->SetData(NULL);
+    this->SetNext(nullptr);
+    return true;
+}
+
+bool LinkList::SetNext(LinkListNode *next) {
+    this->_next = next;
+    return true;
+}
+
+LinkListNode *LinkList::GetNext() {
+    return this->_next;
 }
 
 bool LinkList::SetLength() {
-	this->_length++;
-	return true;
+    this->_length++;
+    return true;
 }
 
 bool LinkList::SetLength(int length) {
-	this->_length = length;
-	return true;
+    this->_length = length;
+    return true;
 }
 
 int LinkList::GetLength() const {
-	return this->_length;
+    return this->_length;
 }
 
 bool LinkList::SetType(bool type) {
-	this->_type = type;
-	return true;
+    this->_type = type;
+    return true;
 }
 
 bool LinkList::GetType() const {
-	return this->_type;
+    return this->_type;
 }
 
 LinkList::LinkList() {
-	this->SetNext(nullptr);
-	this->SetLength(0);
+    this->SetNext(nullptr);
+    this->SetLength(0);
+}
+
+element_type LinkList::GetElem(int index) {
+    if (index >= this->GetLength() || index < 0) {
+        cout << "GetElem:查找索引" << index << "超过索引范围！" << endl;
+        return DEFAULTELEM;
+    }
+    LinkListNode *node = this->GetNext();
+    for (int i = 1; i < index; i++) {
+        node = node->GetNext();
+    }
+    return node->GetData();
+}
+
+int LinkList::Locate(element_type elem) {
+    LinkListNode *node = this->GetNext();
+    for (int i = 1; i < this->GetLength(); i++) {
+        if (node->GetData() == elem) {
+            return i;
+        }
+    }
+    cout << "Locate:未能定位到值为" << elem << "的元素！" << endl;
+    return -1;
 }
 
 LinkListWithHead::LinkListWithHead() {
-	this->SetType(true);
+    this->SetType(true);
 };
 
-bool LinkListWithoutHead::SetData(element_type data) {
-	this->_data = data;
-	return true;
+bool LinkListWithoutHead::SetData(element_type elem) {
+    this->_data = elem;
+    return true;
 }
 
 element_type LinkListWithoutHead::GetData() const {
-	return this->_data;
+    return this->_data;
 }
 
 LinkListWithoutHead::LinkListWithoutHead() {
-	this->SetType(false);
-	this->SetData(NULL);
+    this->SetType(false);
+    this->SetData(NULL);
 }
 
 bool LinkList::Empty() const {
-	if (this->GetLength() == 0) {
-		return true;
-	}
-	else {
-		return false;
-	}
+    if (this->GetLength() == 0) {
+        return true;
+    } else {
+        return false;
+    }
 }
 
 bool LinkListWithHead::Print() {
-	int i = 1;
-	cout << "第0个元素值为空" << endl;
-	if (this->GetLength() == 0) {
-		return true;
-	}
-	// 当前遍历指针
-	LinkListNode* node = this->GetNext();
-	while (node != nullptr) {
-		cout << "第" << i << "个元素值为" << node->GetData() << endl;
-		i++;
-		node = node->GetNext();
-	}
-	return true;
+    int i = 1;
+    cout << "第0个元素值为空" << endl;
+    if (this->GetLength() == 0) {
+        return true;
+    }
+    // 当前遍历指针
+    LinkListNode *node = this->GetNext();
+    while (node != nullptr) {
+        cout << "第" << i << "个元素值为" << node->GetData() << endl;
+        i++;
+        node = node->GetNext();
+    }
+    return true;
 }
 
 bool LinkListWithoutHead::Print() {
-	int i = 0;
-	if (this->GetLength() == 0) {
-		return true;
-	}
-	cout << "第" << i << "个元素值为" << this->GetData() << endl;
-	// 当前遍历指针
-	LinkListNode* node = this->GetNext();
-	while (node != nullptr) {
-		i++;
-		cout << "第" << i << "个元素值为" << node->GetData() << endl;
-		node = node->GetNext();
-	}
-	return true;
+    int i = 0;
+    if (this->GetLength() == 0) {
+        return true;
+    }
+    cout << "第" << i << "个元素值为" << this->GetData() << endl;
+    // 当前遍历指针
+    LinkListNode *node = this->GetNext();
+    while (node != nullptr) {
+        i++;
+        cout << "第" << i << "个元素值为" << node->GetData() << endl;
+        node = node->GetNext();
+    }
+    return true;
 }
 
-bool LinkListWithHead::Insert(int index, element_type data) {
-	if (index < 1) {
-		cout << "Insert:插入索引值" << index << "过小！" << endl;
-		return false;
-	}
-	// 定义一个结点指针p指向当前扫描到的结点
-	LinkListNode* node;
-	// 定义一个变量i表示当前扫描到的结点的索引号
-	int i = 1;
-	// 将链表头结点的next指向node，为第1个结点
-	node = this->GetNext();
-	// 设置一个新结点进行插入
-	auto* new_node = new LinkListNode(data);
-	// 如果该链表为空链表
-	if (node == nullptr) {
-		this->SetNext(new_node);
-		this->SetLength();
-		return true;
-	}
-	// 当插入的是第一个节点
-	if (index == 1) {
-		new_node->SetNext(node);
-		this->SetNext(new_node);
-		this->SetLength();
-		return true;
-	}
-	// 循环遍历到达指定索引号的单链表的结点
-	// 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
-	while (node->GetNext() != nullptr && i < index - 1) {
-		node = node->GetNext();
-		i++;
-	}
-	// 如果此时i小于index-1，表示遍历完还没有到达对应的索引
-	if (i < index - 1) {
-		cout << "Insert:插入索引值" << index << "过大！" << endl;
-		return false;
-	}
-	// 此时i==index-1
-	// 将node原来的后继给新的结点
-	new_node->SetNext(node->GetNext());
-	node->SetNext(new_node);
+bool LinkListWithHead::Insert(int index, element_type elem) {
+    if (index < 1) {
+        cout << "Insert:插入索引值" << index << "过小！" << endl;
+        return false;
+    }
+    // 定义一个结点指针p指向当前扫描到的结点
+    LinkListNode *node;
+    // 定义一个变量i表示当前扫描到的结点的索引号
+    int i = 1;
+    // 将链表头结点的next指向node，为第1个结点
+    node = this->GetNext();
+    // 设置一个新结点进行插入
+    auto *new_node = new LinkListNode(elem);
+    // 如果该链表为空链表
+    if (node == nullptr) {
+        this->SetNext(new_node);
+        this->SetLength();
+        return true;
+    }
+    // 当插入的是第一个节点
+    if (index == 1) {
+        new_node->SetNext(node);
+        this->SetNext(new_node);
+        this->SetLength();
+        return true;
+    }
+    // 循环遍历到达指定索引号的单链表的结点
+    // 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
+    while (node->GetNext() != nullptr && i < index - 1) {
+        node = node->GetNext();
+        i++;
+    }
+    // 如果此时i小于index-1，表示遍历完还没有到达对应的索引
+    if (i < index - 1) {
+        cout << "Insert:插入索引值" << index << "过大！" << endl;
+        return false;
+    }
+    // 此时i==index-1
+    // 将node原来的后继给新的结点
+    new_node->SetNext(node->GetNext());
+    node->SetNext(new_node);
     this->SetLength();
-	return true;
+    return true;
 }
 
-bool LinkListWithoutHead::Insert(int index, element_type data) {
-	if (index < 0) {
-		cout << "Insert:插入索引值" << index << "过小！" << endl;
-		return false;
-	}
-	if (index == 0) {
-		if (this->GetLength() == 0) {
-			this->SetData(data);
-			this->SetLength();
-		}
-		else {
-			auto* node = new LinkListNode(this->GetData());
-			node->SetNext(this->GetNext());
-			this->SetData(data);
-			this->SetNext(node);
-			this->SetLength();
-		}
-		return true;
-	}
-	// 定义一个结点指针node指向当前扫描到的结点
-	LinkListNode* node;
-	// 定义一个变量i表示当前扫描到的结点的索引号
-	int i = 1;
-	// 将链表头结点的next指向p，为第1个结点
-	node = this->GetNext();
-	// 设置一个新结点进行插入
-	auto* new_node = new LinkListNode(data);
-	// 如果该链表为空链表
-	if (node == nullptr) {
-		this->SetLength();
-		this->SetNext(new_node);
-		return true;
-	}
-	// 循环遍历到达指定索引号的单链表的结点
-	// 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
-	while (node->GetNext() != nullptr && i < index - 1) {
-		node = node->GetNext();
-		i++;
-	}
-	// 如果此时i小于index-1，表示遍历完还没有到达对应的索引
-	if (i < index - 1) {
-		cout << "Insert:插入索引值" << index << "过大！" << endl;
-		return false;
-	}
-	// 此时i==index-1
-	// 将p原来的后继给新的结点
-	new_node->SetNext(node->GetNext());
-	node->SetNext(new_node);
-	this->SetLength();
-	return true;
+bool LinkListWithoutHead::Insert(int index, element_type elem) {
+    if (index < 0) {
+        cout << "Insert:插入索引值" << index << "过小！" << endl;
+        return false;
+    }
+    if (index == 0) {
+        if (this->GetLength() == 0) {
+            this->SetData(elem);
+            this->SetLength();
+        } else {
+            auto *node = new LinkListNode(this->GetData());
+            node->SetNext(this->GetNext());
+            this->SetData(elem);
+            this->SetNext(node);
+            this->SetLength();
+        }
+        return true;
+    }
+    // 定义一个结点指针node指向当前扫描到的结点
+    LinkListNode *node;
+    // 定义一个变量i表示当前扫描到的结点的索引号
+    int i = 1;
+    // 将链表头结点的next指向p，为第1个结点
+    node = this->GetNext();
+    // 设置一个新结点进行插入
+    auto *new_node = new LinkListNode(elem);
+    // 如果该链表为空链表
+    if (node == nullptr) {
+        this->SetLength();
+        this->SetNext(new_node);
+        return true;
+    }
+    // 循环遍历到达指定索引号的单链表的结点
+    // 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
+    while (node->GetNext() != nullptr && i < index - 1) {
+        node = node->GetNext();
+        i++;
+    }
+    // 如果此时i小于index-1，表示遍历完还没有到达对应的索引
+    if (i < index - 1) {
+        cout << "Insert:插入索引值" << index << "过大！" << endl;
+        return false;
+    }
+    // 此时i==index-1
+    // 将p原来的后继给新的结点
+    new_node->SetNext(node->GetNext());
+    node->SetNext(new_node);
+    this->SetLength();
+    return true;
 }
 
-bool LinkList::PriorInsert(element_type* elem, int start, int length) {
-	if (this->GetType()) {
-		for (int i = 0; i < length; i++) {
-			bool result = this->Insert(1, elem[i + start]);
-			if (!result) {
-				cout << "PriorInsert:循环插入失败！索引值为" << i + start << endl;
-				return false;
-			}
-		}
-		return true;
-	}
-	else {
-		for (int i = 0; i < length; i++) {
-			bool result = this->Insert(0, elem[i + start]);
-			if (!result) {
-				cout << "PriorInsert:循环插入失败！索引值为" << i + start << endl;
-				return false;
-			}
-		}
-		return true;
-	}
+bool LinkList::PriorInsert(element_type *elem, int start, int length) {
+    if (this->GetType()) {
+        for (int i = 0; i < length; i++) {
+            bool result = this->Insert(1, elem[i + start]);
+            if (!result) {
+                cout << "PriorInsert:循环插入失败！索引值为" << i + start << endl;
+                return false;
+            }
+        }
+        return true;
+    } else {
+        for (int i = 0; i < length; i++) {
+            bool result = this->Insert(0, elem[i + start]);
+            if (!result) {
+                cout << "PriorInsert:循环插入失败！索引值为" << i + start << endl;
+                return false;
+            }
+        }
+        return true;
+    }
 }
 
-bool LinkList::NextInsert(element_type* elem, int start, int length) {
-	if (this->GetType()) {
-		for (int i = 0; i < length; i++) {
-			bool result = this->Insert(i + 1, elem[i + start]);
-			if (!result) {
-				cout << "NextInsert:循环插入失败！索引值为" << i + start << endl;
-				return false;
-			}
-		}
-		return true;
-	}
-	else {
-		for (int i = 0; i < length; i++) {
-			bool result = this->Insert(i, elem[i + start]);
-			if (!result) {
-				cout << "NextInsert:循环插入失败！索引值为" << i + start << endl;
-				return false;
-			}
-		}
-		return true;
-	}
+bool LinkList::NextInsert(element_type *elem, int start, int length) {
+    if (this->GetType()) {
+        for (int i = 0; i < length; i++) {
+            bool result = this->Insert(i + 1, elem[i + start]);
+            if (!result) {
+                cout << "NextInsert:循环插入失败！索引值为" << i + start << endl;
+                return false;
+            }
+        }
+        return true;
+    } else {
+        for (int i = 0; i < length; i++) {
+            bool result = this->Insert(i, elem[i + start]);
+            if (!result) {
+                cout << "NextInsert:循环插入失败！索引值为" << i + start << endl;
+                return false;
+            }
+        }
+        return true;
+    }
 }
 
 element_type LinkList::Delete(int index) {
-	return *(this->Delete(index, 1));
+    return *(this->Delete(index, 1));
 }
 
-element_type* LinkListWithHead::Delete(int index, int length) {
-	auto* data = (element_type*)malloc(length * sizeof(element_type));
-	if (index < 1) {
-	    cout << "Delete:删除索引值" << index << "过小！" << endl;
-	    return data;
-	}
-	if (length < 1) {
-		cout << "Delete:删除长度" << length << "过小！" << endl;
-		return data;
-	}
-	// 定义一个结点指针start指向当前扫描到的结点，即要删除第一的元素的前一个
-	LinkListNode* start;
-	// 定义一个结点指针start指向当前扫描到的结点，要删除最后的元素
-	LinkListNode* end;
-	// 定义一个变量i表示当前扫描到的结点的索引号
-	int i = 1;
-	// 将链表头结点的next指向start，为第1个结点
-	start = this->GetNext();
-	// 如果链表没有任何数据
-	if(start == nullptr) {
-	    cout << "Delete:链表为空！" << endl;
-	    return data;
-	}
-	// 循环遍历到达指定索引号的单链表的结点
-	// 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
-	while (start->GetNext() != nullptr && i < index - 1) {
-	    start = start->GetNext();
-	    i++;
-	}
-	// 如果此时i小于index-1，表示遍历完还没有到达对应的索引
-	if (i < index - 1) {
-	    cout << "Delete:删除索引值" << index << "过大！" << endl;
-	    return data;
-	}
-	// 此时i==index-1，start到达，求end
-	end = start;
-	for (int i = 0; i < length; i++) {
-		data[i] = end->GetData();
-		end = end->GetNext();
-		if (end == nullptr) {
-		    cout << "Delete:删除索引最大值" << index + length - 1 << "大于链表最大索引" << length << "！" << endl;
-			return data;
-		}
-	}
-	if (index == 1) {
-		this->SetNext(end);
-	}
-	else {
-		start->SetNext(end->GetNext());
-	}
-	this->SetLength(this->GetLength() - length);
-	free(start);
-	free(end);
-	return data;
+element_type *LinkListWithHead::Delete(int index, int length) {
+    auto *data = (element_type *) malloc(length * sizeof(element_type));
+    if (index < 1) {
+        cout << "Delete:删除索引值" << index << "过小！" << endl;
+        return data;
+    }
+    if (length < 1) {
+        cout << "Delete:删除长度" << length << "过小！" << endl;
+        return data;
+    }
+    // 定义一个结点指针start指向当前扫描到的结点，即要删除第一的元素的前一个
+    LinkListNode *start;
+    // 定义一个结点指针start指向当前扫描到的结点，要删除最后的元素
+    LinkListNode *end;
+    // 定义一个变量i表示当前扫描到的结点的索引号
+    int i = 1;
+    // 将链表头结点的next指向start，为第1个结点
+    start = this->GetNext();
+    // 如果链表没有任何数据
+    if (start == nullptr) {
+        cout << "Delete:链表为空！" << endl;
+        return data;
+    }
+    // 循环遍历到达指定索引号的单链表的结点
+    // 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
+    while (start->GetNext() != nullptr && i < index - 1) {
+        start = start->GetNext();
+        i++;
+    }
+    // 如果此时i小于index-1，表示遍历完还没有到达对应的索引
+    if (i < index - 1) {
+        cout << "Delete:删除索引值" << index << "过大！" << endl;
+        return data;
+    }
+    // 此时i==index-1，start到达，求end
+    end = start;
+    for (int i = 0; i < length; i++) {
+        data[i] = end->GetData();
+        end = end->GetNext();
+        if (end == nullptr) {
+            cout << "Delete:删除索引最大值" << index + length - 1 << "大于链表最大索引" << length - 1 << "！" << endl;
+            return data;
+        }
+    }
+    if (index == 1) {
+        this->SetNext(end);
+    } else {
+        start->SetNext(end->GetNext());
+    }
+    this->SetLength(this->GetLength() - length);
+    return data;
 }
 
-element_type* LinkListWithoutHead::Delete(int index, int length) {
-	auto* data = (element_type*)malloc(length * sizeof(element_type));
-	if (index < 0) {
-		cout << "Delete:删除索引值" << index << "过小！" << endl;
-		return data;
-	}
-	if (length < 1) {
-		cout << "Delete:删除长度" << length << "过小！" << endl;
-	}
-	// 定义一个结点指针start指向当前扫描到的结点，即要删除第一的元素的前一个
-	LinkListNode* start;
-	// 定义一个结点指针start指向当前扫描到的结点，要删除最后的元素
-	LinkListNode* end;
-	// 定义一个变量i表示当前扫描到的结点的索引号
-	int i = 1;
-	// 将链表头结点的next指向start，为第1个结点
-	start = this->GetNext();
-	// 如果链表没有任何数据
-	if (this->GetData() == NULL) {
-		cout << "Delete:链表为空！" << endl;
-		return data;
-	}
-	data[0] = this->GetData();
-	// 循环遍历到达指定索引号的单链表的结点
-	// 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
-	while (start->GetNext() != nullptr && i < index - 1) {
-		start = start->GetNext();
-		i++;
-	}
-	// 如果此时i小于index-1，表示遍历完还没有到达对应的索引
-	if (i < index - 1) {
-		cout << "Delete:删除索引值" << index << "过大！" << endl;
-		return data;
-	}
-	// 从1开始遍历
-	end = this->GetNext();
-	for (int i = 1; i < index + length - 1; i++) {
-		if (i > index) {
-			data[i - index] = end->GetData();
-		}
-		end = end->GetNext();
-		if (end == nullptr) {
-			cout << "Delete:删除索引最大值" << index + length - 1 << "大于链表最大索引" << length << "！" << endl;
-			return data;
-		}
-	}
-	if (index == 0) {
-		this->SetData(end->GetNext()->GetData());
-		this->SetNext(end->GetNext()->GetNext());
-	}
-	if (index == 1) {
-		this->SetNext(end->GetNext());
-	}
-	else {
-		start->SetNext(end->GetNext());
-	}
-	this->SetLength(this->GetLength() - length);
-	free(start);
-	free(end);
-	return data;
-}
\ No newline at end of file
+element_type *LinkListWithoutHead::Delete(int index, int length) {
+    auto *data = (element_type *) malloc(length * sizeof(element_type));
+    if (index < 0) {
+        cout << "Delete:删除索引值" << index << "过小！" << endl;
+        return data;
+    }
+    if (length < 1) {
+        cout << "Delete:删除长度" << length << "过小！" << endl;
+    }
+    // 定义一个结点指针start指向当前扫描到的结点，即要删除第一的元素的前一个
+    LinkListNode *start;
+    // 定义一个结点指针start指向当前扫描到的结点，要删除最后的元素
+    LinkListNode *end;
+    // 定义一个变量i表示当前扫描到的结点的索引号
+    int i = 1;
+    // 将链表头结点的next指向start，为第1个结点
+    start = this->GetNext();
+    // 如果链表没有任何数据
+    if (this->GetData() == NULL) {
+        cout << "Delete:链表为空！" << endl;
+        return data;
+    }
+    data[0] = this->GetData();
+    // 循环遍历到达指定索引号的单链表的结点
+    // 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
+    while (start->GetNext() != nullptr && i < index - 1) {
+        start = start->GetNext();
+        i++;
+    }
+    // 如果此时i小于index-1，表示遍历完还没有到达对应的索引
+    if (i < index - 1) {
+        cout << "Delete:删除索引值" << index << "过大！" << endl;
+        return data;
+    }
+    // 从1开始遍历
+    end = this->GetNext();
+    for (int i = 1; i < index + length - 1; i++) {
+        if (i >= index) {
+            data[i - index] = end->GetData();
+        }
+        end = end->GetNext();
+        if (end == nullptr) {
+            cout << "Delete:删除索引最大值" << index + length - 1 << "大于链表最大索引" << length - 1 << "！" << endl;
+            return data;
+        }
+    }
+    data[length - 1] = end->GetData();
+    if (index == 0) {
+        this->SetData(end->GetNext()->GetData());
+        this->SetNext(end->GetNext()->GetNext());
+    }
+    if (index == 1) {
+        this->SetNext(end->GetNext());
+    } else {
+        start->SetNext(end->GetNext());
+    }
+    this->SetLength(this->GetLength() - length);
+    return data;
+}
+
+element_type LinkListWithoutHead::GetElem(int index) {
+    if (index == 0) {
+        return this->GetData();
+    } else {
+        return LinkList::GetElem(index);
+    }
+}
+
+int LinkListWithoutHead::Locate(element_type elem) {
+    if (this->GetData() == elem) {
+        return 0;
+    } else {
+        return LinkList::Locate(elem);
+    }
+}
+
+bool LinkList::Destroy() {
+    this->SetLength(0);
+    free(this->GetNext());
+    this->SetNext(nullptr);
+    this->SetType(NULL);
+    return true;
+}
+
+bool LinkListWithoutHead::Destroy() {
+    this->SetData(NULL);
+    return LinkList::Destroy();
+}
diff --git a/Code/CPP-Code/head/sequence_list.h b/Code/CPP-Code/head/sequence_list.h
index 1bc1374..a227bb7 100644
--- a/Code/CPP-Code/head/sequence_list.h
+++ b/Code/CPP-Code/head/sequence_list.h
@@ -65,9 +65,9 @@ private:
     int _max_size{};
 public:
     // 设置最大容量
-    bool SetMaxSize(int length);
+    bool SetMaxSize(int max_size);
     // 获取最大容量
-    int GetMaxSize();
+    int GetMaxSize() const;
     // 构造函数
     DynamicSequenceList();
     // 插入函数
@@ -120,12 +120,12 @@ StaticSequenceList::StaticSequenceList() : SequenceList() {
     this->SetData((element_type*)malloc(MAXSIZE * sizeof(element_type)));
 }
 
-bool DynamicSequenceList::SetMaxSize(int length) {
-    this->_max_size = length;
+bool DynamicSequenceList::SetMaxSize(int max_size) {
+    this->_max_size = max_size;
     return true;
 }
 
-int DynamicSequenceList::GetMaxSize() {
+int DynamicSequenceList::GetMaxSize() const {
     return this->_max_size;
 }
 
@@ -264,7 +264,7 @@ element_type SequenceList::Delete(int index) {
 element_type* SequenceList::LoopDelete(int index, int length) {
     if (index + length > this->GetLength() || index < 0) {
         cout << "LoopDelete:删除索引" << index + length << "超过索引范围！" << endl;
-        return false;
+        return nullptr;
     }
     auto* elem = (element_type*)malloc(length * sizeof(element_type));
     if (elem) {
@@ -285,7 +285,7 @@ element_type* SequenceList::LoopDelete(int index, int length) {
 element_type SequenceList::GetElem(int index) const {
     if (index >= this->GetLength() || index < 0) {
         cout << "GetElem:查找索引" << index << "超过索引范围！" << endl;
-        return DEFAULTDATA;
+        return DEFAULTELEM;
     }
     return this->GetData(index);
 }
diff --git a/Code/CPP-Code/head/static_link_list.h b/Code/CPP-Code/head/static_link_list.h
new file mode 100644
index 0000000..d827a6a
--- /dev/null
+++ b/Code/CPP-Code/head/static_link_list.h
@@ -0,0 +1,64 @@
+#include <cstdio>
+#include <cstdlib>
+#include "head.h"
+
+class StaticLinkListNode {
+private:
+    // 数据元素
+    element_type _data;
+    // 下一个元素的数组下标
+    int _next;
+public:
+    // 设置元素
+    bool SetData(element_type elem);
+    // 获取元素
+    element_type GetData();
+    // 设置下标
+    bool SetNext(int index);
+    // 获取下标
+    int GetNext();
+
+    // 构造函数
+    StaticLinkListNode();
+
+    StaticLinkListNode(element_type elem);
+
+    StaticLinkListNode(element_type elem, int next);
+
+    // 销毁
+    bool Destroy();
+};
+
+class StaticLinkList {
+private:
+    // 首元素地址
+    int _first;
+    // 数据长度
+    int _length;
+    // 数据当前最大长度
+    int _max_size;
+public:
+    // 设置首元素地址
+    bool SetFirst(int index);
+
+    // 获取首元素地址
+    int GetFirst();
+
+    // 数据长度自加
+    bool SetLength();
+
+    // 设置数据长度
+    bool SetLength(int length);
+
+    // 获取数据长度
+    int GetLength();
+
+    // 设置数据当前最大长度
+    bool SetMaxSize(int max_size);
+
+    // 获取数据当前最大长度
+    int GetMaxSize();
+
+    // 数据
+    StaticLinkListNode *data;
+};
\ No newline at end of file
diff --git a/Code/CPP-Code/source/test.cpp b/Code/CPP-Code/source/test.cpp
index 4475dda..bc85e1b 100644
--- a/Code/CPP-Code/source/test.cpp
+++ b/Code/CPP-Code/source/test.cpp
@@ -32,11 +32,12 @@ bool LinkListTest() {
     auto* list = new LinkListWithoutHead();
     list->NextInsert(a, 0 ,5);
     list->Print();
-    int len = 3;
+    int len = 5;
     element_type* b = list->Delete(2, len);
     for (int i = 0; i < len; i++) {
         cout << b[i] << endl;
     }
     list->Print();
+    cout << list->Locate('1') << endl;
     return true;
 }
\ No newline at end of file