哦绝影

public class MergeSort { /* * 归并排序，依次把大小为n的数组分解求和 * 1.数组的起始位置p,找到元素的终止位置r=n-1,找到中间元素q=(p+r)/2，从p---q成一个分割数组a1，(q+1)---r分割成另一个数组a2 * 2.把数组a和数组b重复1的方式，直到p>=r时返回 * 3.返回时合并子数组a1和a2,申请一个大小为r+1的临时数组保存,重复2和3步骤合并 */ public void mergeSort(Intege..

import java.util.Random;public class LinkBubble { public Node head; private Integer num; public void init(int num,Node node) { this.num=num; this.head=node; } class Node{ private Integer data; private Node next; } /*使用尾插发创建链表.

package data.sort;public class SelectSort { public static void sort(Integer[] a) { //将a[]按升序排列 int N=a.length; for (int i=0;i<N;i++) { int mi...

package data.sort;public class InsertSort { public static void sort(Integer[] a) { //将a[]按升序排列 int N=a.length; for (int i=1;i<N;i++) { int va...

package data.sort;public class BubbleSort { //错误：这种方法如果有一段是有序的会导致重复判断 public static void sort(Integer[] a) { //将a[]按升序排列 int N=a.length; for (int i=0;i<N;i+...

package data.structure.stack;import data.structure.link.Node;public class LinkStack { public Node head; public Node tail; public LinkStack(Node head) { this.head=head; ...

package data.structure.stack;public class OrderStack { public int head=0;//队头 public int tail=0;//队尾 public int items[];//数组 public int n;//队列大小 public OrderStack(int n) { item...

package data.structure.heap;import data.structure.link.Node;public class LinkHeap { public Node head; public Node tail; public LinkHeap(Node head) { this.head=head; ...

package data.structure.heap;public class OrderHeap { public int count=0;//栈中元素个数 public int n;//栈的大小 public int items[];//数组 public OrderHeap(int n) { this.n=n; items=new int[...

package data.structure.link;public class BidirectionalLink { private int num; private Node head; public BidirectionalLink(int num,Node head) { this.num=num; this.head=head; } /* * 尾插法...

package data.structure.link;public class CycleLink { private int num; private Node head; public CycleLink(int num,Node head) { this.num=num; this.head=head; } /* * 尾插法 */ public void...

单链表的两种创建方式：头插法尾插法package data.structure;class Node{ public int data;//数据域 public Node next;//指针域}public class LinkList { private int num; private Node head; public LinkList(int num,Nod...

四、实验内容编写程序，实现顺序队列的创建、入队和出队等基本操作算法。(1) 创建包含任意个元素的顺序队列。(2) 入队一个任意元素。(3) 取队首元素并输出。(4) 出队一个任意元素。*(5) 删除队列中值为给定值的元素。*(6) 利用顺序栈实现顺序对列元素的逆置  #include    #include    #include#define ok

编写程序，实现顺序栈的创建、进栈和出栈等基本操作算法。(1) 创建包含任意个元素的顺序栈。(2) 进栈一个任意元素。(3) 出栈一个任意元素。(4) 取栈顶元素并输出。*(5) 删除栈中值为给定值的元素。*(6) 利用顺序表实现顺序栈元素的逆置。       #include    #include    #include    #include  

https://blog.csdn.net/jianyuerensheng/article/details/512583741、基本思想：快速排序是我们之前学习的冒泡排序的升级，他们都属于交换类排序，都是采用不断的比较和移动来实现排序的。快速排序是一种非常高效的排序算法，它的实现，增大了记录的比较和移动的距离，将关键字较大的记录从前面直接移动到后面，关键字较小的记录从后面直接移动到前面，从而减少了...

package com.pan;import java.util.Scanner;public class InsertSort { public static long starttime; public static long endtime; //插入排序 public static void insertSort(int b[],int a[],int i) {...

给出一个字符串数组 S，写一个函数找到其中所有的乱序字符串（Anagram）。如果一个字符串是乱序字符串，那么它存在一个字母集合相同，但顺序不同的字符串也在S中。package com.pan;import java.util.HashSet;import java.util.Hashtable;import java.util.Map;import java.util.Sc

1、A、B两人分别在两座岛上。B生病了，A有B所需要的药。C有一艘小船和一个可以上锁的箱子。C愿意在A和B之间运东西，但东西只能放在箱子里。只要箱子没被上锁，C都会偷走箱子里的东西，不管箱子里有什么。如果A和B各自有一把锁和只能开自己那把锁的钥匙，A应该如何把东西安全递交给B？答案：A把药放进箱子，用自己的锁把箱子锁上。B拿到箱子后，再在箱子上加一把自己的锁。箱子运回A后，

package com.te; public class Testte{ public void fun(int a[]) { for(int i=0;i<a.length/2;i++) { int t; t=a[i]; a[i]=a[a.length-1-i]; a[a.length-1-i]=t; }

1.常见的很容易理解的求阶层package ee;import java.util.Scanner;public class Rucursive { int sum=1; public int compute(int n) { if(n==0) { return 1; } return sum=n*compute(--n); } public s

package com.hanwei;import java.util.ArrayList;import java.util.HashSet;import java.util.List;import java.util.Random;import java.util.Scanner;import java.util.Set;/* * * 2.数组a[N]中，随机存放了1至N

“基数排序对要排序的数据是有要求的，需要可以分割出独立的“位”来比较，而且位之间有递进的关系，如果 a 数据的高位比 b 数据大，那剩下的低位就不用比较了。除此之外，每一位的数据范围不能太大，要可以用线性排序算法来排序，否则，基数排序的时间复杂度就无法做到 O(n) 了。”package data.sort.line;public class CardinalitySort { public static String[] countSort(String b[],int index) {

“计数排序只能用在数据范围不大的场景中，如果数据范围 k 比要排序的数据 n 大很多，就不适合用计数排序了。而且，计数排序只能给非负整数排序，如果要排序的数据是其他类型的，要将其在不改变相对大小的情况下，转化为非负整数。比如，还是拿考生这个例子。如果考生成绩精确到小数后一位，我们就需要将所有的分数都先乘以 10，转化成整数，然后再放到 9010 个桶内。再比如，如果要排序的数据中有负数，数据的范围是[-1000, 1000]，那我们就需要先对每个数据都加 1000，转化成非负整数。”package d

package data.sort.line;public class SumNum { public static void bubbleSort(Integer a[],int num){ Integer r[]=new Integer[79]; int index=0; for (int i = 0; i < a.length; i++) { if(r[a[i]]==null){ .

package data.sort.list;public class FastSortTwo { public void mergeSort(Integer a[],int left,int right,int num) { if(left>right) { return; } //每次通过findIndex得到的位置index上的元素都是它在数组排序中应该在的位置，如果要查找第几个最大值，就可以判断num和index是否相等，返回相等时的a[ind.

package data.sort.list;public class FastSortTwo { public void mergeSort(Integer a[],int left,int right) { if(left>right) { return; } int index=findIndex(a,left,right); mergeSort(a, left,index-1);//分解 mergeSort(a, index+1,righ.

public class FastSort { public void mergeSort(Integer a[],int left,int right) { if(left>right) { return; } int index=findIndex(a,left,right); mergeSort(a, left,index-1);//分解 mergeSort(a, index+1,right);//分解 } /*1.取最后一个元素..

import java.util.Random;public class LinkBubbleModifyNodeValue { public Node head; private Integer num; public void init(int num,Node node) { this.num=num; this.head=node; } class Node{ private Integer data; private Node next; } .

import java.util.Random;public class LinkInsert { public Node head; private Integer num; public void init(int num, Node node) { this.num = num; this.head = node; } class Node { private Integer data; private Node next; } /* 使用尾插发创建链表 *.

import java.util.Scanner;/** * *//** * @author jueying: * @version 创建时间：2018-10-18 下午10:54:54 * 类说明 *//** * @author jueying * */public class Test2 { public void fun(char...

package com;//选择排序public class Selectsort { /* * 思想： * 1.找一个基准元素作为最小值（通常选第一个），把该元素的数组下标给一个变量min * 2.依次和其它元素比较，如果有比它还小的元素，那么就把比它小的元素的数组下标给min * 3.然后把min和初始的基准元素下标比较，如果发现不一样，那么就说明其它元素有比基准元素小...

/** * */package com;import org.apache.lucene.document.Field.Index;/** * @author 绝影 * */public class Quirtsort { /* * 思想：类似分治 * 1.找一个基准元素index * 2.从前往后依次查找，如果有比基准元素大的元素则和基准元素交换,低位用...

package com.pan;import java.util.Scanner;public class A { public static long starttime; public static long endtime; //冒泡排序 public static void bubbleSort(int b[],int a[]) { for(int i

package com.pan;import java.util.Scanner;public class InsertSort { public static long starttime; public static long endtime; //返回每趟找到的最小数位置 static int selectMini(int a[],int i) { int

//题目：如果需要筹够101元，现在有面值为 2元，3元，5元的硬币，显然不能用贪心算法，如果使用贪心算法101%5==1，那么就无法拼成101元//所以我们使用动态规划来解决，动态规划有点类似分治法的思想和递归思想，不同的是在递归思想中每次的结果是确定的，而动态规划的本次的结果//都是前面某次的结果和本次可用硬币中最优解的一种方式，而不一定是它的上一次。动态规划每次要求得到的是最优解

一.JDBC连接(mysql驱动包) Class.forName("com.mysql.jdbc.Driver"); Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/bumen?characterEncoding=utf8","root","123456");

方法一代码：package test;import java.util.Scanner;import java.util.regex.Matcher;import java.util.regex.Pattern;public class ResearchMaxnum { //冒泡法 public ResearchMaxnum(double a[],int r){ d

/** * *//** * @author jueying: * @version 创建时间：2018-10-22 下午01:32:44 * 类说明 *//** * @author jueying * */public class Test4 { /* * 把两个有序数组合并成一个有序数组，实现算法的复杂度为n * * 同理如...

import java.util.Scanner;/** * *//** * @author jueying: * @version 创建时间：2018-10-24 下午08:52:14 * 类说明 *//** * @author jueying * */public class Main { int top=-1;//栈顶指针 int ...