数据结构期中考试复习序章

1.数据是指所有能够被输入到计算机并且能被计算机处理的符号的集合（数据结构主要讨论的是结构化数据）

2.数据的基本单位一般是指比特（bit）和字节（byte），比特是最小的单位，1byte=8bit

3.数据对象是一种抽象的表示方法，数据对象可以是一个单一的值，也可以是一个包含多个值的集合。举个例子，一个学生记录的数据对象，其中包括学号，姓名，成绩等等，这个数据对象可以表示为一个结构体或者类（C++）

4.数据结构是指带结构的数据元素的集合；即数据对象（相同性质的数据元素的集合）+结构（数据元素之间的关系构成结构）

5.二元组的概念，并不是特别好理解，百度吧

6.序偶<x,y>表示有向，序偶（x,y）表示无向。

对于有向无向的理解，简单记忆一下即可  （a,b）等价于（b,a）则表示无向。

x是y的前驱元素，y是x的后继元素（若为端点位置，开始元素或终端元素）

7.存放学生表的结构体数组定义如下：

struct Student {
	int id;				//学号
	char name[50];		//名字
	char sex[2];		//性别
	char classs[4];		//班级
};

顺序存储结构的特点：

        所有元素占用一整块内存空间。

        逻辑上相邻的元素，物理上也相邻。

8.存放学生表的链表的结点类型声明如下：

typedef struct Student {
	int id;				//学号
	char name[50];		//名字
	char sex[2];		//性别
	char classs[4];		//班级
	struct Student* next;
}Stu;

链式存储结构特点：

        一个逻辑元素用一个结点存储，每个结点单独分配，所有结点的地址不一定是连续的。

        用指针来表示逻辑关系。

9.数据分为4种不同的逻辑结构

        集合：

                元素之间无关系，较松散。

        线性结构：

                元素之间关系为一对一      如：    [1] -> [2] -> [3] -> [4] -> [5]

                开始和终端元素都是唯一的，其他元素有且仅有一个前驱元素和一个后继元素

        树形结构：

                元素之间关系为一对多 

                

                开始元素唯一，终端元素不唯一，除终端元素以外，每个元素有一个或多个后续元素，除开始元素外，每个元素有且仅有一个前                  驱元素。

        图形结构：

                元素之家关系为多对多

                

                所有元素都可能有多个前驱元素和多个后继元素

10.存储结构类型分为4钟：

        顺序存储结构        链式存储结构        索引存储结构        哈希（散列）结构

11.抽象数据类型

        

12.算法的五个重要特性：

        有穷性        确定性        可行性        有输入        有输出

13.C++引用

int a = 10;
int& b = a;
//a和b共享内存空间，同时发生变化

14.设计一个算法求解一元二次方程

#include<bits/stdc++.h>
using namespace std;

int solution(double a, double b, double c, double& x1, double& x2)
{
	double half_answer = b * b - 4*a*c;
	if (half_answer > 0) {
		x1 = (-b + sqrt(half_answer)) / (2 * a);
		x2 = (-b - sqrt(half_answer)) / (2 * a);
		return 2;
	}
	else if (half_answer == 0) {
		x1 = x2 = (-b) / (2 * a);
		return 1;
	}
	else
		return 0;
}
int main()
{
	double a, b, c, x1, x2;
	int flag = solution(1, 4, 2, x1, x2);
	printf("%d", flag);
	return 0;
}

15.算法复杂度比较关系如下（这里的对数底数都默认为2）：

O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n)<O(n!)

16.下列程序段的时间复杂度是   O（nlongn）

count = 0;
for (k = 1; k <= n; k *= 2)
	for (j = 1; j <= n; j++)
		count++;

以下算法的时间复杂度为  O（） 

void func(int n)
{
	int i = 0, s = 0;
	while (s < n)
	{
		i++;
		s = s + i;
	}
}

17.递归算法分析称为变长时空分析，非递归算法分析称为定长时空分析

18.

        

//设计集合的顺序存储结构类型如下：
typedef struct
{
	int data[MAX];
	int length;
}Set;

//利用Set类型的变量存储一个集合、

void createtest(Set& s, int a[], int n)//创建
{
	int i;
	for (i = 0; i < n; i++)
		s.data[i] = a[i];
	s.length = n;
}

void dispset(Set s)//输出一个集合
{
	int i;
	for (i = 0; i < s.length; i++)
		printf("%d", s.data[i]);
	printf("\n");
}

bool inset(Set s, int e)//判断e是否在集合s中
{
	int i;
	for (i = 0; i < s.length; i++)
		if (s.data[i] == e)
			return true;
	return false;
}

void add(Set s1, Set s2, Set& s3)//求并集
{
	for (int i = 0; i < s1.length; i++)
		s3.data[i] = s1.data[i];
	s3.length = s1.length;
	for(int i = 0;i<s2.length;i++)
		if (!inset(s1, s2.data[i]))
		{
			s3.data[s3.length] = s2.data[i];
			s3.length++;
		}
}

void sub(Set s1, Set s2, Set& s3)//求差集
{
	s3.length = 0;
	for (int i = 0; i < s1.length; i++)
		if (!inset(s2, s1.data[i]))
		{
			s3.data[s3.length] = s1.data[i];
			s3.length++;
		}
}

void intersection(Set s1, Set s2, Set& s3)//求交集
{
	s3.length = 0;
	for (int i = 0; i < s1.length; i++)
		if (inset(s2, s1.data[i]))
		{
			s3.data[s3.length] = s1.data[i];
			s3.length++;
		}
}

void main()
{
	Set s1, s2, s3, s4, s5;
	int a[] = { 1,2,3,4,5 };
	int b[] = { 2,3,4,5,6,7,8 };
	int n = 5, m = 7;
	createtest(s1, a, n);
	createtest(s2, b, m);
	printf("s1:"); dispset(s1);
	printf("s2:"); dispset(s2);


}