数据结构期末

已于 2024-03-05 11:13:20 修改
阅读量474 收藏 9
点赞数 7
文章标签： 数据结构
于 2024-01-17 14:52:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50262940/article/details/135650589
版权

函数题

//6-1 顺序表的删除操作
int del(SeqList *sq,int i)  
{  
    int j;  i--;
  	if ((i<0) || (i > sq->n-1)) return -1;
    else { 
        for (j=i+1;j<= sq->n-1;j++) sq->a[j-1]=sq->a[j];  
     	sq->n--;
		return 1;  
    }
} 

//6-2 求链式表的表长
int Length(List L){
    int n=0;
    List p = L;
    while(p!=NULL){
        n++;
        p=p->Next;
    }
    return n;
}


//6-3 递增的整数序列链表的插入
List Insert( List L, ElementType X ){
List tail=(List)malloc(sizeof(struct Node));
// List tail=(List)malloc(sizeof(struct Node));
tail->Data=X;
tail->Next=NULL;
List head=L;
 while(L->Next!=NULL &&L->Next->Data<=X){
 	L=L->Next;
 }
     tail->Next=L->Next;
    L->Next=tail;
    return head;
}

//6-4 查找中间结点
Node* find_middle(Node* head)
{
     int count = 0;
     Node *p = head;
      if(p == NULL)
          return p;
      while(p->next != NULL)
      {
          count++;
          p = p->next;
      }
      p = head;
      count = count/2;
      while(count > 0)
      {
            p = p->next;
            count--;
      }
      return p;
}

//6-5 求链表的倒数第m个元素
ElementType Find( List L, int m ){
    List L1,L2;
    L1=L->Next;
    L2=L->Next;
    int i;
    for(i = 0;i < m;i++){
        if(L1==NULL){
            return ERROR;
        }
        L1=L1->Next;
    }
    while(L1){
        L1=L1->Next;
        L2=L2->Next;
    }
    return L2->Data;
}

//6-6 链表逆置
struct ListNode *reverse( struct ListNode *head )//没有头结点
{
    struct ListNode *p,*q;
    q=(struct ListNode *)malloc(sizeof(struct ListNode));
    
    if(head==NULL)
        return ;
    p=head->next;
    head->next=NULL;
    
    while(p!=NULL){
        q=p;
        p=p->next;
        q->next=head;
        head=q;
    }
    
    return head;
}

//6-7 两个有序链表序列的合并
List Merge( List L1, List L2 ){
    List a,c,b,l;
    l=(List)malloc(sizeof(PtrToNode));
    a=L1->Next,b=L2->Next,c=l;
    while(a&&b){
        if(a->Data>b->Data){
            c->Next=b;
            b=b->Next;
        }
        else{
            c->Next=a;
            a=a->Next;
        }
        c=c->Next;
    }
    if(a) c->Next=a;
    if(b) c->Next=b;
    L1->Next=NULL;
    L2->Next=NULL;
    return l;
}

//6-8 另类堆栈
bool Push (Stack S, ElementType X) {
    if (S -> Top == S -> MaxSize) {
        printf("Stack Full\n");
        return false;
    }
    S -> Data[(S -> Top)++] = X;
    return true;
}
ElementType Pop(Stack S) {
    ElementType res;
    if (S -> Top == 0) {
        printf("Stack Empty\n");
        return ERROR;
    }
    res = S -> Data[--(S -> Top)];
    return res;
}

//6-9 另类循环队列
bool AddQ(Queue Q, ElementType X)
{
	if (Q->Count == Q->MaxSize)
	{
		printf("Queue Full\n");
		return false;
	}
	Q->Count++;
	Q->Data[(Q->Front + Q->Count) % Q->MaxSize] = X;
	return true;
}
ElementType DeleteQ(Queue Q)
{
	if (Q->Count == 0)
	{
		printf("Queue Empty\n");
		return ERROR;
	}
	Q->Count--;
	Q->Front = (Q->Front+1) % Q->MaxSize;
	return Q->Data[Q->Front];
}

//6-1 求二叉树高度
int GetHeight( BinTree BT ){
    if (BT==NULL)
        return 0;
    int h1=GetHeight(BT->Left);
    int h2=GetHeight(BT->Right);
    return h1>h2?h1+1:h2+1;
}

//6-2 先序输出叶结点
void PreorderPrintLeaves( BinTree BT ){
    if(BT==NULL)
        return;
    if(BT->Left==NULL && BT->Right==NULL)
        printf(" %c",BT->Data);
    PreorderPrintLeaves(BT->Left);
    PreorderPrintLeaves(BT->Right);
}

//6-3 二叉树的遍历
void InorderTraversal( BinTree BT ){
    if(BT){
        InorderTraversal(BT->Left);
        printf(" %c",BT->Data);
        InorderTraversal(BT->Right);
        
    }
}
void PreorderTraversal( BinTree BT ){
    if(BT){
        printf(" %c",BT->Data);
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
    
}
void PostorderTraversal( BinTree BT ){
    if(BT){
        PostorderTraversal(BT->Left);
        PostorderTraversal(BT->Right);
        printf(" %c",BT->Data);
    }
}

void LevelorderTraversal( BinTree BT ){
    
    BinTree T[1000];
    int front=0,rear=0;
    
    if(BT){
        T[rear++]=BT;
        while(front!=rear){
            BT=T[front++];
            printf(" %c",BT->Data);
            if(BT->Left)
                T[rear++]=BT->Left;
            if(BT->Right)
                T[rear++]=BT->Right;
        }
    }
    
}

//6-4 统计二叉树结点个数
int NodeCount(BiTree T)
{
    int cnt = 0;
    if(T)
    {
        cnt++;
        cnt += NodeCount(T->lchild);
        cnt += NodeCount(T->rchild);
    }
    return cnt;
}

//6-5 统计二叉树度为1的结点个数
int NodeCount(BiTree T)
{
    if(!T)
        return 0;
    if((T->lchild && !T->rchild) || (!T->lchild && T->rchild))
    {
        return NodeCount(T->lchild) + NodeCount(T->rchild) + 1;   //思考为什么要 +1 ？
    }
    return NodeCount(T->lchild) + NodeCount(T->rchild);
}

//6-15 求采用邻接矩阵作为存储结构的无向图各顶点的度
void degree(MGraph G)
{
    for (int i = 0; i < G.vexnum; i++) //图的当前顶点数
    {
        int c = 0;
        for (int j = 0; j < G.vexnum; j++)
        {
            if (G.arcs[j][i] != 0) //邻接矩阵
                c++;
        }
        printf("%c:%d\n", G.vexs[i], c); //存放顶点的一维数组
    }
}

//6-16 求采用邻接矩阵作为存储结构的有向图各顶点的入度
void indegree(MGraph G)
{
    for (int i = 0; i < G.vexnum;i++) 
    {
        int cnt=0;
        for (int j = 0; j < G.vexnum;j++)
        {                       
             if(G.arcs[j][i] == 1)
                 cnt++;
        }
        printf("%c:%d\n", G.vexs[i], cnt); 
    }
}

//6-17 邻接矩阵存储图的深度优先遍历
void DFS(MGraph Graph, Vertex V, void (*Visit)(Vertex))
{
    Visit(V);
    Visited[V] = 1;
    for (int i = 0; i < Graph->Nv; i++)
    {
        if (Graph->G[V][i] == 1)
        {
            if (Visited[i] == false)
            {
                // Visited[i] = 1;
                DFS(Graph, i, Visit);
            }
        }
    }
}

//6-18 图的深度遍历-邻接表实现
void DFS(ALGraph *G, int i)
{
    printf(" %d", i);
    visited[i] = 1;
    struct ArcNode *w;
    for (w = G->vertices[i].firstarc; w; w = w->nextarc)
    {
        if (visited[w->adjvex] == 0)
            DFS(G, w->adjvex);
    }
}

//6-19 图的广度遍历-邻接矩阵实现
void BFS(MGraph G,Vertex i)
{
  int q[MaxVertexNum],front=0,rear=0;
  printf(" %d",i);
  visited[i]=1;
  q[rear++]=i;
  while(front!=rear)
  {
    int now=q[front++];
    for(i=0;i<G.vexnum;i++)
    {
      if(G.arcs[now][i]==1&&visited[i]==0)
      {
        printf(" %d",i);
        visited[i]=1;
        q[rear++]=i;
      }
    }
  }
}

//6-20 邻接表存储图的广度优先遍历
void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) ){
	Visit(S);
	Visited[S] = true;
	Vertex queue[105];
	int front = 0,rear = 0;
	queue[rear++] = S; 
	PtrToAdjVNode p;
	while(front<rear){
		Vertex x = queue[front];
		front++;
		p = Graph->G[x].FirstEdge;
		while(p){
			Vertex v = p->AdjV;
			if(!Visited[v]){
				Visit(v);
				Visited[v] = true;
				queue[rear++] = v;
			}
			p = p->Next;
		} 
	}
}

编程题

//7-1 字符串的冒泡排序
#include <stdio.h>
#include <string.h>
void BubbleSort_For_Strings(char(*Array)[20],int Line,int Times) 
{
    int i,j;
    for(i=0;i<Times;i++)
    {
        for(j=0;j<Line-i-1;j++)
        {
            if(strcmp(Array+j,Array+j+1)>0)
            {
                char temp[20];
                strcpy(temp,Array+j);
                strcpy(Array+j,Array+j+1);
                strcpy(Array+j+1,temp);
            }
        }
    }
}

int main()
{
    int N,K,i=0,j=0;
    char a[100][20]={0};
    scanf("%d %d",&N,&K);
    getchar();  
    for(i=0;i<N;i++)
    {
        j=-1;
        do
        {
            j++;
            scanf("%c",&a[i][j]);
        }while(a[i][j]!='\n');
    }
    BubbleSort_For_Strings(a,N,K);
    for(i=0;i<N;i++)
    {
        j=-1;
        do
        {
            j++;
            printf("%c",a[i][j]);
        }while(a[i][j]!='\n');
    }
    return 0;
}

//7-2 两个有序链表序列的交集
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
	int data;
	struct node *next;
}node;
struct node *createList();
int main()
{
	node *L1 = createList();
	node *L2 = createList();
	int cnt = 0,num = 0;
	node *p1 = L1;
	node *p2 = L2; 
	while(p1!=NULL&&p2!=NULL)
	{
		if(p1->data<p2->data)
		{
			p1 = p1->next;
		}
		else if(p1->data == p2->data)
		{
			num++;		
			if(cnt == 0) 
			{
				cnt = 1;
				printf("%d",p1->data);
			}
			else
			{
				printf(" %d",p1->data);
			}
			p1 = p1->next;
			p2 = p2->next;
		}
		else
		{
			p2 = p2->next;
		}
	}
	if(num==0)
		printf("NULL");	
	return 0;
}
struct node *createList()
{
	node *head = NULL;
	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	node *p = head;
	int x;
	scanf("%d",&x);
	while(x!= -1)
	{
		node *q =NULL;
		q = (node*)malloc(sizeof(node));
		q->data = x;
		p->next = q;
		p = q;
		q->next = NULL;
		scanf("%d",&x);
	}
	return head->next;
}

//7-3 括号匹配
#include <iostream>
#include<stack>
#include<string>
using namespace std;
bool check(string s);
int main()
{
	string s;
	while(getline(cin,s)){
		cout<<(check(s)? "yes" : "no")<<endl;	
	}
	return 0;
}
bool check(string s){
	stack<char> st;
	for(int i=0;i<s.size();i++){
		char c=s[i];
		if(c=='('||c=='['||c=='{'){
			st.push(c);
		} 
		else if(c==')'||c==']'||c=='}'){
			if(st.empty()){
				return false;
			}
			char x=st.top();
			st.pop(); 
			if(c==')'&&x!='('||
			c==']'&&x!='['||
			c=='}'&&x!='{') {
				return false;
			}
		}
	}
	return st.empty();
}

//7-4 表达式求值
#include <cctype>
#include <iostream>
#include <stack>
#include <string>
using namespace std;
int main() {
    string st;
    while (cin >> st) {
        stack<string> s;
        stack<string> ope;
        string temp;
        for (char ct : st) {
            if (isdigit(ct)) {
                temp = ct;
                s.push(temp);
            }
            else {
                double left, right, res;
                switch (ct) {
                    case '+':
                        right = stod(s.top());
                        s.pop();
                        left = stod(s.top());
                        s.pop();
                        res = left + right;
                        temp = to_string(res);
                        s.push(temp);
                        break;
                    case '-':
                        right = stod(s.top());
                        s.pop();
                        left = stod(s.top());
                        s.pop();
                        res = left - right;
                        temp = to_string(res);
                        s.push(temp);
                        break;
                    case '*':
                        right = stod(s.top());
                        s.pop();
                        left = stod(s.top());
                        s.pop();
                        res = left * right;
                        temp = to_string(res);
                        s.push(temp);
                        break;
                    case '/':
                        right = stod(s.top());
                        s.pop();
                        left = stod(s.top());
                        s.pop();
                        res = left / right;
                        temp = to_string(res);
                        s.push(temp);
                        break;
                }
            }
        }
        double out = stod(s.top());
        printf("%.2lf\n", out);
    }
    return 0;
}

//7-5 队的基本操作
#include<stdio.h>
#include<stdlib.h>
struct Queue{
    int data;
    struct Queue* next;
}*queue;

struct Queue *createQueue(); 
void push(int num);        
void pop();             
int main()
{
    queue = createQueue();
    int N,num;
    scanf("%d",&N);
    for(int z=0;z<N;z++){
        scanf("%d",&num);
        if(num==0) pop();
        else push(num);
    }
    putchar('\n');
    while (queue->data!=0){
        printf("%d ",queue->data);
        queue->data = 0;
        queue = queue->next;
    }
    return 0;
}
struct Queue *createQueue()
{
    struct Queue *head,*body;
    head = (struct Queue *) malloc(sizeof(struct Queue));
    head->data = 0; 
    body = head;
    for(int z=1;z<10;z++){
        body->next = (struct Queue *) malloc(sizeof(struct Queue));
        body = body->next;
        body->data = 0;
    }
    body->next = head;
    return head;
}
void push(int num)
{
    struct Queue *head = queue;
    for(int z=0;z<9;z++){
        if(head->data==0){
            head->data = num;
            return;
        }
        head = head->next;
    }
    printf("FULL ");
}
void pop()
{
    if(queue->data==0) printf("EMPTY ");
    else
    {
        printf("%d ",queue->data);
        queue->data = 0;
        queue = queue->next;
    }
}

//7-6 银行业务队列简单模拟
#include<bits/stdc++.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef long long ll;
struct LinkQueue{
    int *base;
    int front,last;
};
void InitQueue(LinkQueue& q){
    q.base = (int*)malloc(1007*sizeof(int));
    q.front = q.last = 0;
}
void push(LinkQueue&q,int e){
    q.base[q.last++] = e;
}
void pop(LinkQueue&q){
    q.front++;
}
int GetTop(LinkQueue&q){
    return q.base[q.front];
}
int EmptyQueue(LinkQueue&q){
    if(q.front==q.last) return true;
    return false;
}
int main()
{
    //freopen("i.txt","r",stdin);
    int n;
    LinkQueue q1,q2;
    scanf("%d",&n);
    InitQueue(q1);InitQueue(q2);
    for(int i=1;i<=n;i++){
        int e;
        scanf("%d",&e);
        if(e&1){
            push(q1,e);
        }else push(q2,e);
    }
    int i=0;
    while(!EmptyQueue(q1)||!EmptyQueue(q2)){
        if(!EmptyQueue(q1)){
            if(i++) printf(" ");
            cout<<GetTop(q1);
            pop(q1);
        }
        if(!EmptyQueue(q1)){
            if(i++) printf(" ");
            cout<<GetTop(q1);
            pop(q1);
        }
        if(!EmptyQueue(q2)){
            if(i++) printf(" ");
            cout<<GetTop(q2);
            pop(q2);
        }
    }
}

//7-7 h0181. 约瑟夫问题
#include<iostream>
using namespace std;
const int MAX = 305;
int main() {
	int n, m;
	while (cin >> n >> m) {
		if (n == 0 && m == 0) break;
		int arr[MAX] = { 0 };
		for (int i = 1; i <= n; i++) arr[i] = 1;
		int sum = n, cur = 1, count = 0;
		while (sum > 1) {
			if (arr[cur] == 1) {
				count++;
				if (count == m) {
					arr[cur] = 0;
					count = 0;
					sum--;
				}
			}
			cur++;
			cur = (cur == n + 1) ? 1 : cur;
		}
		for (int i = 1; i <= n; i++) {
			if (arr[i] == 1) {
				printf("%d\n", i);
				break;
			}
		}
	}
	return 0;
}

//7-8 列出叶结点
#include <stdio.h>
#include <stdlib.h>
typedef struct TNode *Tree;
struct TNode
{
    int data;
    struct TNode *Left;
    struct TNode *Right;
};
int flag[10]; 
struct Node
{
    int left, right;
}num[10];

Tree Build(int node)
{
    Tree t = (Tree) malloc(sizeof(struct TNode));
    t->data = node;
    t->Left = t->Right = NULL;
    if(num[node].left != 100) t->Left = Build(num[node].left);
    if(num[node].right != 100) t->Right = Build(num[node].right);
    return t;
}

void Print(Tree T)
{
    if(T == NULL) return;
    Tree queue[10];
    int left=0, right=0;
    queue[right++] = T;
    int cnt = 0; 
    while (left < right)
    {
        Tree t = queue[left++];
        if(t->Left==NULL && t->Right==NULL) {
            if(cnt == 0) printf("%d", t->data);
            else printf(" %d", t->data);
            cnt++;
        }
        if (t->Left) queue[right++] = t->Left;
        if (t->Right) queue[right++] = t->Right;
    }
}

int main()
{
    int n;
    scanf("%d", &n);
    getchar();
    for(int i=0; i<n; i++)
    {
        char x, y;
        scanf("%c %c",&x, &y);
        getchar();
        if(x == '-') num[i].left = 100;
        else
        {
            num[i].left = x - '0';
            flag[x - '0'] = 1;
        }

        if(y == '-') num[i].right = 100;
        else
        {
            num[i].right = y - '0';
            flag[y - '0'] = 1;
        }
    }
    int node;
    for(int i=0; i<n; i++)
    {
        if(flag[i] == 0) node = i;
    }
    Tree t = Build(node);
    Print(t);
    return 0;
}

//7-9 还原二叉树
#include<iostream>
using namespace std;
typedef struct BiTNode{
	char c;
	struct BiTNode *lchild;
	struct BiTNode *rchild;
}BiTNode,*BiTree;
BiTree Build(char *pre,char *in,int n){
	if(n <= 0)
		return NULL;
	BiTree T = new BiTNode;
	T->c = *pre; 
	char *p = in;
	while(p){
		if(*p == *pre)
			break;
		p++;
	}
	int len = p - in; 
	T->lchild = Build(pre + 1,in,len);
	T->rchild = Build(pre + 1 + len,p+1,n - len - 1);
	return T;
}
int Hight(BiTree T){
	if(!T)
		return 0;
	int m = Hight(T->lchild);
	int n = Hight(T->rchild);
	if(m > n)
		return ++m;
	else
		return ++n;
}
int main(){
	int n,h;
	char pre[51],in[51];
	BiTree T;
	scanf("%d%s%s",&n,&pre,&in);
	T = Build(pre,in,n);
	h = Hight(T);
	printf("%d\n",h);
	return 0;
}

//7-10 插入排序
#include<stdio.h>
int main()
{
    int n;
   scanf("%d",&n);
    int a[n];
    for(int i=0;i<n;i++)
    {
       scanf("%d",&a[i]);
    }
    for(int i=1;i<n;i++)
    {
        int min=a[i];
        int j=i-1;
        for(j=i-1;j>=0;j--)
        {
            if(min<a[j])
            {
                a[j+1]=a[j];
            }
            else
            {
                break;
            }
        }
        a[j+1]=min;
        for(int k=0;k<n;k++)
            {
                printf("%d",a[k]);
                if(k<n-1)
                {
                   printf(" ");
                }
            }
        if(i<n-1)
        {
            printf("\n");
        }
    }
    return 0;
}
Nexuszzz
关注
数据结构期末复习
weixin_52277317的博客
01-01 1981
zzulier的数据结构期末复习 数据结构期末复习**zzulier的数据结构期末复习**第一章 绪论1.基本概念和术语2.算法和算法分析 第一章 绪论 1.基本概念和术语 （1）数据结构：是互相之间存在一种或多种特定关系的数据元素的集合。 （2）数据、数据元素、数据对象、数据项概念辨析： ①首次需要明确的是：数据>数据元素>数据项 （例：学生表>个人信息>某一信息） ②关系图：若将数据看做一个集合，那么有以下关系： （3）数据结构包含：逻辑结构&存储（物理）结构 逻辑结
Java数据结构期末题库
m0_66117547的博客
11-24 2412
目录试题1：快速排序​试题2：希尔排序试题3：折半查找试题4：堆排序试题5：哈夫曼树的实现试题6：二叉树的遍历试题7：图两点最短距离试题8：图的存储实现试题9：二叉排序树的查找试题10：括号匹配问题试题11：二叉树的中序遍历试题12：二叉树的先序遍历试题13：二叉树的分层遍历试题14：二叉树的后序遍历快速排序的核心操作是划分，通过某个数据将原来排序表分成两部分，前面部分比该数小，后面数据比该数据大或相等，该位置就为某数据排序后的位置，即该数据完成排序。如果定义一个排序表的划分方法为： int p
数据结构 期末复习
weixin_62438655的博客
12-01 1398
复习数据结构
数据结构期末总结
chaotiantian的博客
06-24 1296
施加在数据上的运算包括运算的定义和实现。运算的定义是针对逻辑结构的，运算的实现是针对存储结构的。根据数据元素之间关系的不同特性，分为集合、线性结构、树状结构、图状或网状结构。在物理结构表示数据结构中，住哟啊研究数据元素的存储和关系存储，别称为。：是数据结构在计算机中的表示和实现，又称“：对于任意一个关系，可分为。：是对元素之间的逻辑关系。：数据的存储结构又称为。
数据结构期末考试【含答案】
热门推荐
是小雷同学的博客
06-24 2万+
一、单选题（共30题）1.含n个叶结点的哈夫曼树，其总结点个数为（ B ）。 A.2n B.2n-1 C.n+2 D.2n+22.空格串是指（ A ）。 A.一个或多个空格组成的串 B.长度为0的串 C.用“φ”表示的串 D.零个字符的串3.下面二叉树中一定是完全二叉树的是（ B ）。 A.哈夫曼树 B.满二叉树 C.单枝二叉树 D.二叉排序树4.一棵有27结点的完全二叉树，对它按层编号，则对编号为8的结点X，它的双亲结点及右孩子结点的编号分别为（　C　　）。 A.4，14 B.2，15 C.4，
数据结构期末复习总结
weixin_51252109的博客
12-07 3705
数据结构期末复习总结一：绪论1.数据的逻辑结构2.数据的物理结构3.算法的基本概念二：线性表 一：绪论 1.数据的逻辑结构 逻辑结构包括：线性结构、非线性结构 线性结构： 集合中存在唯一一个“第一个元素” 集合中存在唯一一个“最后一个元素” 除最后一个元素之外，其他数据元素均有唯一的“后继” 除第一个元素之外，其他数据元素均有唯一的“前驱” 非线性结构：包括树形结构、图形结构 一对多 2.数据的物理结构 物理结构包括： 顺序存储方法、链式存储方法、索引存储方法、散列存储方法 3.
数据结构期末考试题库
m0_70508178的博客
06-03 1万+
填空题： 1. 将时间复杂度数量级O(n2)、O(nlog2n)、O(2n)、O(1)、O(log2n)和O(n)按由小到大进行排序，结果为：__O(1)，_O(log2n)，_O(n)_，O(nlog2n)，O(n2)，O(2n)___。 2. 数据的逻辑结构可分为_____线性结构___和_____非线性结构___。 3. 用S表示入栈操作，X表示出栈操作，若元素入栈的顺序为1234，为了得到1342出栈顺序，相应的S和X的操作串为______SXSSXSXX__。 4. 设单链表的结点结...
数据结构期末复习速成
传播是知识存在的意义
01-06 6299
数据结构期末复习速成，没有很详细的知识点，只是对照常考的题目提醒，把关键的一些基础题目设计到的知识点重新梳理了一遍，静下心把这些都快速的过一遍，相信你能收获不少，每天复习一点就会持续更新一点！期末不挂科！ 数据和数据结构 定义 数据 数据元素：数据的基本组织单位 数据项：数据元素的组成部分 数据对象：具有相同性质的数据元素的集合 数据的结构分为数据逻辑结构和数据存储结构 数据逻辑结构 4种基本数据逻辑结构类型： 集合 线性结构 数据元素之间是一对一关系 树形结构 数据元素之间是一对多关系 图
数据结构期末速成
m0_58381606的博客
07-21 873
设度为0的节点有N0个，度为k的节点有Nk个，则对严格的k叉树有 N0 = (k-1)Nk+1 ，由此得。在一颗二叉树中，如果某个节点的左指针为NULL，就说明这个节点在原来的森林中没有孩子，是叶子节点。使用DFS算法递归的遍历一个有环无向图，在退出递归时输出相应顶点，这样得到的顶点序列是。二叉排序树的查找性能和数据的输入顺序有关，最坏情况形成单支树，查找长度为O(n)与直接插入排序相比，折半插入排序减少了比较元素的次数，元素的移动次数并未改变。将森林F转换为对应的二叉树T，F中叶节点的个数等于。
数据结构期末大题速成
狗蛋的博客
11-24 2737
二叉树遍历 DLR–前序遍历（根在前，从左往右，一棵树的根永远在左子树前面，左子树又永远在右子树前面 ） LDR–中序遍历（根在中，从左往右，一棵树的左子树永远在根前面，根永远在右子树前面） LRD–后序遍历（根在后，从左往右，一棵树的左子树永远在右子树前面，右子树永远在根前面） 先序遍历 中序遍历 后序遍历 深搜广搜 BFS：这是一种基于队列这种数据结构的搜索方式，它的特点是由每一个状态可以扩展出许多状态，然后再以此扩展，直到找到目标状态或者队列中头尾指针相遇，即队列中所有状态都已处理完毕。 D
北京邮电大学历年数据结构期末试题
12-06
本资源集合包含了北京邮电大学历年来的数据结构期末试题，对于正在学习或准备相关考试的学生来说，这是一个宝贵的参考资料。 数据结构的学习涵盖了线性结构、树形结构、图结构、文件结构等多种类型。线性结构如数组...
中国海洋大学数据结构期末试题A卷
04-03
在中国海洋大学数据结构期末试题A卷中，可能会涵盖以上所有知识点。例如，试题可能要求分析不同数据结构的时间复杂度和空间复杂度，设计并实现特定的排序或查找算法，或者解决与树和图相关的实际问题。此外，试题还...
试题.试卷—--数据结构期末考试试题.doc
06-29
数据结构期末考试试题 数据结构是一门重要的计算机科学课程，对于计算机科学和技术专业的学生来说，它是必修的基础课。数据结构期末考试试题涵盖了数据结构的基本概念、数据结构种类、算法设计和分析、图论、树论、...
西南交大-计算机-超级全面-数据结构期末复习资料.zip
11-18
西南交通大学的这份"超级全面"数据结构期末复习资料包含了丰富的学习资源，旨在帮助学生充分理解和掌握这一领域的关键概念。 文档“算法！.docx”和“算法！.pdf”很可能包含了各种数据结构相关的经典算法详解，如...
数据结构期末考试习题汇总
03-24
数据结构期末考试习题汇总 数据结构是计算机科学中研究非数值计算问题的重要领域，涉及到数据的存储、处理和表示。以下是数据结构期末考试习题汇总的知识点总结： 1. 数据结构的主要研究对象是非数值计算问题，...
Python 数据结构和算法面试题，使用 Jupyter Notebook 编写
hallo128的博客
10-16 404
【代码】Python 数据结构和算法面试题，使用 Jupyter Notebook 编写。
浙大数据结构全题解汇总（C++实现）
最新发布
qq_74924951的博客
10-16 585
浙大数据结构题解汇总
数据结构常考基础代码题-顺序表有序插入
qq_52291558的博客
10-16 322
根据题目中的“顺序表递增有序”，我们需要定义一个顺序表结构体，用于存储元素和顺序表的相关信息。
数据结构——八大排序（下）
2301_78566776的博客
10-16 299
数据结构中的八大排序算法是计算机科学领域经典的排序方法，它们各自具有不同的特点和适用场景。
数据结构期末模拟试题与解答
"数据结构期末考试模拟题，包含线性表相关的Java实现" 在数据结构课程中，期末考试通常会涵盖各种数据结构的基本概念、实现和操作。此模拟题主要针对线性表这一核心概念进行考察，特别是Java语言中的实现。以下是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值