1.链表
package javakaoyan;
public class LinkList<T> {
/**
* @param args//链表的实现
*/
//结点定义
private class Node{
//数据
T item;
//指向下一个结点
Node next;
//构造器
public Node(T item,Node next){
this.item=item;
this.next=next;
}
public Node(T item){
this.item=item;
}
}
private Node head;//头结点
private Node tail;//尾结点
private int size;//结点个数
//链表定义
public LinkList(){
this.head=new Node(null,null);
size=0;
}
//查找指定位置的链表结点
public Node get(int index){
if(index<0||index>=this.size){
return null;
}else{
Node temp=this.head;
for(int i=1;i<=index;i++){
temp=temp.next;
}
return temp;
}
}
//链表插入数据
public void add(T data)
{
Node temp =new Node(data);
//链表为空
if(this.size==0){
head=temp;
tail=head;
}
else{
Node last=tail;
last.next=temp;
this.tail=temp;
}
this.size++;
}
//在链表的第i个位置插入一个值为t数据
public void insert(int index,T data) throws Exception{
if(index<0||index>this.size){
throw new Exception("插入超出范围");
}
else{
Node newNode=new Node(data);
//在头结点插入元素
if(index==0){
if(this.size>0){
Node temp=head;
newNode.next=temp;
}
head=newNode;
}
//尾结点插入
else if(index==this.size){
Node temp=tail;
temp.next=newNode;
this.tail=newNode;
}else{
//在中间插入元素
Node preNode=get(index-1);
Node nextNode=preNode.next;
newNode.next=nextNode;
preNode.next=newNode;
}
}
this.size++;
if(size==1){
tail=head;
}
}
//删除指定位置数据
public void del(int index) throws Exception{
if(index<0||index>this.size){
throw new Exception("删除超出范围");
} else{
//删除头结点
if(index==0){
Node temp=this.head.next;
this.head=temp;
}
//删除尾结点
else if(index==this.size-1){
Node preNode=get(index-1);
this.tail=preNode;
preNode.next=null;
}else{
//删除中间结点
Node preNode=get(index-1);
Node nextNode=preNode.next.next;
preNode.next=nextNode;
}
}
this.size--;
}
//移除末尾元素,并返回对应数据
public T remove() throws Exception{
if(this.size==0){
System.out.println("链表为空,无法移除");
}
//只有一个元素,移除后为空
if(this.size==1){
T data=this.head.item;
this.head=null;
this.tail=this.head;
this.size--;
return data;
}else{
Node preNode=get(this.size-2);
T data=this.tail.item;
preNode.next=null;
this.tail=preNode;
this.size--;
return data;
}
}
//删除特定元素的一个位置
public boolean deleteData(T data){
boolean flag=false;
if(this.size==0){
return flag;
}else{
Node curNode=this.head;
//元素位于第一个结点
if(curNode.item==data){
Node nextNode=curNode.next;
head=nextNode;
flag=true;
//当前只有一个结点
if(this.size==1){
tail=head;
}
this.size--;
}else{
while(curNode!=null){
Node nextNode=curNode.next;
if(nextNode!=null&&nextNode.item==data){
//删除元素为尾结点
if(nextNode.next==null){
this.tail=curNode;
curNode.next=null;
}else{
//删除结点为中间结点
Node temp=curNode.next.next;
curNode.next=temp;
}
flag=true;
this.size--;
break;
}
curNode=curNode.next;
}
}
}
return flag;
}
public void printLinklist(){
if(this.size==0){
System.out.println("链表为空");
}
else{
Node temp=head;
System.out.println("目前的链表,头结点"+head.item+",尾结点"+tail.item+",整体:");
while(temp!=null){
System.out.println(temp.item+",");
temp=temp.next;
}
System.out.println();
}
}
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
LinkList linklist=new LinkList();
linklist.add("2");
linklist.del(0);
linklist.printLinklist();
linklist.insert(0, "a");
System.out.println("删除的元素为:"+linklist.remove());
linklist.insert(0, "2");
linklist.insert(1, "3");
linklist.add("3");
linklist.printLinklist();
linklist.del(1);
linklist.printLinklist();
linklist.insert(1, "1");
linklist.insert(0, "0");
linklist.insert(2, "0");
linklist.del(2);
linklist.printLinklist();
linklist.deleteData(3);
linklist.printLinklist();
}
}
2.线性表
package javakaoyan;
import java.util.Arrays;
public class xianxinbiao {
/**
* @param args
* 线性表:代码表示:(用数组的方法)
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
xianxinbiao b=new xianxinbiao(10);
b.insert(20);
b.insert(20);
b.insert(20);
b.insert(20);
b.insert(20);
b.insert(20);
b.insert(20);
b.insert(20);
b.insertS(3, 60);
System.out.println(Arrays.toString(b.getItem()));
}
private Object[] listItem;//存储位置
private int curlen;//长度
private int maxSize;//最大容量
//线性表初始化
xianxinbiao(int maxSize){
this.maxSize=maxSize;
this.listItem=new Object[maxSize];
this.curlen=0;
}
//顺序插入值
public void insert(Object data){
if(curlen==maxSize){//每次插入值后满容量
System.out.println("线性表已满");
}
else{
listItem[curlen]=data;
curlen++;//加完后改变线性表长度
}
}
public int getCurlen(){
return this.curlen;
}
//顺序表指定位置插入
public void insertS(int index,Object data){
if(curlen==maxSize){System.out.println("线性表已满");}
else{
for(int i=curlen;i>index;i--){
listItem[i]=listItem[i-1];
}
listItem[index]=data;
curlen++;
}
}
//删除指定位置元素
public void deleteS(int index){
//顺序表往前移,最后删掉一格
for(int i=index;i<this.curlen;i++){
this.listItem[i]=this.listItem[i+1];
}
this.curlen--;//删完后要改变顺序表长度
}
//删除所以元素
public void deleteAll(){
this.curlen=0;
}
//获取顺序表数据
public Object[] getItem(){
return this.listItem;
}
}
3.给定一个数值(可以带负号),计算从i到j的和,求最大值以及i和j
例如 -1 1 -5 66 -7 -3 -1 66 99 -138 -124 4
package zhenti;
public class zhenti202301 {
/**
* @param args
* 1.给定一个数值(可以带负号),计算从i到j的和,求最大值以及i和j
例如 -1 1 -5 66 -7 -3 -1 66 99 -138 -124 4
求时间复杂度
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a={-1, 1, -5, 66, -7, -3, -1, 66, 99, -138, -124, 4};
//int[] a={-1, 1, 66,-11};
int max=a[0]+a[1];
int sum=0;
int b=0,c=1;
for(int i=0;i<a.length-1;i++){
sum=a[i];
for(int j=i+1;j<a.length;j++){
sum=a[j]+sum;
if(sum>max){
max=sum;
b=i;
c=j;
}
}
sum=0;
}
System.out.println("该数组的从第"+b+"到"+c+"的总和最大,最大值:"+max);
//时间复杂度:O(n²)
}
}
4.递归题,给一个x,y,如果x能整除y,这确定y为x的最大公约数
如果x不能整除y,这用y和(x,y)的余数来继续执行,直到x能整除y
package zhenti;
import java.util.Scanner;
public class zhenti202302 {
/**
* @param args
* 2.递归题,给一个x,y,如果x能整除y,这确定y为x的最大公约数
如果x不能整除y,这用y和(x,y)的余数来继续执行,直到x能整除y
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int x,y;
System.out.println("请输入除数x和除数y:");
Scanner scanner=new Scanner(System.in);
x=scanner.nextInt();
y=scanner.nextInt();
System.out.println("除数的结果:"+digui(x,y));
}
static int digui(int x,int y){
int temp;
if(x%y==0){
return y;
}
else{
temp=x%y;
return(digui(y,temp));
}
}
}
5.文件
package zhenti;
import java.io.*;
public class zhenti202304 {
/**
* @param args
* 4.文件题,给一个大的定义和大量数据,如葡萄酒里的指标,然后用文件方法来判断
(1)这个葡萄酒里的数字对应的指标类型(数字小数:指标1, 数字整数:指标2 数字小数整数混合:指标3),写到文件里去
(2)对于某个具体类型,取最大最小值
(4)如果文件确实,如何弥补
0.8 0.2 0.4 0.5 0.1 0.4 0.6 0.1
1 0.3 0.77 0.81 0.6 0.1 0.12 0.23
a b c d e f g h
0.8 0.2 0.4 0.5 0.1 0.4 0.6 0.1
1 0.3 0.77 0.81 0.6 0.1 0.12 0.23
0.8 0.2 0.4 0.5 0.1 0.4 0.6 0.1
1 0.3 0.77 0.81 0.6 0.1 0.12 0.23
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
double[][] str={{1,0.3,0.77,0.81,0.6,0.1,0.12,0.23},{0.1,0.3,0.77,0.81,0.6,0.1,0.12,0.23},
{1,2,3,4,5,6,7,8}};
System.out.println(str.length);
File file=new File("F://game/zhenti202304.txt");
try{
FileWriter fo=new FileWriter(file);
BufferedWriter fb=new BufferedWriter(fo);
for(int i=0;i<str.length;i++){
for(int j=0;j<str[0].length;j++){
fb.write(Double.toString(str[i][j])+" ");
}
fb.newLine();
}
for(int i=0;i<str.length;i++){
int t=0;
if(t<str[0].length&&str[i][t]>1){
t++;
}
fb.write("第"+i+"行为:指标"+t);
fb.newLine();
}
fb.close();
fo.close();
}
catch(IOException e){
System.out.println(e);
}
}
}
6.线程
package zhenti;
public class zhenti202305 {
/**
* @param args
* 从ATM里取款,要求(1)可以多用户取款,但同一时间的一个用户只能被一个人取款
(2)如果取款小于用户的账户余额,则进入等待状态
(3)当用户的余额大于存款时,从等待状态中唤醒,然后继续操作。
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
bankThread b1=new bankThread("123456",100);
new bankgetMoney("甲",b1,800).start();
new bankgetMoney("乙",b1,1000).start();
new bankgetMoney("丙",b1,100).start();
}
}
class bankThread {
String name;
double number;
bankThread(String name,double number){
this.name=name;
this.number=number;
}
public synchronized void draw(double number1){
if(number>=number1){
System.out.println(Thread.currentThread().getName()+"取钱成功:"+number1);
try{
Thread.sleep(300);
}catch(InterruptedException e){
e.printStackTrace();
}
number=number-number1;
System.out.println("余额"+number);
}
else{
synchronized(Thread.currentThread()){
try{
Thread.currentThread().wait(1000);
}catch(InterruptedException e){
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"取钱失败");
}
}
}
class bankgetMoney extends Thread{
private bankThread bankThread;
private double money;
bankgetMoney(String name,bankThread bankThread,double money){
super(name);
this.bankThread=bankThread;
this.money=money;
}
public void run(){
bankThread.draw(money);
}
}