八大算法总结

时间 2021-08-15

标签 java 算法数组架构 ide oop 3d 指针 code 栏目 Java 繁體版

原文原文链接

文章目录

算法
- 稳定性
- 插入排序
- - 直接插入排序
  - 折半插入排序
  - 希尔排序
- 交换排序
- - 冒泡排序
  - 快速排序
- 选择类排序
- - 简单选择排序
  - 堆排序
- 归并排序
- 基数排序
- 外部排序

算法

稳定性

选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，java

冒泡排序、插入排序、归并排序、基数排序是稳定的排序算法算法

插入排序

有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法，插入排序的基本操做就是将一个数据插入到已经排好序的有序数据中，从而获得一个新的、个数加一的有序数据，算法适用于少许数据的排序，时间复杂度为 O(n^2)。是稳定的排序方法。数组

从第一个元素开始，该元素能够认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
若是该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤 3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤 2 ~ 5，直至最后一个元素。

import java.util.Arrays;

public class InsertSort {
    private static void insertSort(int[] arr) {
      int j; // 已排序列表下标
      int t; // 待排序元素
      for (int i = 1; i < arr.length; i++) {
        if (arr[i] < arr[i - 1]) {
          t = arr[i]; // 赋值给待排序元素
          for (j = i - 1; j >= 0 && arr[j] > t; j--) {
            arr[j + 1] = arr[j]; // 从后往前遍历已排序列表，逐个和待排序元素比较，若是已排序元素较大，则将它后移
          }
          arr[j + 1] = t; // 将待排序元素插入到正确的位置
        }
      }
    }

    public static void main(String[] args) {
        int[] ints = {5, 3, 4, 1, 2};
        insertSort(ints);
        System.out.println(Arrays.toString(ints));
    }
}

直接插入排序

void InsertSort(ElemType A[],int n){
	int i,j;
	for(i=2;i<=n;i++)	
		if(A[i]<A[i-1]){	
			A[0]=A[i];	//复制为哨兵，A[0]不存放元素
			for(j=i-1;A[0]<A[j];--j)
				A[j+1]=A[j];	//全部比待插入元素值大的都日后移一位，腾出空位
			A[j+1]=A[0];   		//复制到插入位置 
		}
}

折半插入排序

void InsertSort(ElemType A[],int n){
	int i,j,low,high,mid;
	for(i=2;i<=n;i++){	//i记录的是待插入的元素下标，也就是说i-1以前的元素都是有序的	
		A[0]=A[i]; //保存待插入的值			
		low=1;high=i-1; 
		while(low<=high){	 //折半查找	
			mid=(low+high)/2;	
			if(A[mid].key>A[0].key) high=mid-1; 
			else low=mid+1;	
		}
         //找到了待插入的位置 接下来从后往前依次后移元素腾出位置
		for(j=i-1;j>=high+1;--j)A[j+1]=A[j];		
		A[high+1]=A[0];	//由于此时high指向的是待插入位置的前一位		
	}
}

希尔排序

void ShellSort (ElemType A[],int n){
               int i,j;
	for(dk=n/2;dk>=1;dk=dk/2)	    //初始增量为总长度的一半，以后依次除2且向下取整，
                                                               //且最后一次要为1
		for(i=dk+1;i<=n;++i)
			if(A[i].key<A[i-dk].key){  //A[i].key是待插入的关键字，i-dk以前的都是有序的，如          //果待插入的比有序序列最后一个小， 则须要进行排序(进入if语句块)，若是大则不须要(跳出if语句块)
				A[0]=A[i];       //待插入关键字暂存在A[0]
				for(j=i-dk;j>0&&A[0].key<A[j].key; j-=dk)
                            //待插入关键字以前以dk为增量的关键字只要比待插入关键字大的都日后移动dk位
					A[j+dk]=A[j];		
				A[j+dk]=A[0]; //找到了待插入的位置，就将待插入关键字插入这个位置			
			}
}

交换排序

冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列， 依次比较两个相邻的元素 ，若是他们的顺序（如从大到小、首字母从 A 到 Z）错误就把他们交换过来。走访元素的工做是重复地进行直到没有相邻元素须要交换，也就是说该元素已经排序完成。这个算法的名字由来是由于越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端同样，故名“冒泡排序”。架构

比较相邻的元素。若是第一个比第二个大，就交换他们两个。
对每一对相邻元素做一样的工做，从开始第一对到结尾的最后一对。这步作完后，最后的元素会是最大的数。
针对全部的元素重复以上的步骤，除了最后一个。
持续每次对愈来愈少的元素重复上面的步骤，直到没有任何一对数字须要比较。

import java.util.Arrays;

public class BubbleSort {
    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                //若是当前元素比后一位元素大 交换位置
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] ints = {5, 3, 4, 1, 2};
        sort(ints);
        System.out.println(Arrays.toString(ints));
    }
}

快速排序

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），简称快排，也是一种排序算法。最先由东尼·霍尔提出。在平均情况下，排序 n 个项目要 O(nlogn) 次比较。在最坏情况下则须要 O(n^2) 次比较，但这种情况并不常见。事实上，快速排序 O(nlogn) 一般明显比其余算法更快，由于它的内部循环（inner loop）能够在大部分的架构上颇有效率地达成。ide

从数列中挑出一个元素，称为“基准”（pivot），
从新排序数列，全部比基准值小的元素摆放在基准前面，全部比基准值大的元素摆在基准后面（相同的数能够到任何一边）。在这个分割结束以后，该基准就处于数列的中间位置。这个称为分割（partition）操做。
递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法必定会结束，由于在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

int Partition(ElemType A[],int low,int high){  //low是当前待排序的序列起始下标，high是末尾下标
	ElemType pivot=A[low];	//第一个元素做为枢轴
	while(low<high){		
		while(low<high&&A[high]>=pivot) --high;//先从末尾往前找到第一个比枢轴小的元素
		A[low]=A[high]; 	//用high的元素替换low的元素
		while(low<high&&A[low]<=pivot) ++low; //再从开头日后找到第一个比枢轴大的元素
		A[high]=A[low]; 	//用low的元素替换high的元素
	}
	A[low]=pivot;			//枢轴元素存放到最终位置
	return  low; 			//返回存放枢轴的最终位置
}

void QuickSort(ElemType A[],int low,int high){
	if(low<high){   //low和high值要合法			
		int pivotpos=Partition(A,low,high);	
		QuickSort(A,low,pivotpos-1); //分治递归左半部分	
		QuickSort(A,pivotpos+1,high); //分治递归右半部分
	}
}

import java.util.Arrays;

public class QuickSort {
    public static void sort(int[] arr, int head, int tail) {
        if (head >= tail || arr == null || arr.length <= 1) {
            return;
        }
        //设置数组的起始位置 i 结束位置j 基准 pivot 为数组的中间
        int i = head, j = tail, pivot = arr[(head + tail) / 2];
        while (i <= j) {
            //当数组小于基准 循环结束后 至关于i所处的位置的值为大于基准的元素
            while (arr[i] < pivot) {
                ++i;
            }
            //当数组大于基准 循环结束后 至关于j所处的位置的值为小于于基准的元素
            while (arr[j] > pivot) {
                --j;
            }
            //若是i<j 那么则将交互i j对应位置的值
            if (i < j) {
                int t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
                //将指针继续移动
                ++i;
                --j;
            } else if (i == j) {
//若是i=j 那么说明本次排序已经结束 将i++ 若是这里不使用i++ 那么后面的sort(arr,i,tail)将改成arr(arr,i+1,tail)
                ++i;
            }
        }
        //继续将数组分割
        sort(arr, head, j);
        sort(arr, i, tail);
    }

    public static void main(String[] args) {
        int[] ints = {5, 3, 4, 1, 2};
        sort(ints, 0, ints.length - 1);
        System.out.println(Arrays.toString(ints));
    }
}

选择类排序

简单选择排序

void SelectSort(ElemType A[],int n){
	for(i=0;i<n-1;i++){	  //依次从后面序列中选择当前最小的元素做为第i个元素 最后一个元素不须要排序
	       min=i;	                   //min存的是当前最小元素所在下标，初值设为第i个
	       for(j=i+1;j<n;j++)             //从第i个元素日后找，一直要找到最后一个元素
	            if(A[j]<A[min]) min=j;	   //若是这个值更小，则更新min值为这个更小的元素所在下标
	       if(min!=i) {                        //若是第i个元素不是剩下元素最小的，则和最小的进行交换
                           ElemType temp=A[i];
                           A[i]=A[min];
                           A[min]=temp;
                    } 	
	}
}

堆排序

void BuildMaxHeap(ElemType A[],int len){
	for(int i=len/2;i>0;i--) AdjustDown(A,i,len); //由数组下标高处往低处 从第一个可能须要调整的非叶结点
                                                                             // 开始检查，直到根结点(注意根结点下标不是0，是从1开始存储)
}
void AdjustDown(ElemType A[],int k,int len){ //A是存储堆的数组,k是须要检查的结点下标,len是堆中结点个数
	A[0]=A[k]; 		           //A[0]暂存这个须要检查的结点值
	for(i=2*k;i<=len;i*=2){		//从这个结点的左孩子开始往下比较，
                                                                          // 若是发生交换，对交换过的结点继续和它的孩子比较
		if(i<len&&A[i]<A[i+1])i++;	//若是右孩子大一些，就只要考虑和右孩子比较
		if(A[0]>=A[i])  break;	//若是这个结点的值不小于它的较大孩子结点值 则不须要交换
		else{ 
			A[k]=A[i];	//若是这个结点的值小于它的较大孩子
                                                                          //结点值则将较大的孩子结点值赋值给该结点	
			k=i;		//i赋值给k也就是从i开始继续往下检查 直到全部结点检查结束	
		}
	}
	A[k]=A[0];	//检查到最后k的值就是最后一轮交换过的结点位置下标 将该结点换过去		
}

归并排序

归并排序（MERGE-SORT）是创建在归并操做上的一种有效的排序算法，该算法是采用分治法（Divide and Conquer）的一个很是典型的应用。将已有序的子序列合并，获得彻底有序的序列；即先使每一个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。oop

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列ui
设定两个指针，最初位置分别为两个已经排序序列的起始位置3d
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置指针
重复步骤 3 直到某一指针到达序列尾code
将另外一序列剩下的全部元素直接复制到合并序列尾

import java.util.Arrays;

public class MergeSort {

    public static void mergeSort(int[] arrays, int left, int right) {
                // 若是数组还能够拆分
        if (left < right) {
            //数组的中间位置
            int middle = (left + right) / 2;
            //拆分左边数组
            mergeSort(arrays, left, middle);
            //拆分右边数组
            mergeSort(arrays, middle + 1, right);
            //合并
            merge(arrays, left, middle, right);
        }
    }


    /**
     * 合并数组
     */
    public static void merge(int[] arr, int left, int middle, int right) {
        //申请合并空间 大小为两个已经排序序列之和
        int[] temp = new int[right - left + 1];
        //i 和 j为两个已经排好序的数组的起始位置
        int i = left;
        int j = middle + 1;
        int k = 0;
        //排序
        while (i <= middle && j <= right) {
            //将比较小的数组放入合并空间
            if (arr[i] < arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        //将左边剩余元素写入合并空间
        while (i <= middle) {
            temp[k++] = arr[i++];
        }
        //将右边剩余的元素写入合并空间
        while (j <= right) {
            temp[k++] = arr[j++];
        }
        //将排序后的数组写回原来的数组
        for (int l = 0; l < temp.length; l++) {
            arr[l + left] = temp[l];
        }

    }

    public static void main(String[] args) {
        int[] ints = {5, 3, 4, 1, 2};
        mergeSort(ints,0,ints.length-1);
        System.out.println(Arrays.toString(ints));
    }
}

基数排序

ElemType *B=(ElemType *)malloc((n+1)*sizeof(ElemType)); //辅助数组B(动态分配内存)

void Merge(ElemType A[],int low,int mid,int high){
//表A的两段A[low…mid]和A[mid+1…high]各自有序，将它们合并成一个有序表
	for(int k=low;k<=high;k++)B[k]=A[k];		//将A中全部元素复制到B中
	for(int i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){  k是归并以后数组的下标计数器
		if(B[i]<=B[j])   			//比较B的左右两段中的元素
			A[k]=B[i++];			//将较小值复制到A中
		else
			A[k]=B[j++];
	}
	while(i<=mid)	A[k++]=B[i++];	//若第一个表未检测完，直接将剩下的部分复制过来
	while(j<=high)	A[k++]=B[j++];	//若第二个表未检测完，直接将剩下的部分复制过来
}

八大算法总结

文章目录

稳定性

插入排序

直接插入排序

折半插入排序

希尔排序

交换排序

冒泡排序

快速排序

选择类排序

简单选择排序

堆排序

归并排序

基数排序

外部排序