数据结构中的排序算法思路和代码

/*
查看数据结构中算法的稳定性非常重要
其中稳定性是代表一个算法中同一个相同的数字在排序之后他的相对位置会不会交换
其中只有直接 插入，冒泡排序 ， 二路归并 ， 技术排序 的算法是稳定的
快速排序和堆排序都类似树的结构
*/


/*
插入排序分为
1.直接插入排序
思路先从第二个位置开始遍历第一次然后找到最小的元素然后与第一个元素进行交换以此类推
2.希尔排序
把里面的元素按照总长度的一半开始分组，然后每一组的元素第每一个和下一组每一
个和下一组元素的每一个进行对比然后用直接插入排序就可以了
*/
//下面都是升序排序
//稳定
void InsertSort(int A[] , int n ){
    int j ;
    for(int i = 1 ; i < n ; i++) {
        if(A[i]<A[i-1]){
            int temp = A[i];
            for( j = i-1 ; j > 0 && A[j]>temp ; --j ){
                A[j+1]=A[j];
            }
            A[j+1] = temp;
        }
    }
}
//时间复杂度为O（n3）稳定
void ShellSort(int A[] , int n ){
    int i , j , d ;
    for(d = n/2 ; d > 0 ; d = d / 2){
        for( i = d + 1 ; i < n ; i++ ){
            if(A[i]<A[i-d]){
                A[0] = A[i];
                for( j = i -d ; j > 0 && A[j] ; j = j -d ){
                    A[j+d]=A[j];
                }
            }
            A[j+d]=A[0];
        }
    }
}


/*
交换排序
1.快速排序
思想：用两个指针指向头尾然后然后开始比较头尾指针大小
比如头指针比较大的话把尾指针上面的数值赋到头指针然后尾指针不懂头指针开始+1继续遍历
得到一个左边比中位数小右边比中位数大的两个序列 然后递归的调用
2.冒泡排序
思路通过两次遍历数组然后查看相邻元素的大小开始交换
*/

int Partition(int A[] , int low , int high){
    int pivot = A[low];
    while (low < high && A[high] >= pivot )
    {
        high--;
    }
    A[low] = A[high];
    while (low < high && A[low] <= pivot)
    {
        low++;
    }
    A[high] = A[low];
    return low;
    
}
void QuickSort(int A[], int low , int high){
    if(low<high){
        int pivtops = Partition(A , low , high );
        QuickSort(A , low , pivtops-1);
        QuickSort(A , pivtops + 1 , high);
    }
}




void BubbleSort(int A[] , int n){
    for(int i = 0 ; i < n ; i++ ){
        int flag = 0 ;
        for(int j = n - 1 ; j > i ; j-- ){
            if(A[j-1] > A[j]){
                int temp = A[j];
                A[j] = A[j-1];
                A[j-1] = temp;
                flag = 1 ;
            }
            if(flag == 0 ){
                return ;
            }
        }
    }
}


/*
选择排序
1.选择排序
思想想遍历数组找到最小元素的下标然后找到之后第二次遍历和最小元素让后交换
2.堆排序
思路用二叉树来实现的主要思路是
先建立一个二叉树（按从到到尾层次遍历得到的）
然后建立大小堆
思路大根堆
找到非叶子结点也就是数组总长度的一半向下取整开始寻找 然后查看该结点的左孩子和右孩子（思路是，该点的下标*2得到左孩子*2+1得到右孩子）
然后比较大小大的与根节点互换，比较之后查看该节点上一个非叶子节点思路一样 
*/
void Select(int A[] , int n ){
    int j ;
    for(int i = 0 ; i < n ; i++){
        int min = i;
        for(  j = i + 1 ; j < n ; j++){
            if(A[min] > A[j] ){
                min = j ;
            }
        }
        int temp = A[min];
        A[min] = A[i];
        A[i] = temp;
    }
}


void HeapAdjust(int A[] , int k , int n){
    A[0] = A[k];
    int i ;
    for(i = k*2 ; i <= n  ; i *= 2 ){
        if(i < n && A[i]<A[i+1]){
            i++;
        }
        else if(A[0]>A[i]){
            break;
        }
        else{
            A[k] = A[i];
            k = i ;
        }
    }
    A[k] = A[0] ;
}
void BUlieMaxHeap(int A[] , int n ){
    for(int i = n/2 ; i > n ; i-- ){
        HeapAdjust(A,i,n);
    }
}
void HeapSort(int A[] , int n ){
    BUlieMaxHeap(A,n);
    for(int i = n ; n > 1 ; i--){
        int temp = A[i];
		A[i] = A[1];
		A[1] = temp;
		HeapAdjust(A,1,i-1);
    }
}