数据结构，在我看来就是对数据的处理，包括数据的存储和读取等，运用不同的编程语言来实现，其区别在于语言之间的语法不同，然而其所要表达的思想是一样的。闲话不多说，在还是来看代码实现吧。
1.用数组来实现的一个简单的泛型队列
//定义一个泛型的队列
public class list<E> {
//创建一个Odject对象的数组，其长度为零
Object [] o = new Object[0];
//默认在数组最后添加
public void add(E e) {
add(o.length, e);
}
//在index位置添加E类型的e对象
public void add(int index, E e) {
Object [] ol = new Object[o.length + 1];
if (index >= 0 && index <= o.length) {
for (int i = 0; i < index; i++) {
ol[i] = o[i];
}
ol[index] = e;
for (int i = index; i < o.length; i++) {
ol[i + 1] = o[i];
}
o = ol;
System.out.println("在第" + index + "个位置添加了" + e + "\n***此时队列长度为 ：" + o.length + "\n");
} else System.out.println("第" + index + "个位置添加错误" + "\n***此时队列长度为 ：" + o.length + "\n");
}
//更改index位置的值
public void modify(int index, E e) {
System.out.println("更改第" + index + "个位置为：" + e + "\n***此时队列长度为 ：" + o.length + "\n");
o[index] = e;
}
//默认删除最后一个元素
public void delete() {
delete(o.length - 1);
}
//删除index位置的元素
public void delete(int index) {
Object [] ol = new Object[o.length - 1];
if (index >= 0 && index <= ol.length) {
for (int i = 0; i < index; i++) {
ol[i] = o[i];
}
for (int j = index; j < ol.length; j++) {
ol[j] = o[j + 1];
}
o = ol;
System.out.println("第" + index + "个位置的元素被删除了！" + "\n***此时队列长度为 ：" + o.length + "\n");
} else System.out.println("删除第" + index + "个位置错误！" + "\n***此时队列长度为 ：" + o.length + "\n");
}
//获取index位置的元素
@SuppressWarnings("unchecked")
public E get(int index) {
if(index >= o.length || index < 0) {
System.out.println("获取方式错误" + "\n***此时队列长度为 ：" + o.length + "\n");
} else System.out.print("第" + index + "个位置的值为 ：");
return (E)o[index];
}
//获取数组的长度
public int size() {
return o.length;
}
}
//队列测试类
public class listtest {
public static void main(String[] args) {
list <String> l = new list<String>();
l.add("qwqwd");
l.add("fsdvc");
l.add("vcdf");
l.add("reggw");
l.add(2, "qwertuyghjkkhg");
l.modify(1, "change");
l.delete(3);
l.delete();
System.out.println(" ");
for(int i = 0; i < l.size(); i ++) {
System.out.println(l.get(i));
}
}
测试结果如下：
[img]
[/img]
其实，所谓的队列，只不过是穿上了一件“衣服”的数组。利用数组来实现的队列，其优点是只需要知道元素的下标即可实现便捷的访问。但是要删除其中的成员或者添加新的成员，其所要花费的时间复杂度比较大，而利用链表来实现的队列就正好解决了这个弊端。下面就来看用链表来实现的队列。
2.利用链表实现的简单的一个的泛型队列
//节点类
public class Node<E> {
//节点的值
public E value;
//指向下一个节点的指针
public Node<E> next;
}
//链表类
public class List<E> {
/**
* 属性
*/
//头指针
private Node<E> head;
//节点的个数初始为零
private int count = 0;
/**
* 方法
*/
//默认在最后边添加一个
public void add(Node<E> node){
add(count, node);
}
//在第index + 1个位置添加
public Node<E> add(int index, Node<E> node){
if(index > count || index < 0) {
System.out.println("添加错误！");
return null;
}
if(count == 0) {
head = node;
count ++;
return head;
} else {
Node<E> temp = head ;
for(int i = 0; i < index - 1; i ++) {
temp = temp.next;
}
node.next = temp.next;
temp.next = node;
count ++;
System.out.println("在第" + (index + 1) + "个位置添加元素成功！");
return head;
}
}
//删除第index + 1位置的元素
public Node<E> remove(int index){
if(count == 0) {
System.out.println("队列长度为空，无法删除!");
return null;
}
if(index < 0 || index >= count) {
System.out.println("删除错误！");
return null;
}
Node<E> temp = head ;
for(int i = 0; i < index - 1; i ++) {
temp=temp.next;
}
temp.next = (temp.next).next;
count --;
System.out.println("删除第" + (index + 1) + "个位置的元素成功！");
return head ;
}
//获取第index个 元素
public Node<E> get(int index){
if(index > count || index < 0) {
System.out.println("获取错误！");
return null;
}
Node<E> temp = head ;
for(int i = 0; i < index; i ++) {
temp = temp.next;
}
System.out.println("获取" + index + "个位置的元素成功！");
return head ;
}
//返回节点个数
public int size(){
System.out.println("队列长度为：" + count);
return count;
}
//遍历
public void show(){
Node<E> temp = head ;
for(int i = 0;i < count; i++) {
System.out.println("此队列的第" + (i + 1) + "个是：" + temp.value);
temp = temp.next;
}
}
}
//测试类
public class Listtest {
public static void main(String args[]){
//创建一个用于存储String类型的链表队列
List<String> list = new List<String>();
//添加20个节点
for(int i = 0; i < 10; i ++) {
Node<String> temp = new Node<String>();
temp.value = "a" + i;
list.add(temp);
}
//数组长度
list.size();
//在指定位置插入
Node<String> temp1 = new Node<String>();
temp1.value = "qwert";
list.add(3, temp1);
//随机添加
Node<String> temp2 = new Node<String>();
temp2.value = "dfgdgsdb";
list.add(new Random().nextInt(list.size()), temp2);
//数组长度
list.size();
//指定删除
list.remove(7);
//随机删除元素
list.remove(new Random().nextInt(list.size()));
//指定获取
list.get(4);
//随机获取元素
list.get(new Random().nextInt(list.size()));
//遍历
list.show();
}
}
测试结果如下：
[img]
[/img]
综上可以看出利用数组实现的队列访问比较便利，而利用链表实现的队列则是增删比较方便，两种队列都各有千秋，实际运用的时候还得看对数据处理的需求。
3.简单的二叉树
//节点类
public class Enode {
Enode rootnode;
Enode leftnode;
Enode rightnode;
String data;
}
//二叉树类
public class Etree {
//创建二叉树的方法
public Enode creatTree() {
Enode root = new Enode();
root.data = "根节点";
Enode left = new Enode();
left.data = "左节点";
Enode right = new Enode();
right.data = "右节点";
Enode leftleft = new Enode();
leftleft.data = "左左节点";
Enode leftright = new Enode();
leftright.data = "左右节点";
Enode rightleft = new Enode();
rightleft.data = "右左节点";
Enode rightright = new Enode();
rightright.data = "右右节点";
root.leftnode = left;
root.rightnode = right;
left.leftnode = leftleft;
left.rightnode = leftright;
right.leftnode = rightleft;
right.rightnode = rightright;
return root;
}
//中序检索二叉树
public void search1(Enode root) {
if(root != null) {
search1(root.leftnode);
System.out.println(root.data);
search1(root.rightnode);
}
}
//先序检索二叉树
public void search2(Enode root) {
if(root != null) {
System.out.println(root.data);
search2(root.leftnode);
search2(root.rightnode);
}
}
//后序检索二叉树
public void search3(Enode root) {
if(root != null) {
search3(root.leftnode);
search3(root.rightnode);
System.out.println(root.data);
}
}
public static void main(String[] args) {
//创建一个二叉树对象
Etree tr = new Etree();
//创建二叉树
Enode root = tr.creatTree();
System.out.println("中序检索二叉树如下：");
//中序检索二叉树
tr.search1(root);
System.out.println(" ");
System.out.println("先序检索二叉树如下：");
//先序检索二叉树
tr.search2(root);
System.out.println(" ");
System.out.println("后序检索二叉树如下：");
//后序检索二叉树
tr.search3(root);
}
}
测试结果如下：
[img]
[/img]
本人文笔不好，描述若有不当之处，敬请见谅！
- 大小: 6 KB
分享到：
相关推荐
包含常用数据结构的算法，如链表，队列，栈，遍历算法，适合初学者学习。你奶奶地，标题写的够详细了，还说我写的不详细，上传个资料真他娘的难
数据结构实训是对理论知识的深度实践，通过本次实训，我深感收获颇丰。首先，我对数据结构的理解得以巩固和深化，这不仅强化了我在课堂上学到的知识，而且提升了我将这些知识应用于实际问题的能力。数据结构是计算机...
这个压缩包包含了四份重要的资料，分别是“数据结构A卷答案.doc”、“数据结构试卷C.doc”、“数据结构A卷.doc”和“数据结构C卷参考答案.doc”，这些文件对于考生来说是宝贵的复习资源。 首先，"数据结构A卷答案....
河南理工大学857数据结构的考研真题集合，提供了近7年的试题，对于备考该科目来说，无疑是一份宝贵的资料。 数据结构课程的核心内容包括线性结构（如数组、链表）、树形结构（如二叉树、堆）、图结构以及散列结构等...
总的来说，"数据结构 我见过最好的"这个课件将带领我们深入理解数据结构的精髓，掌握它们在实际问题中的应用，从而提高我们的编程技能和问题解决能力。通过系统的学习，我们可以更好地应对各种复杂的问题，并为未来...
数据结构是计算机科学中的核心课程，对于准备考研的学子来说，深入理解和掌握数据结构的知识至关重要。这份"数据结构考研资料"包含了一系列丰富的学习资源，旨在帮助考生全面掌握数据结构的相关概念、原理和应用。 ...
不过，我可以根据标题中提供的《数据结构(C语言版) 严蔚敏吴伟民》这一线索，来阐述关于数据结构以及该书的一些知识点。 首先，《数据结构(C语言版) 严蔚敏吴伟民》是一本在中国计算机科学与技术教育领域具有重要...
因此，掌握各种数据结构及其操作方法对于任何程序员来说都是非常重要的。 ### 常见的数据结构类型 #### 1. 数组（Array） 数组是一种最基本的数据结构，它由一组有序的元素组成，这些元素可以通过索引快速访问。...
高级数据结构部分并不容易，如果你第一次就全部耐心看完，我也不得不怀疑那是不是真的。因为那些数据结构的额繁琐程度非同一般，如果你能随手码出其中的大半，就足以说明你的代码能力已经差不多出神入化了。 最重要...
这是我大学老师上课用的ppt,演示的相当清晰,想要数据结构的朋友放心下吧.本ppt包括清华大学版数据结构c语言有章节,若从头到尾学完,做完配套的数据结构实验,你就可以成为数据结构高手了. 好东西忍不住拿出来分享,...
总的来说，这个压缩包提供了一个全面的Java数据结构学习路径，覆盖了从基础到进阶的各种主题。通过实际操作和代码实践，学习者可以系统地提升自己在数据结构和算法方面的技能，为成为一名优秀的Java开发者打下坚实...
总结来说，这份文档可能是一篇专业性较强的技术文章，重点讨论了如何用C语言实现一种金字塔型的数据结构，并可能探讨了该结构在数据分析和大数据应用中的优势。此外，文档还可能包含对相关领域的参考文献的引用，为...
理解并掌握数据结构对于任何想要深入学习编程的人来说都是至关重要的。正如标题“数据结构习题与解答”所暗示的，通过大量的练习来加强数据结构的理解是一种非常有效的方法。 数据结构可以分为两大类：线性结构和非...
南京理工大学的数据结构试卷对于学习这门课程的学生来说，是极其宝贵的复习资源。这份试卷集合了学校近几年来的考试题目，能够反映出该校在数据结构教学上的重点和常见考查方式。 数据结构试卷通常包含以下几个方面...
然而，我可以基于标题和描述中提到的“自考数据结构02331”这一关键信息，为读者们介绍一些关于自考数据结构科目的知识点和相关考试信息。 自考，即高等教育自学考试，是中国大陆一项权威的学历考试体系，旨在通过...
综上所述，对于准备考研的学生来说，不仅要掌握各种数据结构和算法的基本原理，还要熟悉在有限的考试环境下书写高质量代码的技巧，以及能够对算法的时间复杂度进行分析。通过系统学习和练习，可以提升在数据结构考试...
但是，根据标题“数据结构笔记.pdf”，我可以提供有关数据结构的基础知识点。 数据结构是计算机存储、组织数据的方式。它旨在以某种方式将数据存储在计算机中，以便于可以进行有效的访问和修改。更确切地说，数据...
数据结构与算法是计算机科学的基础，对于理解和解决复杂问题至关重要。这份名为“数据结构与算法笔记代码”的资源可能是一个包含讲解和示例代码的压缩包，旨在帮助学习者深入理解这个主题。 数据结构是组织、存储和...
《重庆大学数据结构项目1——我的购物车程序详解》 数据结构是计算机科学中的核心课程，它探讨如何高效地组织和存储数据，以便于数据的处理和访问。在这个项目中，我们将聚焦于“我的购物车程序”，这个项目是重庆...