第9章_排序

最新推荐文章于 2023-12-23 19:04:11 发布
最新推荐文章于 2023-12-23 19:04:11 发布
阅读量437 收藏
点赞数 1
分类专栏： C语言版数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwww_com/article/details/78185187
版权

排序的基本概念

排序是对数据元素序列建立某种有序排列的过程。更确切地说，排序是把一个数据元素序列整理成按关键字递增（或递减）排列的过程。
关键字分主关键字和次关键字两种。对要排序的数据元素集合来说，如果关键字满足数据元素值不同时该关键字的值也一定不同，这样的关键字称为主关键字。换句话说，主关键字是能够惟一区分各个不同数据元素的关键字。不满足主关键字定义的关键字称为次关键字。
排序分内部排序和外部排序两种。内部排序是把待排数据元素全部调入内存中进行的排序。如果数据元素的数量太大，需要分批导入内存，分批导入内存的数据元素排好序后再分批导出到磁盘和磁带等外存介质上的排序方法称作外部排序。外部排序算法的原理与内部排序算法的原理在很多地方都类同，但因内存的读写速度与外存的读写速度差别很大，所以评价标准差别很大。

插入排序

插入排序的基本思想是：从初始有序的子集合开始，不断地把新的数据元素插入到已排列有序的子集合的合适位置上，使子集合中数据元素的个数不断增多，当子集合等于集合时，插入排序算法结束。常用的插入排序有直接插入排序和希尔排序两种。

直接插入排序

直接插入排序的基本思想是：顺序地把待排序的数据元素按其关键字值的大小插入到已排序数据元素子集合的适当位置。子集合的数据元素个数从只有一个数据元素开始逐次增大，当子集合大小最终与集合大小相同时排序完毕。

Sort.h

typedef struct 
{
    KeyType key;
} DataType;

//直接插入排序
void InsertSort(DataType a[],int n)
{
    int i,j;
    DataType temp;
    for(i = 0;i < n-1; i++)
    {
        temp = a[i+1];
        j = i;
        while(j > -1 && temp.key < a[j].key)
        {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = temp;
    }
}

main.c

#include <stdio.h>
typedef int KeyType;
#include "sort.h"
#define length 6

void print(DataType num[],int len);

void main(void)
{
    DataType num[length] = {
        64,5,7,89,6,24
    };
    print(num,length);

    printf("\n");
    InsertSort(num,length);

    print(num,length);
    printf("\n");
}

void print(DataType num[],int len)
{
    int i;
    for(i = 0;i < len; i++)
        printf("%d\t",num[i]);
}
/*
64      5       7       89      6       24
5       6       7       24      64      89
Press any key to continue
*/

希尔排序

希尔(shell)排序的基本思想是：把待排序的数据元素分成若干个小组，对同一小组内的数据元素用直接插入法排序；小组的个数逐次缩小，当完成了所有数据元素都在一个组内的排序后排序过程结束。希尔排序又称作缩小增量排序。

//希尔排序
//用希尔排序法对元素a[0]--a[n-1]排序，d[0]--d[numOfD-1]
//为希尔增量值
void ShellSort(DataType a[],int n,int d[],int numOfD)
{
    int i,j,k,m,span;
    DataType temp;
    for(m = 0;m < numOfD;m++)       //共numOfD次循环
    {
        span = d[m];                //取本次的增量值
        for(k = 0;k < span; k++)    //共span个小组
        {
            //组内是直接插入排序，区别是每次不是增1而是增span
            for(i = k; i < n-span; i = i + span)
            {
                temp = a[i + span];
                j = i;
                while(j > -1 && temp.key <= a[j].key)
                {
                    a[j + span] = a[j];
                    j = j - span;
                }
                a[j + span] = temp;
            }
        }
    }
}

main.c

#include <stdio.h>
typedef int KeyType;
#include "sort.h"
#define length 6

void print(DataType num[],int len);

void main(void)
{
    DataType num[length] = {
        64,5,7,89,6,24
    };

    int cap[2] = {1,3};

    print(num,length);

    printf("\n");
//  InsertSort(num,length);
    ShellSort(num,length,cap,2);

    print(num,length);
    printf("\n");
}

void print(DataType num[],int len)
{
    int i;
    for(i = 0;i < len; i++)
        printf("%d\t",num[i]);
}
/*
64      5       7       89      6       24
5       6       7       24      64      89
Press any key to continue
*/

选择排序

选择排序的基本思想是：每次从待排序的数据元素集合中选取关键字最小（或最大）的数据元素放到数据元素集合的最前（或最后），数据元素集合不断缩小，当数据元素集合为空时选择排序结束。常用的选择排序有直接选择排序和堆排序两种。堆排序是一种基于完全二叉树的排序。

直接选择排序

直接选择排序的基本思想是：从待排序的数据元素集合中选取关键字最小的数据元素并将它与原始数据元素集合中的第一个数据元素交换位置；然后从不包括第一个位置的数据元素集合中选取关键字最小的数据元素并将它与原始数据集合中的第二个数据元素交换位置；如此重复，直到数据元素集合中只剩一个数据元素为止。

//直接选择排序 
void SelectSort(DataType a[],int n)
{
    int i,j,small;
    DataType temp;

    for(i = 0;i < n-1; i++)
    {
        small = i;                                      //设第i个数据元素关键字最小
        for(j = i + 1;j < n; j++)                       //寻找关键字最小的数据元素
            if(a[j].key < a[small].key) small = j;      //记住最小元素的下标
        if(small != i)                                  //当最小元素的下标不为i时交换位置
        {
            temp = a[i];
            a[i] = a[small];
            a[small] = temp;
        }
    }
}

main.c

#include <stdio.h>
typedef int KeyType;
#include "sort.h"
#define length 6

void print(DataType num[],int len);

void main(void)
{
    DataType num[length] = {
        64,5,7,89,6,24
    };
    print(num,length);

    printf("\n");
    SelectSort(num,length);

    print(num,length);
    printf("\n");
}

void print(DataType num[],int len)
{
    int i;
    for(i = 0;i < len; i++)
        printf("%d\t",num[i]);
}
/*
64      5       7       89      6       24
5       6       7       24      64      89
Press any key to continue
*/

堆排序

在直接选择排序中，待排序的数据元素集合构成一个线性表结构，要从有n个数据元素的线性表中选择出一个最小的数据元素需要比较n-1次。如果能把待排序的数据元素集合构成一个完全二叉树结构，则每次选择出一个最大（或最小）的数据元素只需比较完全二叉树的数值为高度的次数，即log2n次，所以排序算法的时间复杂度就是O(nlog2n)。这就是堆排序的基本思想。

//堆排序
void CreateHeap(DataType a[],int n,int h)
{
    int i,j,flag;
    DataType temp;

    i = h;                  //i为要建堆的二叉树根结点下标
    j = 2 * i + 1;          //j为i的左孩子结点的下标
    temp = a[i];
    flag = 0;

    //沿左右孩子中值较大者重复向下筛选
    while(j < n && flag != 1)
    {
        //寻找左右孩子结点中的较大者，j为其下标
        if(j < n - 1 && a[j].key < a[j + 1].key) j++;
        if(temp.key > a[j].key)     //a[i].key > a[j].key
            flag = 1;               //标记结束筛选条件
        else
        {
            a[i] = a[j];
            i = j;
            j = 2 * i + 1;
        }
    }

    a[i] = temp;                    //把最初的a[i]赋予最后的a[j]
}

//初始化创建最大堆
void InitCreateHeap(DataType a[],int n)
{
    int i;
    for(i = (n - 1) / 2;i >= 0; i--)
        CreateHeap(a,n,i);
}

//堆排序算法
void HeapSort(DataType a[],int n)
{
    int i;
    DataType temp;
    InitCreateHeap(a,n);        //初始化创建最大堆

    for(i = n - 1;i > 0; i--)   //当前最大堆个数每次递减1
    {
        //把堆顶a[0]元素与当前最大堆的最后一个元素交换
        temp = a[0];
        a[0] = a[i];
        a[i] = temp;
        CreateHeap(a,i,0);      //调整根结点满足最大堆
    }
}

main.c

#include <stdio.h>
typedef int KeyType;
#include "sort.h"
#define length 6

void print(DataType num[],int len);

void main(void)
{
    DataType num[length] = {
        64,5,7,89,6,24
    };
    print(num,length);

    printf("\n");
    HeapSort(num,length);

    print(num,length);
    printf("\n");
}

void print(DataType num[],int len)
{
    int i;
    for(i = 0;i < len; i++)
        printf("%d\t",num[i]);
}
/*
64      5       7       89      6       24
5       6       7       24      64      89
Press any key to continue
*/

交换排序

利用交换数据元素的位置进行排序的方法称作交换排序。常用的交换排序方法有冒泡排序法和快速排序法。快速排序法是一种分区交换排序方法。

冒泡排序

//冒泡排序
void BubbleSort(DataType a[],int n)
{
    int i,j,flag = 1;
    DataType temp;
    for(i = 1;i < n && flag == 1; i++)
    {
        flag = 0;
        for(j = 0;j < n - i; j++)
        {
            if(a[j].key > a[j + 1].key)
            {
                flag = 1;
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

main.c

#include <stdio.h>
typedef int KeyType;
#include "sort.h"
#define length 6

void print(DataType num[],int len);

void main(void)
{
    DataType num[length] = {
        64,5,7,89,6,24
    };
    print(num,length);

    printf("\n");
    BubbleSort(num,length);

    print(num,length);
    printf("\n");
}

void print(DataType num[],int len)
{
    int i;
    for(i = 0;i < len; i++)
        printf("%d\t",num[i]);
}
/*
64      5       7       89      6       24
5       6       7       24      64      89
Press any key to continue
*/

快速排序

快速排序是一种二叉树结构的交换排序方法。快速排序算法的基本思想是：设数组a中存放了n个数据元素，low为数组的低端下标，high为数组的高端下标，从数组a中任取一个元素（通常取a[low]）作为标准，调整数组a中各个元素的位置，使排在标准元素前面元素的关键字均小于标准元素的关键字，排在标准元素后面元素的关键字均大于或等于标准元素的关键字。这样一次过程结束后，一方面将标准元素放在了未来排好序的数组中该标准 元素应在的位置上，另一方面将数组中的元素以标准元素为中心分成了两个子数组，位于标准 元素左边子数组中元素的关键 字均小于标准元素的关键 字，位于标准 元素右边子数组中元素的关键字均大于等于标准元素的关键字。然后对这两个子数组中的元素分别再进行方法类同的递归快速排序。递归算法的出口条件是high > low

//快速排序
//用递归方法对数据元素a[low]--a[high]进行快速排序
void QuickSort(DataType a[],int low,int high)
{
    int i = low,j = high;
    DataType temp = a[low];         //取第一个元素为标准数据元素
    while(i < j)
    {
        while(i < j && temp.key <= a[j].key) j--;       //在数组的右端扫描

        if(i < j)
        {
            a[i] = a[j];
            i++;
        }

        while(i < j && a[i].key < temp.key) i++;        //在数组的左端扫描

        if(i < j)
        {
            a[j] = a[i];
            j--;
        }
    }
    a[i] = temp;

    if(low < i) QuickSort(a,low,i - 1);         //对左端子集合进行递归
    if(i < high) QuickSort(a,j + 1,high);           //对右端子集合进行递归
}

main.c

#include <stdio.h>
typedef int KeyType;
#include "sort.h"
#define length 6

void print(DataType num[],int len);

void main(void)
{
    DataType num[length] = {
        64,5,7,89,6,24
    };
    print(num,length);

    printf("\n");
    QuickSort(num,0,length-1);

    print(num,length);
    printf("\n");
}

void print(DataType num[],int len)
{
    int i;
    for(i = 0;i < len; i++)
        printf("%d\t",num[i]);
}
/*
64      5       7       89      6       24
5       6       7       24      64      89
Press any key to continue
*/

归递排序

归并排序主要是二路归并排序。二路归并排序的基本思想是：设数组a中存放了n个数据元素，初始时把它们看成是n个长度为1的有序子数组，然后从第一个子数组开始，把相邻的子数组两两合并，得到n/2的整数上界个长度为2的新的有序子数组（当n为奇数时最后一个新的有序子数组的长度为1）；对这些新的有序子数组再两两归并；如此重复，直到得到一个长度为n的有序数组为止。

//归并排序

//k为有序子数组的长度，一次二路归并排序后的有序子序列存于数组swap中
void Merge(DataType a[],int n,DataType swap[],int k)
{
    int m = 0,u1,l2,i,j,u2;

    int l1 = 0;         //第一个有序子数组下界为0
    while(l1 + k <= n - 1)
    {
        l2 = l1 + k;        //计算第二个有序子数组下界
        u1 = l2 - 1;        //计算第一个有序子数组上界
        u2 = (l2 + k - 1 <= n-1) ? l2 + k - 1 : n-1;

        //计算第二个有序子数组上界

        //两个有序子数组合并
        for(i = l1,j = l2;i <= u1 && j <= u2; m++)
        {
            if(a[i].key <= a[j].key)
            {
                swap[m] = a[i];
                i++;
            }
            else
            {
                swap[m] = a[j];
                j++;
            }
        }

        //子数组2已归并完，将子数组1中剩余的元素存放到数组swap中
        while(i <= u1)
        {
            swap[m] = a[i];
            m++;
            i++;
        }

        //子数组1已归并完，将子数组2中剩余的元素存放到数组swap中
        while(j <= u2)
        {
            swap[m] = a[j];
            m++;
            j++;
        }
        l1 = u2 + 1;
    }

    //将原始数组中只够一组的数据元素顺序存放到数组swap中
    for(i = l1;i < n; i++,m++)
        swap[m] = a[i];
}

void MergeSort(DataType a[],int n)
{
    int i,k = 1;            //归并长度从1开始
    DataType* swap;
    swap = (DataType*)malloc(sizeof(DataType)*n);       //申请动态数组空间
    while(k < n)
    {
        Merge(a,n,swap,k);                              //调用归并函数
        for(i = 0;i < n; i++)
            a[i] = swap[i];                             //将元素从临时数组swap放回数组中
        k = 2 * k;                                      //归并长度加倍
    }
    free(swap);                                         //释放动态数组空间
}

main.c

#include <stdio.h>
typedef int KeyType;
#include "sort.h"
#define length 6

void print(DataType num[],int len);

void main(void)
{
    DataType num[length] = {
        64,5,7,89,6,24
    };
    print(num,length);

    printf("\n");
    MergeSort(num,length);

    print(num,length);
    printf("\n");
}

void print(DataType num[],int len)
{
    int i;
    for(i = 0;i < len; i++)
        printf("%d\t",num[i]);
}
/*
64      5       7       89      6       24
5       6       7       24      64      89
Press any key to continue
*/

基数排序

基数排序也称作桶排序，是一种当关键字为整数类型时非常高效的排序方法。
基数排序算法的基本思想是：设待排序的数据元素关键字是m位d进制整数（不中m位的关键字在高位补0），设置d个桶，令其编号分别为0，1，2，…，d-1。首先，按关键字最低位的数值依次把各数据元素放到相应的桶中；然后，按照桶号从小到大和进入桶中数据元素的先后次序收入集分配在各桶中的数据元素；这样，就形成了数据元素集合的一个新的排列，称这样的一次排序过程为一次基数排序。再对一次基数排序得到的数据元素序列按关键 字次低位的数值依次把各数据元素放到相应的桶中，然后按照桶号从小到大和进入桶中数据元素的先后次序收入集分配在各桶中的数据元素。这样的过程重复进行，当完成了第 m次基数排序后，就得到了排好序的数据元素序列。

LinQueue.h

typedef struct qnode {
    DataType data;
    struct qnode * next;
}LQNode;

typedef struct  {
    LQNode* front;  //队头指针
    LQNode* rear;   //队尾指针
}LQueue;

//1.初始化
void QueueInitiate(LQueue*Q)
{
    Q->rear = NULL;     //定义初始队尾指针
    Q->front = NULL;    //定义初始队头指针
}

//2.非空否
int QueueNotEmpty(LQueue Q)
{
    //判断链式队列Q非空否，非空返回1，否则返回0
    if(Q.front == NULL) return 0;
    else return 1;
}

//3.入队列
int QueueAppend(LQueue*Q,DataType x)
{
    //把数据元素值x插入链式队列Q的队尾，入队列成功返回1，否则返回0
    LQNode*p;
    if((p = (LQNode*)malloc(sizeof(LQNode))) == NULL)
    {
        printf("内存空间不中！");
        return 0;
    }
    p->data = x;
    p->next = NULL;

    if(Q->rear != NULL) Q->rear->next = p;
    Q->rear = p;
    if(Q->front == NULL) Q->front = p;
    return 1;
}

//4.出队列
int QueueDelete(LQueue*Q,DataType*d)
{
    //删除链式队列Q的队头数据元素值到d，出队列成功返回1，否则返回0
    LQNode*p;
    if(Q->front == NULL)
    {
        printf("队列已空无数据元素出队列！\n");
        return 0;
    }
    else
    {
        *d = Q->front->data;
        p = Q->front;
        Q->front = Q->front->next;
        if(Q->front == NULL) Q->rear = NULL;
        free(p);
        return 1;
    }
}

//5.取队头数据元素
int QueueGet(LQueue Q,DataType*d)
{
    //取链式队列Q的当前队头数据元素值到d,成功返回1，否则返回0
    if(Q.front == NULL)
    {
        printf("队列已空无数据元素出队列！\n");
        return 0;
    }
    *d = Q.front->data;
    return 1;
}

//6.撤消动态申请空间
void Destroy(LQueue Q)
{
    LQNode*p,*p1;
    p = Q.front;
    while(p != NULL)
    {
        p1 = p;
        p = p->next;
        free(p1);
    }
}


//基数排序
//对数据元素a[0]--a[n-1]进行关键字为m位d进制整型数值的基数排序
//桶采用链式队列
void RadixSort(DataType a[],int n,int m,int d)
{
    int i,j,k,power = 1;
    LQueue* tub;

    //把d个队列定义为动态数组
    tub = (LQueue*)malloc(sizeof(LQueue)*d);
    for(i = 0;i < d; i++)               //d个队列初始化
        QueueInitiate(&tub[i]);
    //进行m次放和收
    for(i = 0;i < m; i++)
    {
        if(i == 0) power = 1;
        else power = power * d;
        //将数据元素按关键字第k位的数值放到相应的队列中
        for(j = 0;j < n; j++)
        {
            k = a[j].key / power - (a[j].key / (power * d)) * d;
            QueueAppend(&tub[k],a[j]);                  //把a[j]放入相应的队列中
        }

        //顺序回收各队列中的数据元素至数组a中
        k = 0;
        for(j = 0;j < d; j++)
            while(QueueNotEmpty(tub[j]) != 0)
            {
                QueueDelete(&tub[j],&a[k]);     //从各队列中回收
                k++;
            }
    }
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef int KeyType;
typedef struct 
{
    KeyType key;
} DataType;
#include "LinQueue.h"
#include "sort.h"
#define length 6

void print(DataType num[],int len);

void main(void)
{
    DataType num[length] = {
        64,5,7,89,6,24
    };
    print(num,length);

    printf("\n");
    RadixSort(num,length,2,10);

    print(num,length);
    printf("\n");
}

void print(DataType num[],int len)
{
    int i;
    for(i = 0;i < len; i++)
        printf("%d\t",num[i]);
}
/*
64      5       7       89      6       24
5       6       7       24      64      89
Press any key to continue
*/
OS_windows7
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第九章_解析1
08-04
例如，在简单选择排序中，当在一个待排序区间中选出最小的数据时，会与区间第一个数据对调，而不是顺次后移，这导致方法不稳定。 在选择排序中，当在 n 个数据（n 很大）中选出最小的 5~8 个数据时，锦标赛排序最快...
排序算法总结
wj903829182的专栏
07-21 1351
c，数据结构，排序，选择排序，插入排序
DS_习题_第九章_排序
chengminpi7596的博客
11-22 1863
8.在一个具有n个节点的有序单链表中，插入一个新节点并依然有序的时间复杂度是___ A..O1, B.O(n) C.(n*n) D.O(n;og2 n) 解 ： 由图值知：将这个有序数插入即可，若有n个节点，共需插入的时间次数为n 次，故时间复杂度为O(1); 1.已知序列（1...
读书笔记_大话数据结构第九章_排序
Edward的博客
08-20 245
排序  冒泡【O的n方】 简单选择【O的n方】
第九章 排序
最新发布
m0_73557680的博客
12-23 3419
有组记录的排序码为{ 46，79，56，38，40，84 }，则利用堆排序的方法建立的初始堆为：(D)将一个长度为n的无序序列不断分解成两个规模大致相等的子序列，直到子序列大小为1.a.冒泡排序：通过对相邻的数据元素进行交换，一次交换只能消除一个逆序（稳定）二分插入排序：最好情况：o(nlog(n)) 最坏情况（o(n*n)）c.堆排序（弥补树形选择排序占用空间多的遗憾）（不稳定）b.快速排序：一次交换可能消除多个逆序（不稳定）a.简单选择排序（不稳定）a.直接插入排序（稳定）b.折半插入排序（稳定）
《算法导论3rd第七章》快速排序
懒猫的脚印
11-17 960
算法导论，第七章，快速排序
数据结构和算法-第9章-排序系列文章
北巷东东的专栏
05-22 477
数据结构和算法-第9章-排序系列文章
【排序引论】第一章 绪论
热门推荐
知不足而奋进，望远山而前行
05-25 2万+
文章目录1 排序问题的引例2 排序问题的定义3 处理机分类4 部分符号说明5 排序问题分类6 排序问题的求解7 课后习题 1 排序问题的引例 2 排序问题的定义 3 处理机分类 4 部分符号说明 5 排序问题分类 6 排序问题的求解 7 课后习题 习题1 习题2 这一题使用java编写的程序，进行遍历（全排列）求解，但是由于规模较大，需要遍历很久，所以我将题目简化成了2个处理机，p=（9，8，7，6，5，4，3），求解结果如下（最优解由任务索
算法导论_第二章_2.3-1_归并排序
Skying_的博客
04-30 314
算法导论第二章，合并排序，归并排序，C++实现
第7章 排序
weixin_64800741的博客
12-17 1134
在这一章，我们讨论数组元素的排序问题。为简单起见，假设在我们的例子中数组只包含整数，虽然更复杂的结构显然也是可能的。对于本章的大部分内容，我们还假设整个排序工作能够在主存中完成，因此，元素的个数相对来说比较小(小于)。当然，不能在主存中完成而必须在磁盘或磁带上完成的排序也相当重要。这种类型的排序叫作外部排序(external sorting)，将在本章末尾讨论外部排序。 我们对内部排序的考察将指出： 本章的其余部分将描述和分析各种排序算法。这些算法包含一些有趣的、重要的代码优化和
《数据结构》王道 第八章 排序
壹的博客
05-26 2092
《数据结构》王道 第八章 排序 1. 排序的基本概念1.1 算法的评价指标2. 插入排序2.1 算法实现2.2 算法效率分析2.3 优化2.4 对链表进行插入排序 1. 排序的基本概念 1.1 算法的评价指标 2. 插入排序 2.1 算法实现 2.2 算法效率分析 2.3 优化 2.4 对链表进行插入排序 ...
第9章_内部排序.zip
12-05
这一章的主题聚焦于“内部排序”，即数据在内存中进行的排序过程，区别于外部排序，后者涉及到大到无法一次性装入内存的数据集。内部排序算法的效率直接影响到程序的运行时间和资源消耗。下面我们将深入探讨这一主题...
数据结构：第9章_内部排序.ppt
09-17
数据结构：第9章_内部排序.ppt
第九章_电脑展示_
10-02
在本章"第九章_电脑展示_"中，我们将探讨如何有效地设计和呈现电脑展示界面，这一主题主要聚焦于用户交互和视觉设计。电脑展示界面是技术行业中的一个重要元素，它通常用于在线销售、产品演示或者信息共享。在这个...
第9章_查找 .zip
12-05
本章我们将聚焦于“查找”这一主题，并以一个名为“第9章_查找 .zip”的压缩包文件作为讨论的核心。这个压缩包内包含了一份名为“第9章_查找 .ppt”的演示文稿，我们可以推测这是一份关于查找算法的教育材料，可能...
第2章_线性表
北辰
08-16 1523
线性结构的特点是除第一个和最后一个数据元素外每个数据元素只有一个前驱数据元素和一个后继数据元素。线性表是一种最简单的线性结构。线性表的操作特点主要是可以在任意 位置插入和删除一个数据元素。线性表可以用顺序存储结构和链式存储结构存储。用顺序存储结构实现的线性表称作顺序表，用链式存储结构实现的线性表称作链表。链表主要有单链表、循环单链表和双向循环链表三种。顺序表和单链表各有优缺点，并且优缺点刚好相反。线
第1章 C语言程序设计
北辰
07-16 1252
本数据结构系列文章均参考西安交通大学出版的数据结构一书，由朱战立编著。 0.1程序的结构 写文章要考虑文章的结构,编写程序也要考虑程序的结构.程序是处理特定问题的用程序设计语言书写的语句序列.当要处理的问题复杂时,程序将会很长.因此,程序的结构就非常重要. C语言程序的结构一般如下: 函数1 函数2 … 函数n 主函数函数分为库函数和用户自定义函数两大
第6章_递归
北辰
09-13 1249
递归算法不是一种数据结构,而是一种有效的算法设计方法。递归的概念若一个算法直接地或间接地调用自己本身，则称这个算法是递归算法。 递归算法 用把问题分解为形式更加简单的子问题的方法来求解问题。递归算法既是一种有效的分析问题的方法，也是一种有效的算法设计方法。递归算法是解决许多复杂应用问题的重要方法。递归算法的执行过程例1： 计算阶乘函数的递归算法，并给出n = 3时递归算法的执行过程。#inclu
第7章_树和二叉树
北辰
09-25 707
数据结构可分为线性结构、树型结构和图型结构三大类。前几章讨论的线性表、堆栈、队列、串和数组都是线性结构。树型结构中每个结点只允许有一个直接前驱结点，但允许有一个以上直接后继结点。树型结构有树和二叉树两种。二叉树是最多只允许有两个直接后继结点的有序树。树的操作实现比较复杂，但树可以转换为二叉树进行处理。树树的定义树是由n(n>=0)个结点构成的集合。n=0的树称为空树；对n>0的树T，有：（1）有一个
数据结构第9章1
08-08
第9章 排序一、复习要点排序是使用最频繁的一类算法。排序分内排序与外排序。内排序算法主要分5大类，有12个算法。在插入排序类中讨论了直接插入排序、二分法插入排序

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值