本文通过具体实例介绍了使用数组和链表实现队列的方法，并探讨了两者的特点。此外，还讲解了二叉树的基本概念及中序、先序和后序检索方法。
[size=large] 数据结构，在我看来就是对数据的处理，包括数据的存储和读取等，运用不同的编程语言来实现，其区别在于语言之间的语法不同，然而其所要表达的思想是一样的。闲话不多说，在还是来看代码实现吧。[/size]
[size=medium]1.用数组来实现的一个简单的泛型队列[/size]
[size=medium]测试结果如下：[/size]
[img]
[img]http://dl2.iteye.com/upload/attachment/0091/7370/0eabf44c-6b03-3ac6-8d53-c63fc66dd61f.png[/img]
[/img]
[size=medium] 其实，所谓的队列，只不过是穿上了一件“衣服”的数组。利用数组来实现的队列，其优点是只需要知道元素的下标即可实现便捷的访问。但是要删除其中的成员或者添加新的成员，其所要花费的时间复杂度比较大，而利用链表来实现的队列就正好解决了这个弊端。下面就来看用链表来实现的队列。
2.利用链表实现的简单的一个的泛型队列[/size]
测试结果如下：
[img]
[img]http://dl2.iteye.com/upload/attachment/0091/7370/0eabf44c-6b03-3ac6-8d53-c63fc66dd61f.png[/img]
[/img]
[size=medium] 综上可以看出利用数组实现的队列访问比较便利，而利用链表实现的队列则是增删比较方便，两种队列都各有千秋，实际运用的时候还得看对数据处理的需求。[/size]
[size=medium]3.简单的二叉树[/size]
测试结果如下：
[img]
[img]http://dl2.iteye.com/upload/attachment/0091/7391/0b97fe7a-a1a6-3149-8ccb-01136dac056f.png[/img]
[/img]
[size=large] 本人文笔不好，描述若有不当之处，敬请见谅！[/size]
[size=medium]1.用数组来实现的一个简单的泛型队列[/size]
//定义一个泛型的队列
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));
}
}
[size=medium]测试结果如下：[/size]
[img]
[img]http://dl2.iteye.com/upload/attachment/0091/7370/0eabf44c-6b03-3ac6-8d53-c63fc66dd61f.png[/img]
[/img]
[size=medium] 其实，所谓的队列，只不过是穿上了一件“衣服”的数组。利用数组来实现的队列，其优点是只需要知道元素的下标即可实现便捷的访问。但是要删除其中的成员或者添加新的成员，其所要花费的时间复杂度比较大，而利用链表来实现的队列就正好解决了这个弊端。下面就来看用链表来实现的队列。
2.利用链表实现的简单的一个的泛型队列[/size]
//节点类
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]http://dl2.iteye.com/upload/attachment/0091/7370/0eabf44c-6b03-3ac6-8d53-c63fc66dd61f.png[/img]
[/img]
[size=medium] 综上可以看出利用数组实现的队列访问比较便利，而利用链表实现的队列则是增删比较方便，两种队列都各有千秋，实际运用的时候还得看对数据处理的需求。[/size]
[size=medium]3.简单的二叉树[/size]
//节点类
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]http://dl2.iteye.com/upload/attachment/0091/7391/0b97fe7a-a1a6-3149-8ccb-01136dac056f.png[/img]
[/img]
[size=large] 本人文笔不好，描述若有不当之处，敬请见谅！[/size]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
