数据结构算法背诵

最新推荐文章于 2021-11-02 09:47:14 发布
最新推荐文章于 2021-11-02 09:47:14 发布
阅读量1.3k 收藏 40
点赞数 9
CC 4.0 BY-SA版权
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Mr_SuperBaby/archive/2012/03/17/2403935.html

一、线性表

1.逆转顺序表中的所有元素

算法思想：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，……，依此类推。

View Code 
void Reverse(int A[], int n)
{
int i, t;
for (i=0; i < n/2; i++)
    {
        t = A[i];
        A[i] = A[n-i-1];
        A[n-i-1] = t;
    }
}



2.删除线性链表中数据域为

item的所有结点

算法思想：先从链表的第

2个结点开始，从前往后依次判断链表中的所有结点是否满足条件，若某个

结点的数据域为

item，则删除该结点。最后再回过头来判断链表中的第

1个结点是否满足条件，若

满足则将其删除。

 

void PurgeItem(LinkList& thelist)
{　　

　   LinkList theTempList = thelist;

    LinkList p;

    p = thelist->next;

while (p !=  NULL)
    {        
if ( p->data == item )
        {             
            theTempList ->next = p->next;

            delete p;

            p = theTempList ->next; 

        }
else
        {             
            theTempList  = p;

            p = p->next;
         }
    }

if (thelist->data == item)
    {
        theTempList  = thelist;

        thelist = thelist->next;

        delete theTempList ;

        theTempList  = NULL;

    }
}


 

3.逆转线性链表

void Reverse(LinkList& thelist)

{

    LinkList p;
    LinkList q;
    LinkList  r;

    p = thelist;

    q = NULL;

while (p != NULL)
    {

        r = q;

        q = p;

        p = p->next;

        q->next = r;

     }

     thelist = q;

}


 

 

4.复制线性链表（递归）

View Code 
LinkList Copy(LinkList lista)

{

    LinkList listb;

if (lista == NULL)
    {
return NULL;
    }
else
    {
        listb = (LinkList)malloc(sizeof(LNode));

        listb->data = lista->data;

        listb->next = Copy(lista->next);

return listb;
     }

}


 

 

5.将两个按值有序排列的非空线性链表合并为一个按值有序的线性链表

View Code 
LinkList MergeList(LinkList lista, LinkList listb)

{

    LinkList listc;
    LinkList p = lista;
    LinkList q = listb;
    LinkList r;

// listc 指向 lista 和 listb 所指结点中较小者

if (lista->data <= listb->data)
     {

         listc = lista;

         r = lista;

         p = lista->next;
     }
else 
     {

         listc = listb;

         r = listb;

         q = listb->next;

      }



while (p != NULL && q != NULL)
    {

if (p->data <= q->data)
        {

             r->next = p;

             r = p;

             p = p->next;

         }
else
         {

              r->next = q;

              r = q;

              q = q->next;

          }
     }

// 将剩余结点（即未参加比较的且已按升序排列的结点）链接到整个链表后面

      r->next = (p != NULL) ? p : q;

return listc;

}


 

 

二、树

 

 

1.二叉树的先序遍历（非递归算法）

算法思想：若

p所指结点不为空，则访问该结点，然后将该结点的地址入栈，然后再将

p指向其左孩

子结点；若

p所指向的结点为空，则从堆栈中退出栈顶元素（某个结点的地址），将

p指向其右孩子

结点。重复上述过程，直到

p = NULL且堆栈为空，遍历结束。

View Code 
 
#define MAX_STACK 50


void PreOrderTraverse(BTree T)
{

    BTree STACK[MAX_STACK], p = T;

int top = -1;

while (p != NULL || top != -1)
    {

while (p != NULL)
        {
            VISIT(p);

            STACK[++top] = p;

            p = p->lchild;
        }

        p = STACK[top--];

        p = p->rchild;
     }
}


 

 

2.二叉树的中序遍历（非递归算法）

算法思想：若

p所指结点不为空，则将该结点的地址

p入栈，然后再将

p指向其左孩子结点；若

p所

指向的结点为空，则从堆栈中退出栈顶元素（某个结点的地址）送

p，并访问该结点，然后再将

p指

向该结点的右孩子结点。重复上述过程，直到

p = NULL且堆栈为空，遍历结束。

View Code 
#define MAX_STACK 50


void InOrderTraverse(BTree T)
{

    BTree STACK[MAX_STACK], p = T;

int top = -1;

while (p != NULL || top != -1);
    {

while (p != NULL)
        {

            STACK[++top] = p;

            p = p->lchild;
        }

        p = STACK[top--];

        VISIT(p);

        p = p->rchild;

      }

}


 

 

3.二叉树的后序遍历（非递归算法）

算法思想：当

p指向某一结点时，不能马上对它进行访问，而要先访问它的左子树，因而要将此结点

的地址入栈；当其左子树访问完毕后，再次搜索到该结点时（该结点地址通过退栈得到），还不能对

它进行访问，还需要先访问它的右子树，所以，再一次将该结点的地址入栈。只有当该结点的右子

树访问完毕后回到该结点时，才能访问该结点。为了标明某结点是否可以访问，引入一个标志变量

flag，当

flag = 0时表示该结点暂不访问，

flag = 1时表示该结点可以访问。flag的值随同该结点的地

址一起入栈和出栈。因此，算法中设置了两个堆栈，其中

STACK1存放结点的地址，STACK2存放

标志变量

flag，两个堆栈使用同一栈顶指针

top，且

top的初始值为

.1。

 

View Code 
#define MAX_STACK 50

void PostOrderTraverse(BTree T)
{

    BTree STACK1[MAX_STACK], p = T;

int STACK2[MAX_STACK], flag, top = -1;

while (p != NULL || top != -1)
    {
while (p != NULL) {

        STACK1[++top] = p;

        STACK2[top] = 0;

        p = p->lchild;
    }

    p = STACK1[top];

    flag = STACK2[top--];

if (flag == 0) 
    {

        STACK1[++top] = p;

        STACK2[top] = 1;

        p = p->rchild;
    }
else
    {

         VISIT(p);

         p = NULL;
    }

}


 

 

4.二叉树的按层次遍历

算法思想：设置一个队列，首先将根结点（的地址）入队列，然后依次从队列中退出一个元素，每

退出一个元素，先访问该元素所指的结点，然后依次将该结点的左孩子结点（若存在的话）和右孩

子结点（若存在的话）入队列。如此重复下去，直到队列为

View Code 
#define MAX_QUEUE 50



void LayeredOrderTraverse(BTree T)
{

    BTree QUEUE[MAX_QUEUE], p;

int front, rear;
if (T != NULL)
    {

        QUEUE[0] = T;

        front = -1;

        rear = 0;

while (front < rear)
    {
        p = QUEUE[++front];

        VISIT(P);

if (p->lchild != NULL)

       QUEUE[++rear] = p->lchild;

if (p->rchild != NULL)

       QUEUE[++rear] = p->rchild;

    }

}

 

 

 

 

5.建立二叉树（从键盘输入数据，先序遍历递归算法）

View Code 
BTree CreateBT()
{

char ch;

    BTree T;

    sacnf("%c", &ch);

if (ch == ' ')
    {
return NULL;
    }
else
    {
        T = (BTree)malloc(sizeof(BTNode));

        T->data = ch;

        T->lchild = CreateBT();

        T->rchild = CreateBT();

return T;
     }

}


 

 

6.建立二叉树（从数组获取数据）

View Code 
BTree CreateBT(int A[], int i, int n)

{

    BTree p;

if (i > n)
    {
return NULL;
    }
else
    {

        p = (BTree)malloc(sizeof(BTNode));

        p->data = A[i];

        p->lchild = CreateBT(A, 2*i, n);

        p->rchild = CreateBT(A, 2*i+1, n);

return p;

     }

}

    T = CreateBT(A, 1, n);



BTree CreateBT(int A[], int n)
{

int i;

        BTree *pT;

// 对应

      n个结点申请可容纳

      n个指针变量的内存空间

      pT = (BTree *)malloc(sizeof(BTree)*n);

// 若数组中的某个元素不等于零，则申请相应的结点空间并进行赋值

for (i=1; i <= n; i++)
      {

if (A[i] != 0)
          {

               pT[i] = (BTree)malloc(sizeof(BTNode));

               pT[i]->data = A[i];
           }
else
           {

               pT[i] = NULL;
           }
       }

// 修改结点的指针域的内容，使父结点指向左、右孩子结点

for (i=1; i <= n; i++)
    {
if (pT[i] != NULL)
        {

            pT[i]->lchild = pT[2*i];

            pT[i]->rchild = pT[2*i+1];

         }
    }

}


 

 

 

7.求二叉树的深度（递归算法）

View Code 
int Depth(BTree T)
{

int ldepth, rdepth;

if (T == NULL)
    {
return 0;
    }
else 
    {

        ldepth = Depth(T->lchild);

        rdepth = Depth(T->rchild);

if (ldepth > rdepth)
        {
return ldepth+1;
        }
else
        {
return rdepth+1;

        }
     }

}


 

 

8.求二叉树的深度（非递归算法）

算法思想：对二叉树进行遍历，遍历过程中依次记录各个结点所处的层次数以及当前已经访问过的

结点所处的最大层次数。每当访问到某个叶子结点时，将该叶子结点所处的层次数与最大层次数进

行比较，若前者大于后者，则修改最大层次数为该叶子结点的层次数，否则不作修改。遍历结束时，

所记录的最大层次数即为该二叉树的深度。本算法使用的是非递归的中序遍历算法（其它遍历顺序

也可以）。 

 

View Code 
#define MAX_STACK 50

int Depth(BTree T)
{

    BTree STACK1[MAX_STACK], p = T;

int STACK2[MAX_STACK];

int curdepth, maxdepth = 0, top = -1;

if (T != NULL)
    {

        curdepth = 1;

while (p != NULL || top != -)
        {
while (p != NULL)
            {

                STACK1[++top] = p;

                STACK2[top] = curdepth;

                p = p->lchild;

                curdepth++;
             }

             p = STACK1[top];

             curdepth = STACK2[top--];

if (p->lchild == NULL && p->rchild == NULL)
             {
if (curdepth > maxdepth)
                  {
                     maxdepth = curdepth;
                  }
                  p = p->rchild;
                  curdepth++;
              }
         }

    }

return maxdepth;
}

 

9.求结点所在层次

算法思想：采用后序遍历的非递归算法对二叉树进行遍历，遍历过程中对每一个结点判断其是否为

满足条件的结点，若是满足条件的结点，则此时堆栈中保存的元素个数再加

1即为该结点所在的层次。 

 

View Code 
#define MAX_STACK 50



int LayerNode(BTree T, int item)
{

    BTree STACK1[MAX_STACK], p = T;

int STACK2[MAX_STACK], flag, top = -1;

while (p != NULL || top != -1)
    {

while (p != NULL)
        {

            STACK1[++top] = p;

            STACK2[top] = 0;

            p = p->lchild;
        }

        p = STACK1[top];

        flag = STACK2[top--];

if (flag == 0) 
        {

            STACK1[++top] = p;

            STACK2[top] = 1;

            p = p->rchild;

        }
else 
        {

if (p->data == item)

return top+2;

            p = NULL;

        }

    }

}

 

10.交换二叉树中所有结点的左右子树的位置

算法思想：按层次遍历二叉树，遍历过程中每当访问一个结点时，就将该结点的左右子树的位置对

调。

 

 

#define MAX_QUEUE 50

 

void ExchangeBT(BTree T)

 

{

BTree QUEUE[MAX_QUEUE], temp, p = T;

int front, rear;

 

 

if (T != NULL)

 

{

QUEUE[0] = T;

front = -1;

rear = 0;

while (front < rear)

{

 

 

p = QUEUE[++front];

temp = p->lchild;

p->lchild = p->rchild;

p->rchild = temp;

if (p->lchild != NULL)

 

 

QUEUE[++rear] = p->lchild;

if (p->rchild != NULL)

QUEUE[++rear] = p->rchild;

}

}

}

 

 

 

11.删除二叉树中以某个结点为根结点的子树

算法思想：先序遍历找到符合条件的结点（其它遍历方法亦可），然后删除以该结点为根结点的子树。

最后把该结点的父结点的相应的指针域置为

NULL。为此，需在算法中设置一个指针变量用以指示当

前结点的父结点。

 

 

#define MAX_STACK 50

 

BTree DeleteSubtree(BTree &T, int item)

 

{

BTree STACK[MAX_STACK], q, p = T;

int top = -1;

 

 

if (T->data == item)

 

{

DestroyBT(T);

T = NULL;

return NULL;

 

 

}

else

{

 

 

while (p != NULL || top != -1)

 

{

while (p != NULL)

{

 

 

if (p->data == item)

{

if (q->lchild == p)

q->lchild = NULL;

else

 

 

q->rchild = NULL;

DestroyBT(p);

return T;

 

 

}

STACK[++top]= p;

q = p;

p = p->lchild;

 

 

}

q = STACK[top--];

p = q->rchild;

 

 

}

}

}

 

 

 

三、查找

 

 

1.顺序查找的递归算法

int RecurSeqSearch(int A[], int n, int key, int i)

{

if (i >= n)

return -1;

if (A[i] == key)

return i;

else

return RecurSeqSearch(A, n, key, i+1);

}

 

pos = RecurSeqSearch(A, n, key, 0);

 

2.折半查找

int BinSearch(int A[], int n, int key)

{

int low=0, high=n-1, mid;

 

 

while (low <= high)

 

{

mid = (low+high)/2;

if (key == A[mid])

 

 

return mid;

if (key > A[mid])

low = mid + 1;

else

 

 

high = mid – 1;

}

return -1;

 

 

}

 

3.折半查找的递归算法

int RecurBinSearch(int A[], int low, int high, int key)

{

int mid;

 

if (low > high)

return -1;

 

 

else {

mid = (low+high)/2;

if (key == A[mid])

 

 

return mid;

if (key > A[mid])

return RecurBinSearch(A, mid+1, high, key);

else

return RecurBinSearch(A, low, mid-1, key);

}

}

 

pos = RecurBinSearch(A, 0, n-1, key);

 

 

4.在按值递增排列且长度为

n的线性表中折半查找并插入一元素

void BinInsert(int A[], int &n, int key)

{

int j, low=0, high=n-1, mid;

 

 

while (low <= high)

 

{

mid = (low+high)/2;

if (key > A[mid])

 

 

low = mid + 1;

else

high = mid – 1;

}

 

 

for (j=n; j > low; j--)

 

A[j] = A[j-1];

A[low] = key;

n++;

 

 

}

 

5.在按值递增排列且长度为

n的线性表中折半查找值不小于

key的最小元素

void BinSearch(int A[], int n, int key)

{

int low=0, high=n-1, mid;

 

 

while (low <= high)

 

{

mid = (low+high)/2;

if (key == A[mid])

 

 

return mid;

if (key > A[mid])

low = mid + 1;

else

high = mid – 1;

}

 

 

if (low <= n-1)

return low;

else

return -1;

}

 

 

 

四、排序

 

 

1.插入排序

算法思想：第

i趟插入排序为：在含有

i . 1个元素的有序子序列中插入一个元素，使之成为含有

i

个元素的有序子序列。在查找插入位置的过程中，可以同时后移元素。整个过程为进行

n .1趟插入，

即先将整个序列的第

1个元素看成是有序的，然后从第

2个元素起逐个进行插入，直到整个序列有序

为止。

 

 

void InsertSort(int A[], int n)

{

int i, j, temp;

 

 

for (i=1; i <= n-1; i++)

 

{

if (A[i] < A[i-1])

{

 

 

j = i-1;

temp = A[i];

while (j >= 0 && temp < A[j])

{

 

 

A[j+1] = A[j];

 

j--;

}

A[j+1] = temp;

 

 

}

}

}

 

 

2.折半插入排序

算法思想：算法同直接插入排序，只不过使用折半查找的方法来寻找插入位置。

 

 

void BinInsertSort(int A[], int n)

{

int i, j, low, high, mid, temp;

 

 

for (i=1; i <= n-1; i++)

 

{

temp = A[i];

low = 0;

high = i – 1;

while (low <= high)

{

 

 

mid = (low+high)/2;

if (temp > A[mid])

low = mid + 1;

else

 

 

high = mid – 1;

}

for (j=i; j > low; j--)

 

 

A[j] = A[j-1];

A[low] = temp;

}

}

 

 

 

3.冒泡排序

算法思想：首先将第

1个元素和第

2个元素进行比较，若前者大于后者，则两者交换位置，然后比较

第

2个元素和第

3个元素。依此类推，直到第

n . 1个元素和第

n个元素进行过比较或交换为止。上

述过程称为一趟冒泡排序，其结果是使得

n个元素中值最大的那个元素被安排在最后一个元素的位置

上。然后进行第二趟排序，即对前

n . 1个元素进行同样的操作，使得前

n . 1个元素中值最大的那

个元素被安排在第

n . 1个位置上。一般地，第

i趟冒泡排序是从前

n .

i + 1个元素中的第

1个元素

开始，两两比较，若前者大于后者，则交换，结果使得前

n .i + 1个元素中最大的元素被安排在第

n

.

i + 1个位置上。显然，判断冒泡排序结束的条件是"在一趟排序中没有进行过交换元素的操作"，

为此，设立一个标志变量

flag，flag = 1表示有过交换元素的操作，

flag = 0表示没有过交换元素的操

作，在每一趟排序开始前，将

flag置为

0，在排序过程中，只要有交换元素的操作，就及时将

flag置

为

1。因为至少要执行一趟排序操作，故第一趟排序时，

flag = 1。

 

 

void BubbleSort(int A[], int n)

{

int i, j, temp, flag = 1;

 

 

for (i=n-1; i >= 1 && flag == 1; i--)

 

{

flag = 0;

for (j=0; j < i; j++)

{

 

 

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

 

{

temp = A[j];

A[j] = A[j+1];

A[j+1] = temp;

flag = 1;

 

 

}

}

}

}

 

 

4.选择排序

算法思想：第

i趟排序从序列的后

n .

i + 1（i = 1, 2, …, n . 1）个元素中选择一个值最小的元素与该

个元素的第

1个元素交换位置，即与整个序列的第

i个元素交换。依此类推，直到

i = n . 1为止。也

就是说，每一趟排序从从未排好序的那些元素中选择一个值最小的元素，然后将其与这些未排好序

的元素中的第

1个元素交换位置。

 

 

void SelectSort(int A[], int n)

{

int i, j, min, temp;

 

 

for (i=0; i < n; i++)

 

{

min = i;

for (j=i+1; j < n; j++)

{

 

 

if (A[min] > A[j])

 

min = j;

}

if (min != i)

{

 

 

temp = A[min];

A[min] = A[i];

A[i] = temp;

 

 

}

}

}

 

 

 

5.快速排序

算法思想：在参加排序的序列中任意选择一个元素（通常称为分界元素或基准元素），把小于或等于

分界元素的所有元素都移到分界元素的前面，把大于分界元素的所有元素都移到分界元素的后面，

这样，当前参加排序的序列就被划分成前后两个子序列，其中前一个子序列中的所有元素都小于后

一个子序列的所有元素，并且分界元素正好处于排序的最终位置上。然后分别对这两个子序列递归

地进行上述排序过程，直到所有元素都处于排序的最终位置上，排序结束。

 

 

void QuickSort(int A[], int n)

{

QSort(A, 0, n-1);

}

 

 

void QSort(int A[], int low, int high)

{

int pivotloc;

 

 

if (low < high)

 

{

pivot = Partition(A, low, high);

QSort(A, low, pivotloc-1);

QSort(A, pivotloc+1, high);

 

 

}

}

 

 

int Partition(int A[], int low, int high)

{

int pivot;

 

 

pivot = A[low];

// 从线性表的两端交替地向中间扫描

while (low < high)

{

while (low < high && A[high] >= pivot)

high--;

A[low] = A[high];

while (low < high && A[low] <= pivot)

low++;

A[high] = A[low];

}

A[low] = pivot;

return low;

}

 

 

 

6.堆排序

void HeapSort(int A[], int n)

{

int i, temp;

 

 

// 建立大顶堆

for (i = n/2; i >= 1; i--)

HeapAdjust(A,i,n);

 

for (i = n-1; i >= 1; i--)

 

{

temp = A[1];

A[1] = A[i+1];

A[i+1] = temp;

// 将 A[1..i] 重新调整为大顶堆

HeapAdjust(A,1,i);

 

}

}

 

 

void HeapAdjust(int A[], int low, int high)

{

int i, temp;

 

temp = A[low];

for (i=2*low; i <= high; i=i*2)

 

 

{

// 令 i 为关键字较大的记录的下标

if (i < high && A[i] < A[i+1])

i++;

if (temp >= A[i])

break;

 

else {

A[low] = A[i];

low = i;

 

}

 

}

}

A[low] = temp; // 插入

转载于:https://www.cnblogs.com/Mr_SuperBaby/archive/2012/03/17/2403935.html

digui4912
关注
数据结构算法背诵（考研必用）
09-14
考研必用到的数据结构算法。考研后复试上机时用到的算法。
考研数据结构常用算法
11-26
408计算机考研数据结构常用算法背诵，经典常考算法代码，适合考试前冲刺背诵。预祝考研成功！
数据结构算法与分析必背版
07-25
内含数据结构关于各种线性表，树，查找，排序的算法思想及代码
考研数据结构算法总结
02-18
考研数据结构经典算法总结，很全的，很强大。。
数据结构考研必背算法5星.pdf
05-12
本文档是针对考研专业课《数据结构》所编写的，是对考研数据结构的核心算法进行总结，我们知道，不管是统考还是非统考，都会涉及至少10分的算法题（非统考至少25分），而这些题的答案都是在一些经典算法的思想上进行改进的，本文总结出必须要熟练掌握的算法，这些算法不管是考研初期还是冲刺，都应该高度重视，只要对这些代码进行熟练掌握，才能随机应变，希望对大家有所帮助；
考研408数据结构算法背诵
最新发布
01-02
为了帮助考生们更好地应对这一挑战，本篇文章将深入解析【考研408数据结构算法背诵】这份资料，解读其中的要点，并提供学习策略，以期帮助考生们在考试中取得优异的成绩。 首先，我们来探讨线性表这一基本的数据...
数据结构算法背诵版1
08-08
数据结构和算法是计算机科学的基础，对于理解和优化程序性能至关重要。在给定的描述和部分内容中，我们涉及了几个关键的算法，主要集中在线性表和树这两种数据结构上。 1. **线性表操作**： - **逆转顺序表**：...
数据结构算法 背诵篇
10-04
### 数据结构算法背诵篇：考研必备知识点概览 #### 一、线性表操作精解 线性表是数据结构中最基础的概念之一，通过掌握线性表的操作，可以为后续更复杂的数据结构学习奠定坚实的基础。以下是几种关键的线性表操作...
数据结构算法 背诵篇.pdf
03-19
数据结构算法 背诵篇.pdf
学习数据结构算法必备
12-04
数据结构算法演示 1． 顺序表 （1）在顺序表中插入一个数据元素(ins_sqlist) （2）删除顺序表中一个数据元素(del_sqlist) （3）合并两个有序顺序表(merge_sqlist) 2． 链表 （1）创建一个单链表(Crt_LinkList) （2）在单链表中插入一个结点(Ins_LinkList) （3）删除单链表中的一个结点(Del_LinkList) （4）两个有序链表求并(Union) （5）归并两个有序链表(MergeList_L) （6）两个有序链表求交(ListIntersection_L) （7）两个有序链表求差(SubList_L) 3． 栈和队列 （1）计算阿克曼函数(AckMan) （2）栈的输出序列(Gen、Perform) （3）递归算法的演示  汉诺塔的算法(Hanoi)  解皇后问题的算法(Queen)  解迷宫的算法(Maze)  解背包问题的算法(Knap) （4）模拟银行(BankSimulation) （5）表达式求值(Exp_reduced) 4． 串的模式匹配 （1）古典算法(Index_BF) （2）求Next 函数值(Get_next)和按Next 函数值进行匹配 (Index_KMP(next)) （3）求 Next 修正值(Get_nextval)和按 Next 修正值进行匹配(Index_KMP(nextval)) 5． 稀疏矩阵 （1）矩阵转置 (Trans_Sparmat) （2）快速矩阵转置 (Fast_Transpos) （3）矩阵乘法 (Multiply_Sparmat) 6． 广义表 （1）求广义表的深度(Ls_Depth) (2）复制广义表(Ls_Copy) （3）创建广义表的存储结构(Crt_Lists) 7． 二叉树 （1）遍历二叉树  二叉树的线索化  先序遍历(Pre_order)  中序遍历(In_order)  后序遍历(Post_order) (2) 按先序建二叉树(CrtBT_PreOdr) (3) 线索二叉树  二叉树的线索化  生成先序线索(前驱或后继) (Pre_thre)  中序线索（前驱或后继) (In_thre)  后序线索(前驱或后继) (Post_thre)  遍历中序线索二叉树(Inorder_thlinked)  中序线索树的插入(ins_lchild_inthr)和删除(del_lchild_inthr)结点 （4）建赫夫曼树和求赫夫曼编码(HuffmanCoding) （5）森林转化成二叉树(Forest2BT) （6）二叉树转化成森林(BT2Forest) （7）按表达式建树(ExpTree)并求值(CalExpTreeByPostOrderTrav) 8． 图 （1）图的遍历  深度优先搜索(Travel_DFS)  广度优先搜索(Travel_BFS) （2）求有向图的强连通分量(Strong_comp) （3）有向无环图的两个算法  拓扑排序(Toposort)  关键路径(Critical_path) （4）求最小生成树  普里姆算法(Prim)  克鲁斯卡尔算法(Kruscal) （5）求关节点和重连通分量(Get_artical) （6）求最短路径  弗洛伊德算法(shortpath_Floyd)  迪杰斯特拉算法(shortpath_DIJ) 9． 存储管理 （1）边界标识法 (Boundary_tag_method) （2）伙伴系统 (Buddy_system) （3）紧缩无用单元 (Storage_compaction) 10． 静态查找 （1）顺序查找(Search_Seq) （2）折半查找 (Serch_Bin) （3）插值查找 (Search_Ins) （4）斐波那契查找 (Search_Fib) （5）次优查找树(BiTree_SOSTree) 11． 动态查找 （1）在二叉排序树上进行查找(bstsrch)、插入结点(ins_bstree)和删除结点(del_bstree) （2）在二叉平衡树上插入结点(ins_AVLtree) 和删除结点(del_AVLtree) （3）在 B-树上插入结点(Ins_BTree) 和 删除结点(Del_BTree) （4）在 B+树上插入结点(Ins_PBTree) 和 删除结点(Del_PBTree) 12． 内部排序 （1）简单排序法  直接插入排序(Insert_sort)  表插入排序(内含插入(Ins_Tsort) 重排(Arrange)两个算法)  起泡排序(BubbleSort)  简单选择排序(SelectSort) （2）复杂排序法  堆排序(HeapSort)  快速排序(QuickSort)  锦标赛排序(Tournament) （3）其他  快速地址排序（QkAddrst）  基数排序(RadixSort) 13． 外部排序 （1）多路平衡归并排序(K-Merge) （2）置换-选择排序(Repl_Selection)
数据结构经典算法（考研需要的都包括）
10-24
数据结构经典算法。基本上需要的都有。考研需要的都包括。
考研数据结构算法代码总结.pdf
05-12
考研数据结构算法总结
数据结构考研，计算机考研必看
07-16
一、选择题 1. 散列文件使用散列函数将记录的关键字值计算转化为记录的存放地址，因为散列函数是一对一的关系，则选择好的（ ）方法是散列文件的关键。【哈尔滨工业大学 2001二、5 （2分）】 A. 散列函数 B. 除余法中的质数 C. 冲突处理 D. 散列函数和冲突处理 2. 顺序文件采用顺序结构实现文件的存储，对大型的顺序文件的少量修改，要求重新复制整个文件，代价很高，采用（ ）的方法可降低所需的代价。【北京邮电大学 2000 二、8 （20/8分）】 A. 附加文件 B. 按关键字大小排序 C. 按记录输入先后排序 D. 连续排序 3. 用ISAM组织文件适合于（ ）。【中科院软件所 1998】 A．磁带 B．磁盘 4．下述文件中适合于磁带存储的是（ ）。【中科院计算所 2000 一、7（2分）】 A. 顺序文件 B. 索引文件 C. 散列文件 D. 多关键字文件 5. 用ISAM和VSAM组织文件属于（ ）。 A. 顺序文件 B. 索引文件 C. 散列文件 【中国科技大学 1998 二、5（2分） 中科院计算所 1998 二、5（2分）】 6. ISAM文件和VASM文件属于（ ）。【山东大学 2001 二、5 (1分)】 A. 索引非顺序文件 B. 索引顺序文件 C. 顺序文件 D. 散列文件 7. B+树应用在（ ）文件系统中。【北京邮电大学 2001 一、1（2分）】 A. ISAM B. VSAM 二、判断题 1. 文件是记录的集合，每个记录由一个或多个数据项组成，因而一个文件可看作由多个记录组成的数据结构。【长沙铁道学院 1998 一、5 (1分)】 2. 倒排文件是对次关键字建立索引。【南京航空航天大学 1997 一、10（1分）】 3. 倒排序文件的优点是维护简单。【南京航空航天大学 1995 五、10（1分）】 4. 倒排文件与多重表文件的次关键字索引结构是不同的。【西安交通大学 1996 二、6 (3分)】 5. Hash表与Hash文件的唯一区别是Hash文件引入了‘桶’的概念。【南京航空航天大学1996六10(1分）】 6. 文件系统采用索引结构是为了节省存储空间。【北京邮电大学 2000 一、10 （1分）】 7. 对处理大量数据的外存介质而言，索引顺序存取方法是一种方便的文件组织方法。 【东南大学 2001 一、1-10 （1分）】 8. 对磁带机而言，ISAM是一种方便的稳健组织方法。【中科院软件所 1997 一、10（1分）】 9. 直接访问文件也能顺序访问，只是一般效率不高。【北京邮电大学 2002 一、10（1分）】 10. 存放在磁盘，磁带上的文件，即可以是顺序文件，也可以是索引结构或其他结构类型的文件。 【山东大学 2001 一、7 (1分)】 11. 检索出文件中的关键码值落在某个连续的范围内的全部记录，这种操作称为范围检索。对经常需要做范围检索的文件进行组织，采用散列法优于顺序检索法。【中山大学 1994 一、5 （2分）】 三、填空题 1. 文件可按其记录的类型不同而分成两类，即______和______文件。 【西安电子科技大学 1998 二、6（3分）】 2. 数据库文件按记录中关键字的多少可分成______和______两种文件。 【燕山大学 1998 一、10 （2分）】 3. 从用户的观点看，文件的逻辑结构通常可以区分为两类：一类是如 dBASE 中数据库文件那样的文件组织结构，称为_(1)_文件；另一种是诸如用各种文字处理软件编辑成的文本文件，称为__(2)_文件。从文件在存储器上的存放方式来看，文件的物理结构往往可区分为三类，即_(3)_，_(4)_和_(5)_。B+ 树适用于组织_(6)_的索引结构，m 阶B+ 树每个结点至多有_(7)_个儿子，除根结点外每个结点至少有 (8) 个儿子，根结点至少有_(9)_个儿子，有k个儿子的结点必有_(10) 个关键码。 【山东工业大学 1996 一、4（5分）】 4. 文件由______组成；记录由______组成。【大连海事大学 1996 (２分)】 5. 物理记录之间的次序由指针相链表示的顺序文件称为 ______。【燕山大学 1998 一、11 （1分）】 6. 顺序文件中，要存取第I个记录，必须先存取______个记录。【哈尔滨工业大学 2001 一、4 （2分）】 7. 索引顺序文件既可以顺序存取，也可以______存取。【武汉大学2000 一、10】 8. 建立索引文件的目的是______。【中山大学 1998 一、12 （1分）】 9. 索引顺序文件是最常用的文件组织之一，通常用____结构来组织索引。【长沙铁道学院1998二、6(2分)】 10. 倒排序文件的主要优点在于______。【山东工业大学1995一、3（1分）】 11. 检索是为了在文件中寻找满足一定条件的记录而设置的操作。检索可以按______检索，也可以按______检索；按______检索又可以有_________检索和_________检索。【山东大学 1999 一、1 (5分)】 12. 散列检索技术的关键是______和 ______。【山东工业大学 1995 一、2 （2分）】 13. VSAM系统是由______、______、______构成的。【北京科技大学 1997 一、9】 14. VSAM(虚拟存储存取方法)文件的优点是：动态地______，不需要文件进行______，并能较快地______进行查找。【山东大学 2001 三、4 (2分)】 四、应用题 1. 文件【山东工业大学 1998 一、1-1（2分）】 2. 文件存储结构的基本形式有哪些？一个文件采用何种存储结构应考虑哪些因素？ 【燕山大学 1999 二、4(4分）】 3． 名词解释：索引文件【哈尔滨工业大学 2000 一、4 （3分）】 4. 什么是索引顺序文件？【哈尔滨工业大学2001三、5（3分）】【
考研《数据结构》必须掌握的知识点与算法
10-16
考研《数据结构》必须掌握的知识点与算法 考研《数据结构》必须掌握的知识点与算法 考研《数据结构》必须掌握的知识点与算法
【2022---计算机考研】数据结构之基础算法背诵版
优快云_Admin0的博客
11-02 3534
文章目录一、线性表1. 逆转顺序表中的所有元素2. 删除线性链表中数据域为 item 的所有结点3. 逆转线性链表4. 复制线性链表（递归）5. 将两个按值有序排列的非空线性链表合并为一个按值有序的线性链表二、树1. 二叉树的先序遍历（非递归算法）2. 二叉树的中序遍历（非递归算法）3. 二叉树的后序遍历（非递归算法）4. 二叉树的按层次遍历5. 建立二叉树（从键盘输入数据，先序遍历递归算法）6. 建立二叉树（从数组获取数据）8. 求二叉树的深度（非递归算法）9. 求结点所在层次1
【数据结构必背算法】——线性表操作python实现
ywm_up
08-11 705
以下五个算法在数据结构中常考，必须记住！ 逆转线性表 删除线性链表中数据域为 value 的所有结点 逆转线性链表 复制线性链表（递归） 将两个按值有序排列的非空线性链表合并为一个按值有序的线性链表 1. 逆转线性表 def reverse_list(nums): """逆转线性表，双指针从左右往中间靠""" if len(nums) < 2: return nums left, right = 0, len(nums) - 1 while left
数据结构必会算法
dujuancao11的博客
01-31 826
2.2顺序表插入 //顺序表存储结构 #define MAXSIZE 100 typedef struct{ Type elem[MAXSIZE]; int last ; }List; #define OK 1 #define ERROR 0 //在顺序表L中第i个数据元素之前插入一个元素e。 //i的合法取值范围1<=i<=last+2 int InsList(List *L...
数据结构算法详解：线性表操作
“数据结构算法背诵版，涵盖了线性表的操作，包括逆转顺序表、删除特定元素、逆转链表、复制链表以及合并有序链表等核心算法。” 在计算机科学和编程领域，数据结构和算法是至关重要的基础知识。数据结构是组织和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值