**
快速排序
**
public class QuickSort {
public static void quickSort(int[] arr,int low,int high){
int i,j,temp,t;
if(low>high){
return;
}
i=low;
j=high;
//temp就是基准位
temp = arr[low];
while (i<j) {
//先看右边,依次往左递减
while (temp<=arr[j]&&i<j) {
j--;
}
//再看左边,依次往右递增
while (temp>=arr[i]&&i<j) {
i++;
}
//如果满足条件则交换
if (i<j) {
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
//最后将基准为与i和j相等位置的数字交换
arr[low] = arr[i];
arr[i] = temp;
//递归调用左半数组
quickSort(arr, low, j-1);
//递归调用右半数组
quickSort(arr, j+1, high);
}
public static void main(String[] args){
int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
quickSort(arr, 0, arr.length-1);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
输出为
1
2
2
3
4
4
7
7
8
9
10
19
62
**
冒泡排序
**
public class BubbleSort {
public void bubbleSort(Integer[] arr, int n) {
if (n <= 1) return; //如果只有一个元素就不用排序了
for (int i = 0; i < n; ++i) {
// 提前退出冒泡循环的标志位,即一次比较中没有交换任何元素,这个数组就已经是有序的了
boolean flag = false;
for (int j = 0; j < n - i - 1; ++j) { //此处你可能会疑问的j<n-i-1,因为冒泡是把每轮循环中较大的数飘到后面,
// 数组下标又是从0开始的,i下标后面已经排序的个数就得多减1,总结就是i增多少,j的循环位置减多少
if (arr[j] > arr[j + 1]) { //即这两个相邻的数是逆序的,交换
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = true;
}
}
if (!flag) break;//没有数据交换,数组已经有序,退出排序
}
}
public static void main(String[] args) {
Integer arr[] = {2, 4, 7, 6, 8, 5, 9};
SortUtil.show(arr);
BubbleSort bubbleSort = new BubbleSort();
bubbleSort.bubbleSort(arr, arr.length);
SortUtil.show(arr);
}
}
**
手写ArrayList
**
public class MyArraylist {
//数组容器,jdk中默认大小为10
private Object[] objects = new Object[3];
//初始大小
private int size = 0;
//数组的添加方法
public void add(Object obj){
//判断是否索引大于容器容量,如果大于,则扩容(新建数组)arraylist支持的是1.5倍扩容
if(size >= objects.length){
//jdk中采用的是位运算,区别在于位运算效率更高
Object[] temp = new Object[size*3/2 + 1];
//核心方法,相当于数组的复制
System.arraycopy (objects,0,temp,0,objects.length);
objects = temp;
}
objects[size] = obj;
size++;
}
//集合的长度
public int length(){
return size;
}
//集合指定元素的赋值
public void set(int index,Object obj) throws Exception {
if(index <= size && index >= 0){
objects[index] = obj;
}else{
throw new Exception ("数组下标越界");
}
}
//获取指定下标的元素
public Object getValue(int index) throws Exception {
if(index > size || index < 0){
throw new Exception ("数组下标越界");
}
return objects[index];
}
//删除指定下标的元素
public Object remove(int index) throws Exception {
if(index > size || index < 0){
throw new Exception ("数组下标越界");
}
//要返回的元素
Object obj = objects[index];
//从删除元素的后一个位置开始复制,复制newIndex个(相当于数组的自我复制)
int newIndex = objects.length-1-index;
System.arraycopy (objects,index+1,objects,index,newIndex);
//复制完后,长度要减一
size--;
return obj;
}
//清空集合
public void clear(){
size = 0;
objects = new Object[3];
}
//测试方法
public static void main(String[] args) throws Exception {
MyArraylist ma = new MyArraylist ();
ma.add ("1");
ma.add ("2");
ma.add ("3");
ma.add ("4");
for (int i = 0;i < ma.length ();i++){
Object obj = ma.getValue (i);
System.out.println (obj);
}
**
手写LinkedList
**
package com.weichai.linkedlist;
import java.util.LinkedList;
/**
* 手写LinkeList
* 底层实现是一个双向链表
-
@author linhaiy
-
@date 2019.02.12
-
@param
*/
public class ExtLinkedList <E> {class Node {
Node prev; // 上一个节点
Object object; // 节点内容
Node next; // 下一个节点
}private Node first; // 第一个元素
private Node last; // 最后一个元素
private int size; // 实际存放在长度/**
* 添加新的节点元素内容- @param e
*/
public void add(E e) {
Node node = new Node();
node.object = e;
if(first == null) {
first = node; // 第一个元素和最后一个元素都是为node
}else {
node.prev = last; // 存放上一个节点内容
last.next = node; // 设置上一个节点的next为当前节点
}
last = node;
size ++;
}
/**
* 在节点index位置添加节点Node元素-
@param index
-
@param e
*/
public void add(int index, E e) {
// 1.循环遍历到当前index位置Node
// 2.新增当前节点
Node newNode = new Node();
newNode.object = e;
// 3.获取原来的节点
ExtLinkedList<E>.Node oldNode = getNode(index); // 获取原来的节点
ExtLinkedList<E>.Node olNodePrev = oldNode.prev; // 获取原来上一个节点// 4.新增节点的上一个还是当前Node节点的 上一个节点,下一个就是原来的节点
// 原来上一个节点变为当前节点
oldNode.prev = newNode;
if(oldNode == null) {
first = newNode;
}else {
olNodePrev.next = newNode; // 原来上一个节点的下一个节点变为当前节点
}
newNode.next = oldNode; // 新节点的下一个节点为原来节点
size ++;
}
/**
* 获取节点某个位置的元素- @param index
- @return
*/
public E get(int index) {
Node node = getNode(index);
return (E) node.object;
}
/**
* 获取节点Node某个位置的元素- @param index
- @return
*/
public Node getNode(int index) {
// TODO Auto-generated method stub
Node node = null;
if(first !=null) {
node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
}
return node;
}
/**
* 移出节点某个位置的元素-
@param index
*/
public void remove(int index) {
checkElementIndex(index);
Node node = getNode(index);
if(node != null) {
Node prevNode = node.prev;
Node nextNode = node.next;
if (prevNode != null) { // 设置上一个节点的next为当前删除节点的next
prevNode.next = nextNode;
}// 判断是否是最后一个节点 if (nextNode != null) { nextNode.prev = prevNode; }
}
size --;
}
/**
* 判断当前位置是否在节点范围内- @param index
- @return
*/
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
/**
* 判断节点当前位置是否合法- @param index
*/
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(“越界啦!”);
}
public static void main(String[] args) {
ExtLinkedList<String> linkeList = new ExtLinkedList<String>();
linkeList.add(“A”);
linkeList.add(“B”);
linkeList.add(“C”);
linkeList.add(“D”);
linkeList.add(2, “E”);
for (int i = 0; i < linkeList.size; i++) {
System.out.println(linkeList.get(i));
}
// LinkedList<String> list = new LinkedList<String>();
} - @param e
LRU缓存淘汰算法
/**
-
类说明:利用LinkedHashMap实现简单的缓存, 必须实现removeEldestEntry方法,具体参见JDK文档
-
@author dennis
-
@param
-
@param
*/
public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {
private final int maxCapacity;private static final float DEFAULT_LOAD_FACTOR = 0.75f;
private final Lock lock = new ReentrantLock();
public LRULinkedHashMap(int maxCapacity) {
super(maxCapacity, DEFAULT_LOAD_FACTOR, true);
this.maxCapacity = maxCapacity;
}@Override
protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
return size() > maxCapacity;
}
@Override
public boolean containsKey(Object key) {
try {
lock.lock();
return super.containsKey(key);
} finally {
lock.unlock();
}
}@Override
public V get(Object key) {
try {
lock.lock();
return super.get(key);
} finally {
lock.unlock();
}
}@Override
public V put(K key, V value) {
try {
lock.lock();
return super.put(key, value);
} finally {
lock.unlock();
}
}public int size() {
try {
lock.lock();
return super.size();
} finally {
lock.unlock();
}
}public void clear() {
try {
lock.lock();
super.clear();
} finally {
lock.unlock();
}
}public Collection<Map.Entry<K, V>> getAll() {
try {
lock.lock();
return new ArrayList<Map.Entry<K, V>>(super.entrySet());
} finally {
lock.unlock();
}
}
}