一、冒泡排序
思想：反复走訪过要排序的序列。一次比較两个元素。假设他们的顺序错误就将他们进行交换，一次冒上来的是最小的，其次是第二小。
时间复杂度：O(n^2)
空间复杂度:O(1)
稳定性：稳定
1.
/**
* 冒泡排序
* @param disOrderArray
* @return
*/
public static int[] BubbleSort(int[] disOrderArray) {
int temp;
// 第一层循环:表明比較的次数, 比方 length 个元素,比較次数为 length-1 次（肯定不需和自己比）
for(int i=0;i<disOrderArray.length-1;i++)
{
// 把最小的数交换着"冒泡"的相对的最上边,一次冒上来的是最小的,其次是第二小的.
for(int j=disOrderArray.length-1;j>i;j--)
{
//此处为<时其返回是从小到大排序，>时其返回从大到小
if(disOrderArray[j] < disOrderArray[j-1])
{
temp = disOrderArray[j];
disOrderArray[j] = disOrderArray[j-1];
disOrderArray[j-1] = temp;
}
}
}
return disOrderArray;
}二、高速排序
思想：通过一趟排序将待排记录切割成两个部分，当中一部分记录keyword均比还有一部分记录的keyword小，则能够分别对这两部分keyword继续排序，以达到整个序列有序的目的。
时间复杂度：O(nlogn),最坏的情况下为O(n^2)
空间复杂度：O(1)
稳定性:不稳定
/*
*
* 高速排序
*
* 思想:
* 通过一趟排序将待排记录切割成独立的两部分,当中一部分记录的keyword均比还有一部分的keyword小,
* 则能够分别对这两部分记录继续进行排序,已达到整个序列有序的目的
*
* 本质就是,找一个基位(枢轴,分水岭,作用是左边的都比它小,右边的都比它大.可随机,取名base
* 首先从序列最右边開始找比base小的
* ,假设小,换位置,从而base移到刚才右边(比較时比base小)的位置(记为暂时的high位),这样base右边的都比base大
* 然后,从序列的最左边開始找比base大的
* ,假设大,换位置,从而base移动到刚才左边(比較时比base大)的位置(记为暂时的low位),这样base左边的都比base小
*
* 循环以上两步,直到 low == heigh, 这使才真正的找到了枢轴,分水岭. 返回这个位置,分水岭左边和右边的序列,分别再来递归
*/
public static int[] quickSort(int[] arr, int low, int heigh) {
if(low < heigh)
{
int division = partition(arr, low, heigh);
quickSort(arr, low, division - 1);
quickSort(arr, division + 1, heigh);
}
return arr;
}
// 分水岭,基位,左边的都比这个位置小,右边的都大
private static int partition(int[] arr, int low, int heigh) {
int base = arr[low]; //用子表的第一个记录做枢轴(分水岭)记录
while (low < heigh)
{
//更改以下两个while循环中的<=和>=。就可以获取到从大到小排列
//从表的两端交替向中间扫描，从小到大排列
while (low < heigh && arr[heigh] >= base)
{
heigh--;
}
// 假设高位小于base,base 赋值给 当前 heigh 位,base 挪到(互换)到了这里,heigh位右边的都比base大
swap(arr, heigh, low);
while(low < heigh && arr[low] <= base)
{
low++;
}
// 假设低位大有base,
swap(arr, heigh, low);
}
//如今low=heigh
return low;
}
//交换大小
private static void swap(int[] arr, int heigh, int low) {
int temp = arr[heigh];
arr[heigh] = arr[low];
arr[low] = temp;
}三、直接选择排序:
思想：每一趟排序将会选择出最小的(或者最大的)值。顺序放在已排好序的数列的后面
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：不稳定
/**
* 直接选择排序
* 直接选择排序每一趟选择出最小的值
* @param arr
* @return
*/
public static int[] selectionSort(int[] arr) {
for(int i=0;i<arr.length;i++)
{
for(int j=i+1;j<arr.length;j++)
{
if(arr[i] > arr[j])
{
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
return arr;
}四、堆排序
思想：堆排序利用这样的堆这样的数据结构所设计的一种排序算法，能够利用数组的特点高速定位指定索引的元素
时间复杂度：O(nlogn)
空间复杂度：O(1)
稳定性：不稳定
/**
* 堆排序
* 堆排序(Heapsort)是指利用堆这样的数据结构所设计的一种排序算法，能够利用数组的特点高速定位指定索引的元素。
* @param arr
* @return
*/
public static int[] heapSort(int[] arr) {
int i;
// 将arr构成一个大顶堆
// 从 0 到 arr.length/2 ,这些都是有孩子的节点
// 没孩子的节点构造大顶堆就无意义了
for (i = arr.length / 2; i >= 0; i--)
{
heapAdjust(arr, i, arr.length - 1);
}
for (i = arr.length - 1; i > 0; i--)
{
swap(arr, 0, i);
// 将arr[0...i-1] 又一次构造成一个大顶堆
heapAdjust(arr, 0, i - 1);
}
return arr;
}
private static void heapAdjust(int[] arr, int s, int m) {
int temp, j;
temp = arr[s]; // 指向暂时(相对与root节点)的根节点
for (j = 2 * s; j <= m; j *= 2)
{
// 假设右节点比左节点大,当前节点移到右节点
if (j < m && arr[j] < arr[j + 1])
{
// 指向右节点
j++;
}
// 当前的父节点大于如今指向的节点
// 不须要做不论什么处理
if (temp >= arr[j])
{
break;
}
// 当前的父节点小于其下的子节点
// 换位置,把这个子节点替换到父节点
// 当前这个位置,假设是叶子节点,则它应该是最小的(相对于它的祖先们)
// 这种方法目的就是交换parent与children的值,构造大根堆
// 运行到这里表明当前节点的父节点(暂时根节点小于当前的节点),
// 把当前节点移到上面,换位置
// arr[s]被覆盖无所谓,由于temp记了这个值(原来的根节点(相对的parent))
arr[s] = arr[j];
// 如今把当前的这个元素,看做是暂时的parent节点
// 为了找到此时这个元素的孩子节点,看看是否有比当前这个值还大的
// 最后s指向 当前遍历到的这个元素
s = j;
}
arr[s] = temp;
}
五、插入排序
思想：将一个记录插入到一个已排好序的有序表中，从而得到一个新的、记录增1的有序表。默认将第一个元素看为有序表，然后依次插入后边的元素
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定
/**
* 插入排序
* 思想:将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表，
* 默认将第一个元素看为有序表，一次插入后边的所欲元素
* 时间复杂度O(n^2)
* 空间复杂度O(1) 适用于记录数量小的
* @param arr
* @return
*/
public static int[] InsertSort(int[] arr) {
//从小到大排列
for(int i=1;i<arr.length;i++)
{
//待插入元素
int temp = arr[i];
int j;
for(j=i-1;j>=0 && temp < arr[j];j--)
{
//待插入元素小于已有的，就将已有往后挪，直到元素大于插入元素或已经到序列最首端了
arr[j+1] = arr[j];
}
arr[j+1] = temp;
}
return arr;
}六、折半插入排序
思想：折半插入排序是基于直接插入排序进行改写的，其能够降低"移动"和"比較"的次数
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定
/**
* 折半插入排序
* 长处:能够降低"比較"和"移动"的次数
* @param arr
* @return
*/
public static int[] BInsertSort(int[] arr){
for(int i=1;i<arr.length;i++)
{
//待插入元素
int temp = arr[i];
int j;
int low = 0, high = i-1;
while(low <= high) //在arr[low..high]中折半查找有序插入的位置
{
int m = (low + high)/2;//折半
if(temp < arr[m])
{
high = m-1; //插入点在低半区
}
else
{
low = m+1; //插入点在高半区
}
}
//记录后移
for(j=i-1;j>=high+1;j--)
{
arr[j+1] = arr[j];
}
arr[j+1] = temp;
}
return arr;
}七、希尔排序：
思想：希尔排序也是插入排序的一种，是直接针对插入排序进行改进的。该方法又称为"缩小增量排序"。
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：不稳定
/**
* 希尔排序(缩小增量排序)
* 希尔排序也是插入排序的一种，仅仅是其有增量，并且最后一次增量必须为1
* @param arr
* @return
*/
public static int[] ShellInsert(int[] arr){
int step = arr.length/2; //取增量
//保证最后一个增量为1
while(step >= 1)
{
for(int i=step;i<arr.length;i++)
{
int temp = arr[i];
int j = 0;
//根插入排序的差别在这里
for(j=i-step;j>=0 && temp<arr[j];j-=step)
{
arr[j+step] = arr[j];
}
arr[j+step] = temp;
}
step /= 2;
}
return arr;
}八、归并排序
思想：归并排序是将两个或两个以上的有序表组合成一个有序表，该算法是採用分治法实现
时间复杂度：O(nlogn)
空间复杂度：O(n)
稳定性：稳定
/**
* 归并排序
* 归并排序是将两个或两个以上的有序表组合成一个新的有序表
* 时间复杂度 O(nlog2n)
* @param arr
* @param tempArray
* @param left
* @param right
* @return
*/
public static int[] mergeSort(int[] arr, int left,int right) {
if (left < right)
{
// 取切割位置
int middle = (left + right) / 2;
// 递归划分数组左序列
mergeSort(arr, left, middle);
// 递归划分数组右序列
mergeSort(arr, middle+1, right);
//将左数组和右数组进行归并
Merge(arr, left, middle, right);
}
return arr;
}
private static void Merge(int[] arr, int left, int middle,int right) {
int[] tempArray = new int[arr.length];
int leftEnd = middle;
int rightStart = middle+1;
// 暂时数组的下标
int tempIndex = left;
int tmp = left;
// 先循环两个区间段都没有结束的情况
while ((left <= leftEnd) && (rightStart <= right))
{
// 左边的比右边的小,先插入左边的
if (arr[left] < arr[rightStart])
{
tempArray[tempIndex++] = arr[left++];
}
else
{
tempArray[tempIndex++] = arr[rightStart++];
}
}
// 推断左序列是否结束
while (left <= leftEnd)
{
tempArray[tempIndex++] = arr[left++];
}
// 推断右序列是否结束
while (rightStart <= right)
{
tempArray[tempIndex++] = arr[rightStart++];
}
// 将暂时数组中的内容拷贝回原数组中
// （原left-right范围的内容被复制回原数组）
while (tmp <= right) {
arr[tmp] = tempArray[tmp++];
}
}九、基数排序
思想：基数是依照低位先排序，然后收集；再按高位排序，然后再收集，依次类推，直到最高位。
注:表示关键词分类到radix(基数)个盒子，在关键词为数字时。基数为10。当关键词为字母时，基数为26
时间复杂度：O(n+d)
空间复杂度：O(n)
稳定性：稳定
/**
* 基数排序
* @radix 基数 表示 按关键词分类到radix(基数)个盒子 在关键词为数字时，基数为10
* @d 排序元素的位数
* @return
*/
public static int[] RadixSort(int[] arr, int radix, int d){
//用于暂存元素
int[] temp = new int[arr.length];
//用于计数排序
int[] count = new int[radix];
int divide = 1;
for(int i=0;i<d;i++)
{
System.arraycopy(arr, 0, temp, 0, arr.length);
// 重置count数组，開始统计下一个keyword
Arrays.fill(count, 0);
// 计算每一个待排序数据的子keyword
for(int j=0;j<arr.length;j++)
{
int tempKey = (temp[j]/divide)%radix;
count[tempKey]++;
}
for(int j=1;j<radix;j++)
{
count[j] = count[j] + count[j-1];
}
// 按子keyword对指定的数据进行排序
for(int j=arr.length-1;j>=0;j--)
{
int tempKey = (temp[j]/divide)%radix;
count[tempKey]--;
arr[count[tempKey]] = temp[j];
}
divide = divide * radix;
}
return arr;
}public static void main(String[] args) {
//基础默认从小到大排列
// int[] disOrderArray = {3,1,5,7,0};
//冒泡排序
// disOrderArray = BubbleSort(disOrderArray);
//高速排序
// disOrderArray = quickSort(disOrderArray, 0, disOrderArray.length-1);
//直接选择排序
// disOrderArray = selectionSort(disOrderArray);
//堆排序
// disOrderArray = heapSort(disOrderArray);
//直接插入排序
// disOrderArray = InsertSort(disOrderArray);
//折半插入排序(二分查找排序)
// disOrderArray = BInsertSort(disOrderArray);
//希尔排序
// disOrderArray = ShellInsert(disOrderArray);
//归并排序
// disOrderArray = mergeSort(disOrderArray, 0, disOrderArray.length-1);
//基数排序
int[] disOrderArray = {3,2,3,2,5,333,45566,2345678,78,990,12,432,56};
disOrderArray = RadixSort(disOrderArray, 10, 7);
for(int i=0;i<disOrderArray.length;i++)
{
System.out.print(disOrderArray[i]+" ");
}
}数据结构主要的排序算法基本都全了。
加入一个二分查找算法：类似于折半查找算法
时间复杂度：O(logn)
/**
* 二分查找
* @param arr
* @param searchnum 待查找元素
* @return
*/
public static int BSearch(int[] arr, int searchnum){
int low = 0;
int high = arr.length-1;
while(low<=high)
{
int m = (low+high)/2;
if(searchnum == arr[m])
{
return m;
}
else if(searchnum < arr[m])
{
high = m-1;
}
else
{
low = m+1;
}
}
return -1;
}