数据结构算法,算法,java算法,算法大全

boolean res = true;
if (o1 instanceof Comparable) {
Comparable c1 = (Comparable)o1;
Comparable c2 = (Comparable)o2;
if (pareTo(c2) < 0) {
res = false;
}
} else {
if (o1.toString().compareTo(o2.toString()) < 0) {
res = false;
}
}
return res;
}
5、对双链表的操作
public class DoubleLink implements Iterable{
Comparable c1 = (Comparable) o1;
Comparable c2 = (Comparable) o2;
if(pareTo(o2) < 0){
temp = false;
}
}else{
if(o1.toString().compareTo(o2.toString()) < 0){
Node node = find(oldData);
if(node != null){
node.data = newData;
}
updata(oldData,newData);
}
//按值查找出值相同的节点，并返回这个节点
public Node find(Object data){
Comparable c2 = (Comparable)o2;
if (pareTo(c2) < 0) {
res = false;
}
} else {
if (o1.toString().compareTo(o2.toString()) < 0) {
1、冒泡排序
思想：： 从小到大排序（把每次比较的最大值依次从最后一个依次往前放，并且每次都是这个数据和它的下一个比较）
//冒泡排序算法
public static void maoPao(Object[] datas){
for(int i = 0; i < datas.length; i++){
if(!compare(datas[j], data)){
index = j;
data = datas[j];
}
}
if(index > i){
datas[index] = datas[i];
datas[i] = data;
temp = false;
}
}
return temp;
}
2、选择排序
思想：： 从小到大排序（在数据里找到最小的放到最前，依次从前到后的数据里找到最小的依次从前向后放）
//选择排序算法
public static void xuanZe(Object[] datas){
//如果datas[j]大于等于temp,即temp小于等于他前一个位置的值，则把datas[j]值移到下一位
datas[j + 1] = datas[j];
} else {//如果datas[j]小于temp，即temp大于他前一个位置的值，则把temp放到datas[j]值下一位
//取出第i+1个数据
Object temp = datas[i];
//从最后一个排好序的数据开始循环
int j = i - 1;
for (; j >= 0; j--) {
//如果第j+1个数据
if (compare(datas[j],temp)) {
Node node = head;
while(node != null){
if(node.data.equals(data) && node.data.hashCode()==data.hashCode())
Comparable c1 = (Comparable)o1;
Comparable c2 = (Comparable)o2;
if(pareTo(o2) < 0){
temp = false;
}
}else{
if(o1.toString().compareTo(o2.toString()) < 0 ){
res = false;
}
}
return res;
}
4、快速排序：：：
思想：： 从小到大排序（先和最后一个以标准值，前指针从前向后找到标准值的前一个位置，后指针从后向前找到指针的后一个位 置，标准值的前指针从标准值的前一个位置找到开始位置，标准值的后指针从后一个位置找到结束位置，）
if (from >= end) {
return;
} else {
int middle = sort1(datas,from,end);
sort(datas,from,middle - 1);
sort(datas,middle + 1, end);
}
//定义两个数据交换的方法
private static void trans(Object[] datas,int a,int b){
Object data = datas[b];
datas[b] = datas[a];
datas[a] = data;
}
//排序
public static void sort(Object[] datas,int from ,int end){
}
}
}
//自己做的比较器true: o1 > o2 false: o1 < o2
public static boolean compare(Object o1, Object o2){
boolean temp = true;
if(o1 instanceof Comparable){
datas[j + 1] = temp;
break;
}
}
if (j == -1) {//如果是最小值，就放到第一个位置
datas[0] = temp;
}
}
}
//自己做的比较器true o1 >= o2 false o1 < o2
if(node == head && node == rear){
head = null;
rear = null;
}else if(node == head){
head = node.next;
head.priv = null;
}else if(node == rear){
temp = false;
}
}
return temp;
}
3、插入排序
思想：： 从小到大排序（）
//插入排序
public static void insertSort(Object[] datas){
//从第二个数据开始取
for (int i = 1; i < datas.length; i++) {
trans(datas,left,end);
middle = left;
break;
}
}
return middle;
}
//自己做的比较器true o1 >= o2 false o1 < o2
private static boolean compare(Object o1, Object o2){
trans(datas,left,right);
continue;
} else { // left = end , right == from - 1; left < end and right >= from
//trans(left,end); trans(left,end); trans(left,end);
}
//算法
public static int sort1(Object[] datas,int from,int end){
int middle = 0;
Object data = datas[end];
int left = from - 1;
int right = end ;
while (true) {
while (++left < end && !compare(datas[left],data) );
while (--right >= from && compare(datas[rபைடு நூலகம்ght],data) );
if (left < right) {
Object data = null;
int index = 0;
for( int i = 0; i < datas.length; i++){
index = i;
data = datas[i];
for(int j = i; j < datas.length; j++){
private static boolean compare(Object o1, Object o2){