c#数据结构文摘

 

 

1.   绪论

数据是人们利用文字，数学符号，以及其他规定的符号对现实世界的事物以其活动所做的抽象描述

表示一个事物的一组数据称为一个数据元素

构成数据元素的数据称为该数据元素的数据项

没有实际含义的数据元素称为抽象数据元素

数据元素之间的相互联系方式称为数据的逻辑结构

 

数据的逻辑结构可分为：

1。线性结构:除第一个和最后一个数据元素外，每个数据元素只有一个前驱数据元素和一个后继数据元素

2。树结构:除根节点外，每个数据元素只有一个前驱数据元素，可有0个或多个后继数据元素

3。图结构:每个数据元素可有0个或多个前驱和后继数据元素

 

数据在计算机中的存储方式称为数据的存储结构

1。顺序存储结构:

把数据元素存储在一块连续地址空间的内存中，逻辑上相邻的数据元素在物理上也相邻,数据间的逻辑关系表现在数据元

素的存储位置关系上

2。链式存储结构

是用指针把相互直接关联的结点链接起来，逻辑上相邻的数据元素在物理上不一定相邻，数据间的逻辑关系表现在结点的

链接关系上

 

类型是一组值的集合

数据类型是在指一个类型和定义在这个类型上的操作集合

--------------------------------------------------------------------------

表示算法的时间效率与算法所处理的数据元素个数n函数关系的函数是O()函数

时间复杂度T(n)和数据元素个数n无关时，T(n) = O(1)

时间复杂度T(n)和数据元素个数n为线性关系时，T(n) = O(n)

时间复杂度T(n)和数据元素个数n为二次方关系时，T(n) = O(n2)

 

空间复杂度分析算法在运行时所需要的内存空间的数量级,一般为S(n) = O(1)

 

2.线形表

在任意位置都可以插入或删除一个元素

顺序表：支持随机读取，以及内存空间利用效率高；需要预先给出最大数据元素个数，插入和删除需要移动叫多的数据元素. T(n) =O(1)

 

单链表：不需要给出最大个数，不需要移动数据;不支持随机读取，每个节点有个指针，空间效率略低.

指针表示一个数据元素逻辑意义上的存储位置.

把一个数据元素和一个指针称为一个结点. T(n) = O(n);

 

3.堆栈和队列

堆栈是特殊的线形表，栈顶插入和删除，后进先出

可以用来完成数据序列的特定转换

 

队列是特殊的线形表，队尾插入，队头删除,先进先出

队列可以用作数据元素序列的缓冲存储

 

4.串

 

5.数组，集合和矩阵

数组和线性表的异同:

数组要求其元素占用一块地址连续的内存单元空间，线性表无此要求

线性表的元素是逻辑意义上不可再分的元素，而数组中的每个元素还可以是一个数组

数组的操作主要是向某个下标的数组元素中存数据和取某个下标的数组元素

 

6.递归算法

Fact(6);

int[] a = { 2,5,7,9,23,45,67,89};

BSearch(a,67,0,7);          

PrintNumber(9);

 

//n阶层

public static long Fact(int n)

{

    int x;

    long y;

 

    if (n < 0) throw new Exception("参数错!");

    if (n == 0) return 1;

    else

    {

        x = n - 1;

        y = Fact(x);

        return n * y;

    }

}

//用递归实现二分查找

public static int BSearch(int[] a, int x,int low,int high)

{

    int mid;

 

    if (low > high) return -1;

 

    mid = (low + high) / 2;

    if (a[mid] == x) return mid;

    else if (x < a[mid])  return BSearch(a, x, low, mid - 1);

    else  return BSearch(a, x, mid + 1, high);

 

}

 

//递归问题举例

public static void PrintNumber(int number)

{

    for (int i = 0; i < number; i ++ )

    {

        Console.Write(number + " ");

    }

    Console.WriteLine("");

    if (number > 0)

    {

        PrintNumber(number - 1);

    }

}

 

//9 9 9 9 9 9 9 9 9

//8 8 8 8 8 8 8 8

//7 7 7 7 7 7 7

//6 6 6 6 6 6

//5 5 5 5 5

//4 4 4 4

//3 3 3

//2 2

//1

 

7.树和二叉树

 

8.图

 

9.排序

int[] a = { 3,45,2,24,4,11,7};

 

//直接插入排序

int j, temp;

 

for (int i = 0; i < a.Length - 1; i++)

{

    temp = a[i + 1];

    j = i;

    while (j > -1 && temp <= a[j])

    {

        a[j + 1] = a[j];

        j--;

    }

    a[j + 1] = temp;

}

 

//希尔排序 分组组内是直接插入排序

 

//直接选择排序

int j, small, temp;

 

for (int i = 0; i < a.Length - 1; i++)

{

    small = i;

    for (j = i + 1; j < a.Length; 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;

    }

}

 

//堆排序基于完全二叉树的排序

 

//冒泡排序

int j, temp;

int flag = 1;

 

for (int i = 1; i < a.Length && flag == 1; i++)

{

    flag = 0;

    for (j = 0; j < a.Length - i; j++)

    {

        if (a[j] > a[j + 1])

        {

            flag = 1;

            temp = a[j];

            a[j] = a[j + 1];

            a[j + 1] = temp;

        }

    }

}

 

//快速排序 二叉树结构的递归排序

//归并排序 二路归并排序

//基数排序 为整数高效的排序方法

 

10.查找

int[] a = { 3, 56, 4, 45, 2, 13, 23, 78, 6, 29, 5 };

int[] b = { 2, 3, 4, 5, 6, 13, 23, 29, 45, 56, 78 };

int elem = 13;

SeqSearch(a,elem);

OrderSeqSearch(b,elem);

BiSearch(b,45);

 

//静态查找

//无序序列查找

public static int SeqSearch(int[] a,int elem)

{

    int i = 0;

    while (i < a.Length && a[i] != elem)

    {

        i++;

    }

    if (a[i] == elem) return i;

    else return -1;           

}

//有序序列查找

//顺序查找

public static int OrderSeqSearch(int[] a, int elem)

{

    int i = 0;

    while (i < a.Length && a[i] < elem)

    {

        i++;

    }

    if (a[i] == elem) return i;

    else return -1;

}

//二分查找

//1。循环结构

public static int BiSearch(int[] a, int elem)

{

    int low = 0;

    int high = a.Length - 1;

    int mid;

 

    while(low <= high)

    {

        mid = (low + high) / 2;

        if (a[mid] == elem) return mid;

        else if (a[mid] < elem) low = mid + 1;

        else high = mid - 1;

    }

    return -1;

}

//2。递归结构

//索引结构

 

//动态查找

//二叉排序树

//B_树

 

11.哈希表

一种数据元素极其在内存中的位置之间存在某种函数关系的特殊的存储结构

哈希表构造一个映射函数，该函数以函数元素为自变量，函数值即为数据元素在内存中的存储位置。此为哈希函数h（x）.哈希表是通过哈希函数h(x)来确定数据元素x存放位置h(x)的一种特殊存储结构.