各种小算法

最新推荐文章于 2022-05-07 10:24:54 发布

头发不够长

最新推荐文章于 2022-05-07 10:24:54 发布

阅读量164

点赞数 1

分类专栏：算法文章标签：算法

本文链接：https://blog.csdn.net/weixin_44318626/article/details/92843901

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

快速排序

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>();
}

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();
}
}
}

头发不够长

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
各种小算法

**快速排序**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) ...
复制链接

扫一扫

专栏目录