java实现常见的数据结构

线性查找

package org.xx.demo1;

public class LinearSearch {
	public static void main(String[] args){
		int[] arr = new int[]{1,2,12,312,12131,2112,21};
		int target = 312;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i]==target) {
				System.out.println(i);
				break;
			}
		}	
	}
}

数组的增删改查

package org.xx.demo1;
import java.util.Arrays;
public class MyArray {
	private int[] arr;
	public MyArray(){
		arr = new int[0];
	}
	public int getsize(){
		return arr.length;
	}
	public void add(int element){
		int[] newarr = new int[arr.length+1];
		for (int i = 0; i < arr.length; i++) {
			newarr[i] = arr[i];
		}
		newarr[arr.length] = element;
		arr = newarr;
	}
	public void index(int index,int element){
		int[] newarr = new int[arr.length+1];
		for (int i = 0; i < newarr.length; i++) {
			if (i<index) {
				newarr[i]=arr[i];
			}else if (i>index) {
			
				newarr[i] = arr[i-1];
			}	
		}
		newarr[index] = element;
		arr=newarr;
	}
	public void delete(int index){
		if (index<0|index>arr.length-1) {
			throw new RuntimeException("下标越界");
		}else {
			int[] newarr = new int[arr.length-1];
			for (int i = 0; i < newarr.length; i++) {
				if (i<index) {
					newarr[i] = arr[i];
				}else {
					newarr[i] = arr[i+1];
				}
			}
			arr= newarr;
		}		
	}
	public void show(){
		System.out.println(Arrays.toString(arr));
	}
	public int getelement(int index){
		if (index<0|index>arr.length-1) {
			throw new RuntimeException("下标越界");
		}
		return arr[index];
	}
	public void set(int index,int element){
		if (index<0|index>arr.length-1) {
			throw new RuntimeException("下标越界");
		}
		arr[index] = element;
	}
	//线性查找
	public int search(int element){
		for (int i = 0; i < arr.length; i++) {
			if (arr[i]==element) {
				return i;
			}
		}
		return -1;
	}
	//二分查找
	public int binarySearch(int target){
		//开始位置
		int begin = 0;
		//结束位置
		int end = arr.length-1;
		//中间位置
		int mid = (begin+end)/2;	
		//循环查找
		while(true){
			//先判断元素是否存在于数组中
			if (target<arr[begin]||target>arr[end]||begin>end) {
				return -1;
			}
			if (target==arr[mid]) {
				return mid;
			}else{
				if (target<arr[mid]) {
					end=mid-1;
				}else{
					begin=mid+1;
				}
				mid=(begin+end)/2;
			}
		}
	}
}

链表

package org.xx.demo2;

public class Node {
	private int data;
	Node next;
	public Node(int data){
		this.data = data;
	}
	public Node append(Node node){
		//当前节点
		Node currentNode = this;
		//循环向后找
		while(true){
			//取出下一个节点
			Node nextNode = currentNode.next;
			//如果当前节点的下一个节点为空，那么则跳出循环
			if (nextNode==null) {
				break;
			}
			//赋值给当前节点
			currentNode = nextNode;
		}
		//把需要追加的节点追加到当前节点的下一个节点
		currentNode.next = node;
		return currentNode;
	}
	//获取下一个节点
	public Node next(){
		return this.next;
	}
	//获取节点中的数据
	public int getData(){
		return this.data;
	}
	//当前节点是否是最后一个节点
	public boolean isLast(){
		return next==null;
	}
	//获取所有节点
	public void show(){
		Node currentNode = this;
		while(true){
			System.out.print(currentNode.data+" ");
			currentNode = currentNode.next;
			if (currentNode==null) {
				break;
			}
		}
		System.out.println();
	}
	//删除下一个节点
	public void removeNext(){
		Node newNext = this.next.next;
		this.next = newNext;
		
	}
	//插入节点
	public void insertNode(Node node){
		Node currentNode = this;
		Node nextNode = currentNode.next;
		currentNode.next = node;
		node.next = nextNode;
	}
}

循环链表

package org.xx.demo2;
public class LoopNode {
	private int data;
	LoopNode next=this;
	public LoopNode(int data){
		this.data = data;
	}
	
	//获取下一个节点
	public LoopNode next(){
		return this.next;
	}
	//获取节点中的数据
	public int getData(){
		return this.data;
	}
	
	//删除下一个节点
	public void removeNext(){
		LoopNode newNext = this.next.next;
		this.next = newNext;
		
	}
	//插入节点
	public void insertNode(LoopNode node){
		LoopNode currentNode = this;
		LoopNode nextNode = currentNode.next;
		currentNode.next = node;
		node.next = nextNode;
	}
}

双向循环链表

package org.xx.demo2;
public class DoubleLoop {
	//上一个节点
	DoubleLoop pre = this;
	//下一个节点
	DoubleLoop next = this;
	private int data;
	public DoubleLoop(int data){
		this.data = data;
	}
	public void insert(DoubleLoop node){
		//原来的下一个节点
		DoubleLoop nextNode = next;
		//把新节点作为当前节点的下一个节点
		this.next = node;
		//把当前节点作为新节点的前一个节点
		node.pre = this;
		//把原来的下一个节点作为新节点的下一个节点
		node.next = nextNode;
		//把新节点作为原来的下一个节点的前一个节点
		nextNode.pre = node;		
	}
	public DoubleLoop next(){
		return this.next;
	}
	public DoubleLoop pre(){
		return this.pre;
	}
	public int getData(){
		return this.data;
	}
}

栈

package org.xx.demo2;
public class MyStack {
	private int[] elements;
	public MyStack(){
		elements = new int[0];
	}
	public void push(int element){
		int[] newarr = new int[elements.length+1];
		for (int i = 0; i < elements.length; i++) {
			newarr[i] = elements[i];
		}
		newarr[elements.length] = element;
		elements = newarr;
	}
	public int pop(){
		//判断栈是否为空
		if (elements.length==0) {
			throw new RuntimeException("Stack is empty");
		}
		//取出栈顶元素
		int element = elements[elements.length-1];
		//更新栈内元素
		int[] newarr = new int[elements.length-1];
		for (int i = 0; i < elements.length-1; i++) {
			newarr[i] = elements[i];
		}
		elements = newarr;
		return element;
	}
	//查看栈顶元素
	public int peek(){
		if (elements.length==0) {
			throw new RuntimeException("Stack is empty");
		}
		return elements[elements.length-1];
	}
	//判断栈是否为空
	public boolean isEmpty(){
		return elements.length==0;
	}
}

队列

package org.xx.demo2;
public class MyQueue {
	private int[] elements;
	public MyQueue(){
		elements = new int[0];
	}
	//入队
	public void add(int element){
		int[] newarr = new int[elements.length+1];
		for (int i = 0; i < elements.length; i++) {
			newarr[i] = elements[i];
		}
		newarr[elements.length] = element;
		elements = newarr;
	}
	//出队
	public int poll(){
		int element = elements[0];
		int[] newarr = new int[elements.length-1];
		for (int i = 0; i < newarr.length; i++) {
			newarr[i] = elements[i+1];
		}
		elements = newarr;
		return element;
	}
	//判断队列是否为空
	public boolean isEmpty(){
		return elements.length==0;
	}
}