数据结构——排序算法

插入排序

直接插入排序（O(n2)）

public static void insertSort(int[] a){
        int i ,j ,temp;
        int n =a.length;
        for(i=0 ; i<n-1;i++){
            temp=a[i+1];
            j=i;
            while (j>-1&&temp<a[j]){
                a[j+1]=a[j];
                j--;
            }
            a[j+1]=temp;
        }
    }

void InsertSort(int array[], int size)
{
    for (int i = 1; i < size; i++)
    {                        // 第 1 个数肯定是有序的，从第 2 个数开始遍历，依次插入有序序列
        int temp = array[i]; // 取出第 i 个数，和前 i-1 个数比较后，插入合适位置
        int j = i - 1;       // 因为前 i-1 个数都是从小到大的有序序列，所以只要当前比较的数 (array[j]) 比 temp 大，就把这个数后移一位
        while (j >= 0 && array[j] > temp)
        {                            // 当 j < 0 或 array[j] < temp(array[i]) 时终止
            array[j + 1] = array[j]; // 将大于 temp(array[i]) 的数据后移
            j--;                     // 向前比较
        }                            // 结束循环
        array[j + 1] = temp;         // array[i]插入到正确的位置上

        //打印每次排序结果
        display(array, size);
    }
}

希尔排序

 public static void shellSort(int[]a,int[]d,int numOfD) {
        int i, j, k, m, span;
        int temp;
        int n = a.length;
        for (m = 0; m < numOfD; m++) {
            span = d[m];
            for (k = 0; k < span; k++) {
                for (i = k; i < n - span; i = i + span) {
                    temp = a[i + span];
                    j = i;
                    while (j > -1 && temp <= a[j]) {
                        a[j + span] = a[j];
                        j = j - span;

                    }
                    a[j + span] = temp;
                }
            }
        }
    }

void shellsort(int *k, int n)
{
    int i, j, temp, gap = n;
    while (gap > 1)
    {
        gap = gap / 2;                /*增量缩小，每次减半*/
        for (i = 0; i < n - gap; i++) // n-gap 是控制上限不让越界
        {
            j = i + gap; //相邻间隔的前后值进行比较
            if (k[i] > k[j])
            {
                temp = k[i];
                k[i] = k[j];
                k[j] = temp;
            }
        }
    }
}

折半插入排序算法

//折半插入排序
typedef int ElemType;
ElemType arr[] = {0, 9, 8, 7, 6, 5, 4, 3, 2, 1};
ElemType n = 10, i, j;
ElemType low, high, mid;
void BinSort(ElemType r[], ElemType n)
{
    for (i = 2; i <= n; i++)
    {
        r[0] = r[i];
        low = 1;
        high = i - 1;
        while (low <= high)
        {
            mid = (low + high) / 2;
            if (r[0] < r[mid])
                high = mid - 1;
            else
                low = mid + 1;
        }
        for (j = i - 1; j >= low; j--)
        {
            r[i] = r[j];
            i--;
        }
        r[low] = r[0];
    }
}
void put(ElemType r[], ElemType n)
{
    for (j = 1; j < n; j++)
        printf("%d\t", r[j]);
    printf("\n");
}

选择排序

直接选择排序

public static void selectSort(int[] a){
        int i ,j ,small;
        int temp;
        int n =a.length;
        for(i=0;i<n-1;i++){
            small=i;
            for(j=i+1;j<n;j++)
                if(a[j]<a[small]){small =j;}

                if(small!=i){
                 temp=a[i];
                 a[i]=a[small];
                 a[small]=temp;
                }

        }
    }

稳定的直接选择

public static void selectSort2(int[] a){
        int i ,j ,small;
        int temp;
        int n =a.length;
        for(i=0;i<n-1;i++){
            small=i;
            for(j=i+1;j<n;j++){
                if(a[j]<a[small])
                    small =j;

            }
            if(small!=i){
                temp=a[small];
                for(j=small;j>i;j--)
                    a[j]=a[j-1];
                a[i]=temp;
            }
        }

    }

交换排序

冒泡排序

public  static void doubleSort(int[]a){
        int i ,j ,flag=1;
        int temp;
        int n =a.length;
        for(i=1;i<n&&flag==1;i++){
            flag=0;
            for(j=0;j<n-i;j++){
                flag=1;
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;

            }
        }
    }

///冒泡排序
void bubbleSort(elemType arr[], int len)
{
    elemType temp;
    int i, j;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - i; j++)
        {
            if (arr[j] > arr[j + 1])
                temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
}

实现快速排序

//实现快速排序

void Quicksort(int *number, int first, int last)
{
    int i, j, pivot;
    int temp;
    if (first < last)
    {
        i = first;
        j = last;
        while (i < j)
        {
            while (number[i] <= number[pivot] && i < last)
                i++;
            while (number[j] > number[pivot])
                j--;
            if (i < j)
            {
                temp = number[i];
                number[i] = number[j];
                number[j] = temp;
            }
        }
        temp = number[pivot];
        number[pivot] = number[j];
        number[j] = temp;
        quickSort(number, first, j - 1);
        quickSort(number, j + 1, last);
    }
}
struct record
{
    int key;
    datatype others;
};

//实现快速排序2
void Quicksortpass(struct record r[], int s, int t, int &i)
{
    int j = t;
    struct record x = r[s];
    i = s;
    while (i < j)
    {
        while (i < j && r[j].key < x.key)
            j--;
        if (i < j)
        {
            r[i] = r[j];
            i++;
        }

        while (i < j && r[i].key < x.key)
            i++;
        if (i < j)
        {
            r[i] = r[j];
            j--;
        }
    }
    r[i] = x;
}

折半递归

 public static int bSearch(int[]a, int x, int low ,int high){
        int mid;
        if(low>high)return -1;
        mid =(low+high)/2;
        if(x==a[mid])return mid;
        else if(x<a[mid])
            return bSearch(a,x,low,mid-1);
        else
            return bSearch(a,x,mid+1,high);

    }

线性表的查找

二分查找法

 public static  int biSearch(int[]a,int elem){
        int n =a.length;
        int low =0,high=n-1,mid;
        while (low<=high){
            mid =(low+high)/2;
            if(a[mid]==elem)return mid;
            else if(a[mid]<elem) low=mid;
            else high=mid-1;

        }
        return -1;
    }

分块查找

struct index /*定义块的结构*/
{
    int key;
    int start;
    int end;
} index_table[4]; /*定义结构体数组*/

int block_search(int key, int a[]) /*自定义实现分块查找*/
{
    int i, j;
    i = 1;
    while (i <= 3 && key > index_table[i].key) /*确定在那个块中*/
        i++;
    if (i > 3) /*大于分得的块数，则返回0*/
        return 0;
    j = index_table[i].start;                      /*j等于块范围的起始值*/
    while (j <= index_table[i].end && a[j] != key) /*在确定的块内进行查找*/
        j++;
    if (j > index_table[i].end) /*如果大于块范围的结束值，则说明没有要查找的数,j置0*/
        j = 0;
    return j;
}