数据结构-排序

一.排序算法

1.直接插入排序：

//直接插入排序：  						
//初始最左边为有序序列，其余为无序序列，一一对比，再把无序的关键字挪动有序对应位置
void insertSort(int arr[],int n)		//整型数组，关键字个数
{
	int i,j,temp;						//下标，temp为暂存待插入的关键字
	for(i=1; i < n; ++i)				//下标为0的关键字为有序序列，i循环范围1<i<n，外层循环为无序序列，第一个为有序关键字
	{
		temp = arr[i];					//最大关键字存入辅助常量
		j = i-1;						//j为有序序列，无序序列的左边一个为有序序列
		while (j>=0 && temp<arr[j])		//当有序序列的范围大于0，temp小于j扫描到的关键字，内层循环为有序序列
		{
			arr[j+1] = arr[j];			//每扫描到关键字往后移动一位
			--j;						//下标也往前移动一位
		}
		arr[j+1] = temp;				//指示标志落在最后待插入的前一个位置
	}
}

2.简单选择排序

//简单选择排序：  						
//每次找到最小关键字，移动至无序最左边
void selectSort(int arr[],int n)
{
	int i,j,k;							//下标
	int temp;
	for(i=0;i < n;++i)
	{
		k = i;							//记录下标
		for (j=i+1 ;j < n; ++j)
			if (arr[k] > arr[j])		//比较最值
				k = j;					//把最小值的下标赋值给k
		temp = arr[i];					//第一个关键字与最小值对调
		arr[i] = arr[k];
		arr[k] =temp;

	}
}

3.冒泡排序：

//冒泡排序：							
//两两关键字对比，大的关键字移动到右边，一轮循环下来最右边关键字为最大值，后续在无序序列进行多趟操作。
void bubleSort(int arr[],int n)			//整型数组，关键字个数
{
	int i,j,flag,temp;
	for(i=n-1;i >= 1;--i)				//无序序列的范围
	{
		flag = 0;
		for (j=1;j<=i;++j)				//扫描当前的无序序列，此处为什么没有j=0?下面有arr[j-1] > arr[j]比较，而下标0前面没有数可以比较
			if (arr[j-1] > arr[j])
			{
				temp = arr[j];
				arr[j] = arr[j-1];
				arr[j-1] =temp;
				flag = 1;				//有交换，flag变更为1
			}
		if (flag == 0)
			return;
	}
}

4.shell排序

//shell排序								
//（先将整个待排元素序列切割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，
然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。）
viod shellSort(int arr[],int n)
{
    int temp;
    for(int gap=n/2;gap>0;gap/=2)
    {
        for(int i=gap;i<n;++i)
        {
            temp=arr[i];
            int j;
            for(j=i;j>=gap && arr[j-gap]>temp;j-=gap) //每个元素与自己组内的数据进行直接插入排序 
                arr[j]=arr[j-gap];
            arr[j]=temp;
        }
    }
}

5.堆排序

建立大顶堆

插入节点：

删除节点：

//堆排序
//关键字调整函数
void Sift(int arr[],int low,int high)	//arr[]中是一棵完全二叉树，所以元素的存储必须从1开始
{
    int i=low,j=2*i+1;					//arr[j]是arr[i]的左孩子结点
    int temp=arr[i];					//temp暂存要调整节点关键字值
    while(j<=high)
    {
        if(j<high && arr[j]<arr[j+1])   //若右孩子较大，则把j指向右孩子
            ++j;                    	//j变为2*i+2
        if(temp<arr[j])
        {
            arr[i]=arr[j];              //将arr[j]调整到双亲结点的位置上
            i=j;                    	//修改i和j的值，以便继续向下调整
            j=2*i+1;
        }
        else
            break;                  	//调整结束
    }
    arr[i]=temp;						//被调整结点的中放入最终位置
}

//堆排序函数 
viod heapSort(int arr[],int n)
{
    int i;
    int temp;
    for(i=n/2-1;i>=0;--i)            	//此for循环建立一个大顶堆，i为递减，说明从最后一个分叶节点往前逐个调整
        Sift(arr,i,n-1);				//存储二叉树的数组;本趟循环要调整的节点下标;堆中最后一个节点下标
    for(i=n-1;i>=0;--i)              	//进行n-1次循环，完成堆排序
    {									//以下3句，0位置关键字与当前最大关键字（也就是i位置关键字）交换
        temp=arr[0];
        arr[0]=arr[i];
        arr[i]=temp;
        Sift(arr,0,i-1);             	//无序序列的边界[0,被换出的关键字前一个位置]
    }
}

6.快速排序

//快速排序
//快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，
则可分别对这两部分记录继续进行排序，以达到整个序列有序。
function quickSort(arr, left, right) {
    var len = arr.length,
        partitionIndex,
        left = typeof left != 'number' ? 0 : left,
        right = typeof right != 'number' ? len - 1 : right;
 
    if (left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex-1);
        quickSort(arr, partitionIndex+1, right);
    }
    return arr;
}
 
function partition(arr, left ,right) {     // 分区操作
    var pivot = left,                      // 设定基准值（pivot）
        index = pivot + 1;
    for (var i = index; i <= right; i++) {
        if (arr[i] < arr[pivot]) {
            swap(arr, i, index);
            index++;
        }       
    }
    swap(arr, pivot, index - 1);
    return index-1;
}
 
function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

7.归并排序

//归并排序
//将一个数组中的两部分子表归并成一个更长的表（待归并与归并后结果都是在同一个数组当中）
void merge(int arr[],int low,int mid,int high)
{
    int i,j,k;
    int n1=mid -low+1;					//下标为[low,mid]	
    int n2=high-mid;					//下标为[mid+1,high]
    int L[n1],R[n2];
    for(i=0;i<n1;i++)
        L[i]=arr[low+i];
    for(j=0;j<n2;j++)
        R[j]=arr[mid+1+j];
    i=0;
    j=0;
    k=low;
    while(i<n1 && j<n2)
    {
        if(L[i]<=R[j])
            arr[k]=L[i++];
        else
            arr[k]=R[j++];
        k++;
    }
    while(i<n1)
        arr[k++]=L[i++];
    while(j<n2)
        arr[k++]=R[j++];
}

void mergeSort(int arr[],int low,int mid,int high)
{
    if(low<high)
    {
        int mid=(low+high)/2;
        mergeSort(arr,low,mid);			//归并排序前半段
        mergeSort(a,mid+1,high);		//归并排序后半段
        merge(A,low,mid,high);			//merge()函数：把A数组中low到mid和mid+1到high范围内的两段有序序列归并成一段有序序列
    }
}