数据结构的java实现

-------------------------单向链表

 1 //自制单向链表
 2 class MyList {
 3     private Cell head;
 4     private int length;
 5     class Cell {
 6         private String data;
 7         private Cell next;
 8         public Cell(String data) {
 9             this.data = data;
10         }
11     }
12     public void add(String data) {
13         Cell c = new Cell(data);
14         Cell tail = getTail();
15         if (tail == null) {
16             head = c;
17         } else {
18             tail.next = c;
19         }
20         this.length++;
21     }
22     public int size() {
23         return this.length;
24     }
25     public Cell getTail() {
26         if (head == null) {
27             return null;
28         }
29         Cell p = head;
30         while (p.next != null) {
31             p = p.next;
32         }
33         return p;
34     }
35     public String get(int index) {
36         if (index >= this.length) {
37             throw new IndexOutOfBoundsException("下标越界");
38         }
39         Cell p = head;
40         for (int i = 0; i < index; i++) {
41             p = p.next;
42         }
43         return p.data;
44     }
45 }
46 public class Demo {
47     public static void main(String[] args) {
48         MyList list = new MyList();
49         list.add("lala");
50         list.add("hehe");
51         list.add("haha");
52         list.add("heihei");
53         System.out.println(list.size());
54         for (int i = 0; i < list.size(); i++) {
55             System.out.println(list.get(i));
56         }
57     }
58 }

---------------------二叉树

 1 /**
 2  * 自定义二叉树,存放int型数据 中序排列
 3  */
 4 class MyTree {
 5     // 定义树根
 6     private Node root;
 7     // 定义二叉树节点
 8     class Node {
 9         private int data;// 存放数据
10         private Node left;// 左子树地址
11         private Node right;// 右子树地址
12         public Node(int data) {
13             // 初始化成员变量
14             this.data = data;
15             this.left = this.right = null;
16         }
17         /**
18          * 根据规则，把节点添加到二叉树中
19          * 
20          * @param n
21          *            节点
22          */
23         public void add(Node n) {
24             // 首先比较data的大小，大于根节点放在右边，小于根节点放在左边
25             if (this.data > n.data) {
26                 if (this.left != null) {
27                     this.left.add(n);
28                 } else {
29                     this.left = n;
30                 }
31             } else {
32                 if (this.right != null) {
33                     this.right.add(n);
34                 } else {
35                     this.right = n;
36                 }
37             }
38         }
39         public void bianLi() {
40             if (this.left != null) {
41                 this.left.bianLi();
42             }
43             System.out.println(this.data);
44             if (this.right != null) {
45                 this.right.bianLi();
46             }
47         }
48     }
49     /**
50      * 定义add方法
51      * 
52      * @param data
53      *            要存放的数据
54      */
55     public void add(int data) {
56         // 实例化一个节点
57         Node n = new Node(data);
58         // 添加到二叉树中,首先判断树是否存在，如果不存在，就把这个节点当做根节点
59         // 如果存在，调用Node的add方法，将节点添加进去
60         if (this.root == null) {
61             this.root = n;
62         } else {
63             this.root.add(n);
64         }
65     }
66     public void bianLi() {
67         if (this.root == null) {
68             System.out.println("空");
69         } else {
70             this.root.bianLi();
71         }
72     }
73 }
74 public class Demo3 {
75     public static void main(String[] args) {
76         MyTree tree = new MyTree();
77         for (int i = 0; i < 20; i++) {
78             int num = (int) (Math.random() * 100 + 1);
79             tree.add(num);
80         }
81         tree.bianLi();
82     }
83 }

-------------------------双向链表

  1 //双向链表
  2 class LinkedList {
  3     private Node head;
  4     private Node tail;
  5     /**
  6      * 定义构造方法，初始化头结点和尾结点。
  7      */
  8     public LinkedList() {
  9         head = new Node("Head");
 10         tail = new Node("Tail");
 11         head.next = tail;
 12         tail.prev = head;
 13     }
 14     /**
 15      * 定义结点类
 16      */
 17     class Node {
 18         private String data;
 19         private Node prev;
 20         private Node next;
 21         public Node(String data) {
 22             this.data = data;
 23             this.prev = this.next = null;
 24         }
 25     }
 26     /**
 27      * 从头结点插入，每次都是在头结点之后插入
 28      * 
 29      * @param data
 30      *            结点数据
 31      */
 32     public void addFirst(String data) {
 33         Node n = new Node(data);
 34         n.prev = head;
 35         n.next = head.next;
 36         head.next = n;
 37         n.next.prev = n;
 38     }
 39     /**
 40      * 从尾结点插入
 41      * 
 42      * @param data
 43      *            结点数据
 44      */
 45     public void addTail(String data) {
 46         Node n = new Node(data);
 47         n.next = tail;
 48         n.prev = tail.prev;
 49         tail.prev = n;
 50         n.prev.next = n;
 51     }
 52     /**
 53      * 得到链表的size
 54      * @return int 链表的size
 55      */
 56     public int size() {
 57         Node p = head.next;
 58         int count = 0;
 59         while (true) {
 60             if (p.next == null) {
 61                 break;
 62             }
 63             p = p.next;
 64             count++;
 65         }
 66         return count;
 67     }
 68     /**
 69      * 得到指定位置的数据
 70      * @param index int 索引
 71      * @return String 指定索引处的数据
 72      */
 73     public String get(int index) {
 74         if (index >= this.size() || index < 0) {
 75             throw new IndexOutOfBoundsException("下标越界");
 76         }
 77         Node p = head.next;
 78         for (int i = 0; i < index; i++) {
 79             p = p.next;
 80         }
 81         return p.data;
 82     }
 83 }
 84 // 双向循环链表
 85 class DoubleLinkedList {
 86     // 定义头结点
 87     private Node head;
 88     private int length;
 89     public DoubleLinkedList() {
 90         this.head = null;
 91         this.length = 0;
 92     }
 93     class Node {
 94         private String data;
 95         private Node prev;
 96         private Node next;
 97         public Node(String data) {
 98             this.data = data;
 99             this.prev = this.next = this;
100         }
101     }
102     // 顺序添加到链表
103     public void add(String data) {
104         // 实例化节点
105         Node n = new Node(data);
106         // 得到最后一个节点
107         Node last = getLast();
108         if (last == null) {
109             head = n;
110         } else {
111             // 总共修改四个值，最后一个节点的next，新加节点的prev和next，头结点的prev
112             last.next = n;
113             n.prev = last;
114             n.next = head;
115             head.prev = n;
116         }
117         this.length++;
118     }
119     public Node getLast() {
120         if (this.length == 0) {
121             return null;
122         }
123         return head.prev;
124     }
125     public int size() {
126         return this.length;
127     }
128     public String get(int index) {
129         Node n = head;
130         if (index < 0 || index > length - 1) {
131             throw new IndexOutOfBoundsException("下标越界");
132         }
133         for (int i = 0; i < index; i++) {
134             n = n.next;
135         }
136         return n.data;
137     }
138 }
139 public class Demo4 {
140     public static void main(String[] args) {
141         DoubleLinkedList dll = new DoubleLinkedList();
142         dll.add("lala");
143         dll.add("hehe");
144         dll.add("jaja");
145         dll.add("fafa");
146         System.out.println(dll.size());
147         for (int i = 0; i < dll.size(); i++) {
148             System.out.print(dll.get(i) + " ");
149         }
150         System.out.println();
151         LinkedList ll = new LinkedList();
152         ll.addFirst("11");// 首插入
153         ll.addFirst("22");// 首插入，然后"11"后移
154         ll.addTail("33");// 尾插入
155         ll.addTail("44");// 尾插入，"33"前移
156         System.out.println(ll.size());
157         for (int i = 0; i < ll.size(); i++) {
158             System.out.print(ll.get(i) + " ");
159         }
160     }
161 }

------------------------------树的Map实现

  1 import java.util.ArrayList;
  2 import java.util.HashMap;
  3 import java.util.List;
  4 import java.util.Map;
  5 /**
  6  * 利用Map实现树型结构 1.能获得子节点 2.能获取父节点 3.能获取兄弟节点 4.能获取祖先节点 5.能获取子孙节点
  7  */
  8 class MyTree {
  9     private Map<String, String> map;// 基础Map
 10     private Map<String, List<String>> map2;// 为了查找子节点方便创造的Map
 11     public MyTree() {
 12         this.map = new HashMap<String, String>();
 13         this.map2 = new HashMap<String, List<String>>();
 14     }
 15     /**
 16      * 添加数据到Map中
 17      * 
 18      * @param child
 19      *            子节点
 20      * @param parent
 21      *            父节点
 22      */
 23     public void add(String child, String parent) {
 24         this.map.put(child, parent);
 25         List<String> list = this.map2.get(parent);
 26         if (list == null) {// 如果list为空，说明map2没有parent这个key值
 27             list = new ArrayList<String>();
 28             this.map2.put(parent, list);
 29         }
 30         list.add(child);
 31     }
 32     /**
 33      * 通过传递child，得到map中的元素
 34      * 
 35      * @param child
 36      *            子节点
 37      * @return 父节点
 38      */
 39     public String getParent(String child) {
 40         return this.map.get(child);
 41     }
 42     /**
 43      * 通过传递过来的父节点，得到map2中的子节点集合
 44      * 
 45      * @param parent
 46      *            父节点
 47      * @return 子节点集合
 48      */
 49     public List<String> getChild(String parent) {
 50         return this.map2.get(parent);
 51     }
 52     /**
 53      * 通过传递的节点，先找到该节点的父节点，然后找到父节点的所有子节点集合，最后在集合中remove该节点
 54      * @param node 节点
 55      * @return 兄弟节点集合
 56      */
 57     public List<String> getBrother(String node) {
 58         if("root".equals(node)) return null;
 59         String parent = this.getParent(node);
 60         List<String> node2 = new ArrayList<String>();
 61         node2.add(node);
 62         List<String> child = this.getChild(parent);
 63         List<String> brother = new ArrayList<String>(child);
 64         brother.removeAll(node2);
 65         return brother;
 66     }
 67     /**
 68      * 通过传递过来的子节点，迭代查找父节点，得到这个子节点的所有祖先集合
 69      * 
 70      * @param child
 71      *            子节点
 72      * @return 祖先集合
 73      */
 74     public List<String> getAncestor(String child) {
 75         // ancestor 祖先
 76         List<String> list = new ArrayList<String>();
 77         String parent = getParent(child);
 78         if (parent == null) {
 79             return list;
 80         }
 81         list = getAncestor(parent);
 82         list.add(parent);
 83         return list;
 84     }
 85     /**
 86      * 通过传递过来的父节点，迭代查找子节点，构成子节点集合
 87      * 
 88      * @param parent
 89      *            父节点
 90      * @return 子孙节点集合
 91      */
 92     public List<String> getDescendant(String parent) {
 93         // descendant 子孙，后裔
 94         List<String> list = new ArrayList<String>();
 95         List<String> child = getChild(parent);
 96         if (child == null)
 97             return list;
 98         for (int i = 0; i < child.size(); i++) {
 99             List<String> temp = getDescendant(child.get(i));
100             list.add(child.get(i));
101             list.addAll(temp);
102         }
103         return list;
104     }
105 }
106 public class Demo02 {
107     public static void main(String[] args) {
108         MyTree mt = new MyTree();
109         mt.add("互联网", "root");
110         mt.add("百度", "互联网");
111         mt.add("阿里巴巴", "互联网");
112         mt.add("腾讯", "互联网");
113         mt.add("百度一下", "百度");
114         mt.add("百度糯米", "百度");
115         mt.add("百度云", "百度");
116         mt.add("淘宝", "阿里巴巴");
117         mt.add("天猫", "阿里巴巴");
118         mt.add("支付宝", "阿里巴巴");
119         mt.add("QQ", "腾讯");
120         mt.add("微信", "腾讯");
121         mt.add("腾讯游戏", "腾讯");
122         mt.add("云PC", "百度云");
123         mt.add("云手机", "百度云");
124         mt.add("余额宝", "支付宝");
125         mt.add("天弘基金", "支付宝");
126         mt.add("CF", "腾讯游戏");
127         mt.add("毒奶粉", "腾讯游戏");
128         mt.add("警察", "CF");
129         mt.add("匪徒", "CF");
130         mt.add("暴风骑兵", "毒奶粉");
131         mt.add("黑暗帝君", "毒奶粉");
132         mt.add("剑皇", "毒奶粉");
133         mt.add("铿锵玫瑰", "毒奶粉");
134         mt.add("复仇者", "毒奶粉");
135         System.out.println("得到毒奶粉的父节点：");
136         System.out.println(mt.getParent("毒奶粉"));
137         System.out.println("----------------------------");
138         System.out.println("得到毒奶粉的子节点：");
139         List<String> list = mt.getChild("毒奶粉");
140         for (String string : list) {
141             System.out.println(string);
142         }
143         System.out.println("----------------------------");
144         
145         System.out.println("得到毒奶粉的兄弟：");
146         List<String> list2 = mt.getBrother("毒奶粉");
147         for (String string : list2) {
148             System.out.println(string);
149         }
150         System.out.println("----------------------------");
151         System.out.println("得到毒奶粉的祖先：");
152         List<String> list3 = mt.getAncestor("毒奶粉");
153         for (String string : list3) {
154             System.out.println(string);
155         }
156         System.out.println("----------------------------");
157         String str = "腾讯";
158         System.out.println("得到" + str + "的子孙：");
159         // 首先得到节点的所有子孙节点
160         List<String> list4 = mt.getDescendant(str);
161         // 得到该节点的祖先深度
162         int length = mt.getAncestor(str).size();
163         for (String string : list4) {
164             // 得到每一个节点的祖先深度，然后减去起始节点的祖先深度，for循环输出--。构成树型结构
165             List<String> temp = mt.getAncestor(string);
166             for (int i = 0; i < temp.size() - length; i++) {
167                 System.out.print("--");
168             }
169             System.out.println(string);
170         }
171         System.out.println("----------------------------");
172     }
173 }

----------------------------------

 posted on 2015-09-02 10:58  码农xk  阅读(282)  评论(0)  编辑  收藏  举报