最近活不多,借此来制作属于自己的一套工具类,先从数据结构和算法开始,下面上代码
/**
* 单向链表
* @author TMACJ
*
*
*/
public class LinkedList {
private int size = 0;
private Node head;//头指针(不含数据域)
public LinkedList() {
this.head = new Node(null, null, null);
}
/**
* 增
* @param node
*/
public void insert(Node node){
this.insert(node, this.size);
}
/**
* 增
* @param node
* @param position
*/
public void insert(Node node,int position){
Node tempNode = moveCursor(position);
//设置节点指针指向
node.setPrevious(tempNode);
node.setNext(tempNode.getNext());
Node next = tempNode.getNext();
if(next!=null){
next.setPrevious(node);
}
tempNode.setNext(node);
this.size++;
}
/**
* 删
* @param position
*/
public void delete(int position){
position++;
Node tempNode = moveCursor(position);
Node previous = tempNode.getPrevious();
Node next = tempNode.getNext();
if(previous!=null){
previous.setNext(tempNode.getNext());
}
if(next!=null){
next.setPrevious(tempNode.getPrevious());
}
this.size--;
}
/**
* 改
* @param node
* @param position
*/
public void update(Node node,int position){
position++;
Node tempNode = moveCursor(position);
Node previous = tempNode.getPrevious();
Node next = tempNode.getNext();
if(previous!=null){
previous.setNext(node);
}
if(next!=null){
next.setPrevious(node);
}
node.setPrevious(previous);
node.setNext(next);
}
/**
* 查
* @param position
* @return
*/
public Node select(int position){
position++;
Node tempNode = moveCursor(position);
return tempNode;
}
public Node moveCursor(int position){
int i = 0;
Node tempNode = head;
while(i<position){
tempNode = tempNode.getNext();
i++;
}
return tempNode;
}
public void iterator(){
int i = 0;
Node tempNode = head;
while(i<this.getSize()){
tempNode = tempNode.getNext();
i++;
System.out.println(tempNode.getData());
}
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
public Node getHead() {
return head;
}
public void setHead(Node head) {
this.head = head;
}
}
/**
* 插入排序(升序)
* @author TMACJ
*思路:先取一个有序的队列,然后将其他数字一个一个和这个有序数列排序
*稳定
*时间复杂度 最好情况:O(n) 最坏情况O(n²)
*空间复杂度 O(n)
*/
public class StraightInsertionSort {
public static void sort(LinkedList ll){
//把第一数据当成一个有序的一组,然后把其他的数据依次插入比较
for(int i=1;i<ll.getSize();i++){
for(int j=0;j<i;j++){
if((int)ll.select(i).getData()<(int)ll.select(j).getData()){
int temp = (int)ll.select(j).getData();
ll.select(j).setData(ll.select(i).getData());
ll.select(i).setData(temp);
}
}
}
}
}
/*测试类*/
public class Test{
public static void main(String[] args) {
LinkedList ll = new LinkedList();
ll.insert(new Node(null, null, 10));
ll.insert(new Node(null, null, 9));
ll.insert(new Node(null, null, 8));
ll.insert(new Node(null, null, 7));
ll.insert(new Node(null, null, 6));
ll.insert(new Node(null, null, 5));
ll.insert(new Node(null, null, 4));
ll.insert(new Node(null, null, 3));
ll.insert(new Node(null, null, 2));
ll.insert(new Node(null, null, 1));
StraightInsertionSort.sort(ll);
ll.iterator();
}
}
输出结果:
1
2
3
4
5
6
7
8
9
10
/**
* 希尔排序(直接插入排序的改良算法,升序)
* @author TMACJ
* 时间复杂度O(n^2)(这里虽然有4个循环,但是while和for之间是没有联系的,所以时间复杂度还是O(n^2))
* 空间复杂度(1)
* 希尔排序利用插入排序对于基本有序的数列高效的特点,先选取增量d,然后在进行直接插入排序,达到提升效率的目的
* 然而,对于增量如何选取,目前也没有什么太好的办法,好像数学界还没解决这个问题..我就不浪费时间了
* 一般而言,第一次的增量选择采用N/2
*/
public class ShellSort {
public static void sort(LinkedList ll){
int n = ll.getSize();
int d = n/2;
while(d!=0){
int i = 0;
while(i<d){
for(int j=1;j<ll.getSize();j=j+d){
for(int k=0;k<j;k=k+d){
if((int)ll.select(j).getData()<(int)ll.select(k).getData()){
int temp = (int)ll.select(k).getData();
ll.select(k).setData(ll.select(j).getData());
ll.select(j).setData(temp);
}
}
}
i++;
}
d = d/2;
}
}
}