>>向着CTO前进>>

包含：插入排序，选择排序，冒泡排序，快速排序，归并排序class Solution {     public static void main(String[] args) {         int[] arr = {3,6,7,3,1,6,2,5,5,4};         //insertSort(arr);         //bubbleSort(arr);

为了能够充分地使用数组中的存储空间，把数组的前端和后端连接起来，形成一个环形的顺序表，即把存储队列元素的表从逻辑上看成一个环，称为环形队列，也叫循环队列。ps：1、队空条件：front==rear        2、队满条件：(rear+1)%maxSize == front   //少用一个空间，即最多放maxSize-1个元素。        3、初始化时front=rear=0；

public class LinkedQueue { QueueHead qh = new QueueHead(); boolean empty() { return qh.front == null; //or qh.rear == null } void enQueue(int e) { QNode q = new QNode(e); if(empt

public class SqString { char[] data; int length; SqString() { data = new char[30]; length = 0; } SqString(String s) { data = new char[30]; for(int i=0; i<s.length(); i++) { data[i

public class MaxChildStr { public static void main(String[] args) { process(new String("zzzzxxxfffr")); process(new String("zzzzxxxfffrrrrr")); process(new String("zzzzxxxxxfffrrr")); p

问题描述：         n个人编号为1~n，围成一个圈，从第一个人开始报数，123123。。。，报到3的人被踢出，如此循环，直到最后剩下一个人，请问这个人的编号是多少？？方法一：数组解法import java.util.Scanner;public class Joseph { int[] arr; Joseph(int e) { arr = new

问题描述：        n个人站成一排，编号为1~n，现在从左向右报数“1,2,1,2.。。。”，报到1的人出列，报到2的人立即站到队伍的最后，如此循环往复，直到n个人全部出列为止。public class LinkedQueue { QueueHead qh = new QueueHead(); boolean empty() { return qh.front

一、定义           广义表简称表，它是线性表的推广。一个广义表是n个元素的一个序列，n=0时称为空表。设ai为广义表的第i个元素，则广义表GL表示为：                GL=（a1, a2, a3, ........,an）           如果ai是单个数据元素，则ai是广义表GL的原子；如果ai是一个广义表，则ai是广义表GL的子表。二、特性

public class Main { public static void main(String[] args) { UFSTree[] u = new UFSTree[11]; makeSet(u); union(u, 2, 4); union(u, 5, 7); union(u, 1, 3); union(u, 8, 9); union(u, 1, 2);

0、废话 一直ym传说中的kmp算法能以最坏线性的时间复杂度搞定字符串匹配，开始动手看才知道kmp中的K居然是Donald.E.Knuth，《计算机程序设计艺术》的作者。好吧，继续ym……1、传统的字符串匹配算法/* * 从s中第sIndex位置开始匹配p * 若匹配成功，返回s中模式串p的起始index * 若匹配失败，返回-1 */int

public class BinaryTree { public static void main(String[] args) { int[] data = new int[10]; for(int i = 0; i < data.length; i++) { data[i] = (int)(Math.random() * 100) + 1; System.out.prin

public class Main { public static void main(String[] args) { int[] arr = {0, 2, 1, 5, 8, 2, 4, 3, 7, 6, 5}; heapSort(arr, arr.length - 1); for(int i = 1; i < arr.length; i++) { System.out.pr

public class Main { public static void main(String[] args) { int[] arr = {0, 2, 1, 5, 8, 2, 4, 3, 7, 6, 5}; shellSort(arr, arr.length); for(int i = 0; i < arr.length; i++) { System.out.print

我的输入测试树为：ABC#D###EF##G##，这是按照先序创建二叉树的可是我的程序中返回双亲结点：char Parent(BiTree T,ElemType e)              返回左孩子  ：char Leftchild(BiTree T,ElemType e)              返回左孩子  ：char Rightchild(BiTree T,ElemT

public class Main { static int num=0; public static void main(String[] args) { int[] arr = {4, 1, 8, 2, 3, 7, 6, 5}; Node root = new Node(arr[0]); for(int i=1; i<arr.length; i++) { root.s

B-tree树即B树，B即Balanced，平衡的意思。因为B树的原英文名称为B-tree，而国内很多人喜欢把B-tree译作B-树，其实，这是个非常不好的直译，很容易让人产生误解。如人们可能会以为B-树是一种树，而B树又是另一种树。而事实上是，B-tree就是指的B树。特此说明。BST树       即二叉搜索树：       1.所有非叶子结

public class SqQueue { int[] data; int front, rear; SqQueue() { data = new int[30]; front = rear = -1; } boolean empty() { return front == rear; } boolean enQueue(int e) { if(rear ==

import java.util.Scanner;public class Cartesian { public HList list = new HList(); public void create() { System.out.print("表的行数和列数: "); Scanner sc = new Scanner(System.in); list.row = sc.n

#笨方法O(n^2)#数较少时，遍历一个数组，其值放到HashSet，再遍历另一个数组。O(n)#数多时，用BitSet,构造方法new BitSet();new BitSet(n);n为可能的最大整数，默认下，所有初始值为false。BitSet bs = new BitSet();for(int i=0; i<arr1.length; i++) {

题干：先输入两个值，代表矩阵的宽和长，再依次输入矩阵中的值，只能是0或1，最后求矩阵中最大正方形的边长，该正方形里面要全是1。如： 3 4       0 0 0 0       0 1 1 0       0 1 1 0输出：2import java.util.*; public class Main {     public static void main(S

public class findMaxChildArray { public static void main(String[] args) { //int[] arr = new int[]{5,-4,2,3,7,-1, -4, 3, 6,-8,6}; int[] arr = new int[]{-5,-4,2,3,7,-1, -4, 3, 6,-8,6}; //int[]

import java.util.regex.Matcher;import java.util.regex.Pattern;public class RegexTest { /** * @param args */ public static void main(String[] args) { // 测试是否为合法的身份证号码 String[] strs = {

一、基本术语节点的度和树的度：树中某个节点的子树的个数称为该节点的度。树中各节点的度的最大值称为树的度，通常将度为m的树称为m次树。分支节点和叶子节点：度不为0的节点称为非终端节点，也叫分支节点。度为0的节点为终端节点或叶子节点。路径和路径长度：路径长度等于路径所通过的节点数目减1。显然从树的根节点到树中其余节点均存在唯一路径。孩子节点、双亲节点、兄弟节点、子孙节点、祖先节点节点的层次

一、定义          二叉树也叫二分树，是有限节点的集合，这个集合要么为空，要么是由一个根节点和两颗互不相交的称为左子树和右子树的二叉树组成。注意：二叉树和度为2的树（2次树）是不同的，其差别在：1、度为2的树中至少有一个节点的度为2，而二叉树没有这个要求；2、度为2的树不区分左右子树，而二叉树是严格区分左右子树的。满二叉树：如果所有分支节点都有左右孩子，并且叶子

public class RenMingBi { private static final char[] data = new char[]{ '零','壹','贰','叁','肆','伍','陆','柒','捌','玖' }; private static final char[] units = new char[]{ '元','拾','佰','仟','万','拾','佰'

public class Test { public static void main(String[] args) { System.out.println(new Test().sqrt(13)); } int sqrt(int x ){ int left = 1, right = x/2+1; int last_mid=0; while(left<=right){

一、逻辑结构类型集合、线性结构、树形结构、图形结构。其中集合表示数据元素之间没有任何关系，树形结构和图形结构都是非线性结构。二、存储结构类型顺序存储结构、链式存储结构、索引存储结构、散列（哈希）存储结构。三、算法的特性有穷性、确定性、可行性、有输入、有输出。算法与程序不同，程序可能不满足有穷性，即可能无穷循环，但是算法必须满足有穷性。四、算法

public class SqList { private int[] data; private int length; public SqList() { data = new int[30]; length = 0; } public boolean empty() { return length == 0; } public int length() {

1

public class LinkList { public Node head; public LinkList() { head = new Node(); head.next = null; } //尾插法 public void createByTail(int[] arr, int n) { Node tail = head; for(int i=0; i

public class LinkedStack { Node head = new Node(); boolean empty() { return head.next == null; } void push(int e) { Node n = new Node(e); n.next = head.next; head.next = n; } int[]

public class SqStack { public int[] data; public int top; public SqStack() { data = new int[20]; top = -1; } public boolean empty() { return top == -1; } public boolean push(int e) {

public class DoubleLinkedList { public Node head; public DoubleLinkedList() { head = new Node(); head.next = null; head.prior = null; } //尾插法 public void createByTail(int[] arr, int n) {

1 .基本概念AVL树的复杂程度真是比二叉搜索树高了整整一个数量级——它的原理并不难弄懂，但要把它用代码实现出来还真的有点费脑筋。下面我们来看看：1.1  AVL树是什么？AVL树本质上还是一棵二叉搜索树（因此读者可以看到我后面的代码是继承自二叉搜索树的），它的特点是：1. 本身首先是一棵二叉搜索树。 2. 带有平衡条件：每个结点的左右子树的高度之差的绝对值（平