复习数据结构

public class Test_01 {
    static class Node {
        Node parent;
        Node left;
        Node right;
        String content;
        boolean visited;
        Node(String content) {
            this.content = content;
        }

        void setLeft(Node left) {
            this.left = left;
            left.parent = this;
        }

        void setRight(Node right) {
            this.right = right;
            right.parent = this;
        }
    }

    public static void main(String[] args) {
        Node na = new Node("A");
        Node nb = new Node("B");
        Node nc = new Node("C");
        Node nd = new Node("D");
        Node ne = new Node("E");
        Node nf = new Node("F");
        Node ng = new Node("G");
        Node nh = new Node("H");
        Node ni = new Node("I");

        na.setLeft(nb);
        na.setRight(nc);

        nb.setLeft(nd);
        nb.setRight(ne);

        nc.setLeft(nf);
        nc.setRight(ng);

        ne.setLeft(ni);
        nf.setLeft(nh);

        test1(na);
        System.out.println();
        System.out.println("==========================");
        test2(na);
        System.out.println();
        System.out.println("==========================");
        test3(na);
        System.out.println();
        System.out.println("==========================");
        test4(na);
        System.out.println();
        System.out.println("==========================");
        test5(na);
        System.out.println();
        System.out.println("==========================");
        test6(na);
    }

    private static void test1(Node root) {
        if (root != null) {
            System.out.print(root.content+",");
            test1(root.left);
            test1(root.right);
        }
    }

    private static void test2(Node root) {
        if (root != null) {
            test2(root.left);
            System.out.print(root.content+",");
            test2(root.right);
        }
    }

    private static void test3(Node root) {
        if (root != null) {
            test3(root.left);
            test3(root.right);
            System.out.print(root.content+",");
        }
    }

    private static void test4(Node root) {
        Stack<Node> stack = new Stack<Node>();
        Node current = root;
        while (current != null || !stack.isEmpty()) {
            while (current != null) {
                stack.push(current);
                current = current.left;
            }
            current = stack.peek();
            stack.pop();
            System.out.print(current.content+",");
            current = current.right;
        }
    }

    private static void test5(Node root) {
        Stack<Node> stack = new Stack<Node>();
        Node current = root;
        while (current != null || !stack.isEmpty()) {
            while (current != null) {
                System.out.print(current.content+",");
                stack.push(current);
                current = current.left;
            }
            current = stack.peek();
            stack.pop();
            current = current.right;
        }
    }

    private static void test6(Node root) {
        Stack<Node> stack = new Stack<Node>();
        Node current = root;
        while (current != null || !stack.isEmpty()) {
            while (current != null) {
                stack.push(current);
                current = current.left;
            }
            current = stack.peek();
            stack.pop();
            if (!current.visited) {
                current.visited = true;
                stack.push(current);
                current = current.right;
            } else {
                System.out.print(current.content+",");
                current = null;
            }
        }
    }
}
时间: 2024-10-15 01:18:13

复习数据结构的相关文章

复习数据结构:排序(一)——插入排序

从这一篇开始,我开始复习数据结构的知识点,博文主要偏重于每个知识点的核心思想,以及代码实现.这一篇先从排序算法中的插入排序开始. 稳定排序.内排序.适合少量数据量的排序. 当输入数组已经排好序时,插入排序需要O(n),快排需要O(n^2). 当输入数组倒序排列时,插入排序时复为:O(n^2). 平均时间复杂度:O(n^2). 插入排序的基本做法是:将一个数插入到一个已经排列好的数组中,通过移动这个数的位置,使得插入之后的数组也是有序的,不断重复这个过程,使得最终所有的数都是有序的. 实现代码如下

复习数据结构:排序算法(一)——插入排序

从这一篇开始,计划复习一下数据结构的基本知识.一来是为了开年之后的找工作,二来是为了想提升自己的编程能力.由于这些数据结构知识点,之前都学习过,这里我们就提炼出每个知识点的核心,以及代码实现. 这篇先说排序算法中的插入排序. 插入排序是一种稳定排序算法,属于内排序.适合少量数据量的排序. 当输入数组已经排好序时,插入排序需要O(n),快排需要O(n^2). 当输入数组倒序排列时,插入排序时复为:O(n^2). 平均时间复杂度:O(n^2). 代码实现如下: #include<iostream>

复习数据结构:排序算法(二)——冒泡排序

这篇复习冒泡排序.     冒泡排序也是一种稳定排序.内排序. 冒泡排序的基本思想:对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒.即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换. 插入排序比冒泡排序快! 上面说的是普通的冒泡排序算法,时间复杂度是O(n^2),这种方法只能一趟排序操作只能找到一个最大值或最小值,消耗时间太多.     改进方法1:我们可以让每趟排序中进行正向和反向两遍冒泡的方法,一次就可以同时得到

复习(数据结构):链表:c语言:练习

库函数 #include "stdio.h" #include "string.h" #include "ctype.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define

复习数据结构:排序算法(五)——快速排序的各种版本

之前已经比较熟悉快排的基本思想了,其实现的方式也有很多种.下面我们罗列一些常见的实现方式: 版本一:算法导论上的单向扫描,选取最后一个元素作为主元 #include<iostream> using namespace std; int partition(int data[], int low, int high) { int pivot = data[high]; // let the last atom be the pivot int i = low - 1; // mark the p

复习数据结构:排序算法(四)——归并排序

基本思想:基于分治法,即把待排序的数组序列,分为若干个子序列,对每个子序列排序,然后再把所有有序的子序列合并为一个整体有序的序列.分析可知,如果拿任何一个元素作为子序列,那么所有子序列就已经是有序的,而归并排序的关键就在于如何合并,也就是"归并". 归并排序是外排序,稳定排序,时间复杂度是O(nlogn). 详细说归并排序的过程:1个元素的表总是有序的.所以对n个元素的待排序列,每个元素可看成1个有序子表.对子表两两合并生成n/2个子表,所得子表除最后一个子表长度可能为1 外,其余子表

复习数据结构:排序(三)——选择排序

选择排序的核心是:每趟选择最小的元素和首部交换. 时间复杂度:O(n^2). 选择排序是一种不稳定的排序,为什么呢?因为不好处理相等两个数的前后位置,举个例子,序列5 8 5 2 9, 我们知道第一遍选择第1个元素5会和2交换,那么原序列中2个5的相对前后顺序就被破坏了,所以选择排序不是一个稳定的排序算法.所以稳定排序是一定不会改变相等数之间之前位置关系的. 实现代码如下: #include<iostream> using namespace std; void SelectSort(int

【复习数据结构】单链表的操作

#include <stdio.h> #include <malloc.h> typedef char ElemType; typedef struct LNode{ //定义单链表结点类型 ElemType data; //数据域 struct LNode *next; //指针域 }LNode,*LinkList; /** * 头插法初始化链表 **/ LinkList CreateListhead(void){ char ch; LinkList L; //初始化链表 LNo

复习数据结构:排序算法(七)——桶排序

桶排序是一种稳定的排序方法,也是一种外排序. 桶排序的时间复杂度:最坏情况运行时间:当分布不均匀时,全部元素都分到一个桶中,则O(n^2),当然[算法导论8.4-2]也可以将插入排序换成堆排序.快速排序等,这样最坏情况就是O(nlgn).最好情况运行时间:O(n). 也就说,前面介绍的排序算法要么是O(n^2),要么是O(nlogn),只有桶排序是可能实现O(n)排序的,但是对数据是有要求的. 基本思想:是将阵列分到有限数量的桶子里.每个桶子再个别排序(有可能再使用别的排序算法或是以递回方式继续