大话数据结构

 

 

 

第一章 数据结构绪论

 

1.1 开场白

废话

 

1.2 数据结构怎么学

废话

 

1.3 数据结构起源

高德纳 程序设计=数据结构+算法

 

1.4 基本概念和术语

数据：描述客观事物的符号，计算机中可操作的对象，能被计算机识别，并输入给计算机处理的符号集合

数据元素：组成数据的、有一定意义的基本单位，也被成为记录，例：人类的数据元素是人，畜类的数据元素是牛、马、羊

数据项：一个数据元素可以又若干数据项组成，例：人类的数据元素是人，人的数据元素可以由眼、耳、鼻这些数据项组成，数据项是数据不可分割的最小单位

数据对象：性质相同（数据元素具有相同数量和类型）数据元素的集合，是数据的子集

数据结构：相互之间存在一种或多种特定关系的数据元素的集合（结构简单的理解就是关系，“数据结构”就是数据与数据之间的关系）

 

1.5 逻辑结构与物理结构

 

逻辑结构：数据元素之间的相互关系

1、集合结构：集合结构中的数据元素除了同属一个集合外，它们之间没有其它关系

2、线性结构：线性结构中的数据元素是一对一的关系

3、树形结构：树形结构中的数据元素存在一种一对多的层次关系

4、图形结构：图形结构中的数据元素是多对多关系

 

物理结构（存储结构）：数据的逻辑结构在计算机中的存储形式

1、顺序存储结构：数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系一致

2、链式存储结构：数据元素存在任意的存储单元里，这组存储单元可以是连续的，也可以是不连续的，数据元素的存储关系不能反映其逻辑关系

1.6 抽象数据类型

 

数据类型：一组性质相同的值的集合及定义在此集合上的一些操作总称，例：int a,b;a,b赋值时不能超过int的取值范围

抽象：指抽取出事物具有的普遍性的本质，抽取出问题的特征而忽略本质的细节

抽象数据类型（Abstract Data Type,ADT）：一个数学模型及定义在该模型上的一组操作（面向对象中的类）

 

1.7 总结回顾

 

 

 

第二章 算法

 

2.1 开场白 

废话 

 

2.2 数据结构与算法关系

梁山伯与祝英台、罗密欧与朱丽叶的关系

 

2.3 两种算法的比较

求1+2+3+...+100，第一种方式使用循环

    int i,sum=0,n=100;
    for(i=1; i<=n; i++)
    {
        sum = sum+i;
    }
    printf("%d",sum);

 第二种采用公式n=n*(n+1)/2，这种方式避免了循环，哪怕累加到一千、一万、一亿的累加

 

    int n=100,sum;
    sum = n*(n+1)/2;
    printf("%d",sum);

 

2.4 算法定义

描述解决问题的方法，解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个火多个操作

 

2.5 算法的特性

1、输入/输出：算法具有零个或多个输入，至少有一个或多个输出

2、有穷性：算法在执行有限的步骤之后，自动结束而不会无限循环，并且每一个步骤在可以接收的时间内完成

3、确定性：算法的每一步骤都具有确定的含义，不会出现二义性，相同的输入只能有唯一的输出结果

4、可行性：算法每一步都必须是可行的，每一步都能够通过执行有限次数完成，可行性意味着算法可以转换为程序上机运行，并得到正确的结果

 

2.6 算法设计要求

1、正确性：算法应该具有输入、输出和加工处理武无歧义行、能正确反映问题的需求、能狗得到问题的正确答案

正确性四个层次：

1.算法程序没有语法错误

2.算法程序对合法的输入数据能够产生满足要求的输出结果

3.算法程序对非法输入数据能够得出满足规格说明的结果

4.算法程序对于精心选择的，甚至刁难的测试数据都有满足要求的输出结果

2、可读性：算法设计的另一个目的是为了便于阅读、理解和交流

3、健壮性：当如入数据不合法时，算法也能做出相关处理，而不是产生异常或莫名奇妙的错误

4、时间效率高和存储量低：用时少，占用内存低

 

2.7 算法效率的度量方法

1、事后统计方法：通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序的运行时间进行比较，从前而确定算法效率的高低，事后统计方法有缺陷，不采纳

2、事前分析估算方法：测定运行时间最可靠的方法就是计算对运行时间有消耗的基本操作的执行次数，运行时间与这个计数成正比

 在分析算法运行时间时，把基本操作的数量与输入规模关联起来

 

2.8 函数的渐近增长

函数的渐近增长：给定两个函数f(n)和g(n)，如果存在一个整数N，是的对于所有的n>N，f(n)总是比g(n)大，那么说f(n)的增长渐近大于g(n)

 

 2.9 算法时间复杂度

 

 

 

第三章 线性表 

3.1 开场白

 

3.2 线性表定义

线性表（List）：零个或多个数据元素的有限序列

第一个元素无先驱，最后一个元素无后继，其它元素有且只有一个前驱和后继

线性表元素个数n(>=0)定义为线性表的长度，当n=0时，线性表为空表

3.3 线性表的抽象数据类型

 

3.4 线性表的顺序存储结构

顺序存储：用一段地址连续的存储单元依次存储线性表的数据元素

3.5 顺序存储结构的插入与删除

获取元素操作：

/**
	 * 返回pos下标位置的值
	 * 
	 * @param array
	 * @param pos
	 * @return
	 */
	public String getPos(String[] array, Integer pos) {
		if (array.length == 0 || pos < 0 || pos >= array.length) {
			return null;
		}
		return array[pos];
	}

插入操作：

/**
	 * 在pos位置插入value，pos后数据后移
	 * 
	 * @param array
	 * @param pos
	 * @param value
	 * @return
	 */
	public String insert(String[] array, Integer pos, String value) {
		if (pos < 1 || pos >= array.length) {
			return ERROR;
		}
		// 插入的位置不在最后
		if (pos != array.length - 1) {
			for (int end = array.length - 1; end > pos; end--) {
				array[end] = array[end - 1];
			}
		}
		// 插入操作
		array[pos] = value;
		return SUCCESS;
	}

 删除操作：

/**
	 * 删除pos位置数据，pos后数据前移
	 * 
	 * @param array
	 * @param pos
	 * @return
	 */
	public String delete(String[] array, Integer pos) {
		if (pos < 0 || pos >= array.length)
			return ERROR;
		// 删除的位置不在最后
		if (pos != array.length - 1) {
			for (int i = pos; i < array.length - 1; i++) {
				array[i] = array[i + 1];
			}
		}
		// 清空尾部数据
		array[array.length - 1] = null;
		return SUCCESS;
	}

线性表顺序存储结构的优缺点

 

3.6 线性表的链式存储结构

线性表顺序存储结构最大的缺点是插入和删除数据时需要移动大量元素，耗费时间。

链表把一个“结点”分为数据部分和指针部分（指向下一个结点的指针）

 

 

 

 

冒泡，程序

	@Test
	public void test() {
		int[] array = new int[] { 2, 1, 3, 4, 5, 6, 7, 8, 9 };
		print(array);
		bubble3(array);
		// print(array);

	}

	/**
	 * 对bubble2进行优化<br>
	 * 当数组为[ 2, 1, 3, 4, 5, 6, 7, 8, 9]<br>
	 * i=0，内循环[0]和[1]互换后就不需要在比较<br>
	 * 通过在外循环的判断上设置标志位<br>
	 * 
	 * @param array
	 */
	public void bubble3(int[] array) {
		boolean flag = true;
		for (int i = 0; i < array.length && flag; i++) {
			flag = false;
			for (int j = 0; j < array.length - 1; j++) {
				if (array[j] > array[j + 1]) {
					swap(array, j, j + 1);
					flag = true;// 有数据交换
				}
				print(array);
			}
		}
	}

	/**
	 * 相邻的两个元素比较 内循环：j=0时，相邻比较，内循环一次的完整位置转换<br>
	 * [9, 8, 7, 6, 5, 4, 3, 2, 1]<br>
	 * [8, 9, 7, 6, 5, 4, 3, 2, 1]<br>
	 * [8, 7, 9, 6, 5, 4, 3, 2, 1]<br>
	 * [8, 7, 6, 9, 5, 4, 3, 2, 1]<br>
	 * [8, 7, 6, 5, 9, 4, 3, 2, 1]<br>
	 * [8, 7, 6, 5, 4, 9, 3, 2, 1]<br>
	 * [8, 7, 6, 5, 4, 3, 9, 2, 1]<br>
	 * [8, 7, 6, 5, 4, 3, 2, 9, 1]<br>
	 * [8, 7, 6, 5, 4, 3, 2, 1, 9]<br>
	 * 
	 * @param array
	 */
	public void bubble2(int[] array) {
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array.length - 1; j++) {
				if (array[j] > array[j + 1]) {
					swap(array, j, j + 1);
				}
				print(array);
			}
		}
	}

	/**
	 * 不满足两两比较，最简单的交换
	 * 
	 * @param array
	 */
	public void bubble1(int[] array) {
		for (int i = 0; i < array.length; i++) {
			for (int j = i + 1; j < array.length; j++) {
				if (array[i] > array[j]) {
					swap(array, i, j);
				}
			}
		}
	}

	public void swap(int[] array, int pos1, int pos2) {
		int temp = array[pos1];
		array[pos1] = array[pos2];
		array[pos2] = temp;
	}

	public void print(int[] array) {
		System.out.println(Arrays.toString(array));
	}

 选择：

@Test
	public void test() {
		int[] array = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		print(array);
		selectSort1(array);
		print(array);

	}

	/**
	 * 最简单的选择排序，在内循环中选出最小的<br>
	 * [9, 8, 7, 6, 5, 4, 3, 2, 1]<br>
	 * [1, 8, 7, 6, 5, 4, 3, 2, 9]<br>
	 * [1, 2, 7, 6, 5, 4, 3, 8, 9]<br>
	 * [1, 2, 3, 6, 5, 4, 7, 8, 9]<br>
	 * [1, 2, 3, 4, 5, 6, 7, 8, 9]<br>
	 * [1, 2, 3, 4, 5, 6, 7, 8, 9]<br>
	 * 
	 * @param array
	 */
	public void selectSort1(int[] array) {
		int j = 0, minPos = 0;
		for (int i = 0; i < array.length; i++) {
			minPos = i;
			for (j = i + 1; j < array.length; j++) {
				if (array[minPos] > array[j]) {
					minPos = j;
				}
			}
			if (minPos != i) {
				swap(array, minPos, i);
				print(array);
			}
		}
	}

	public void swap(int[] array, int pos1, int pos2) {
		int temp = array[pos1];
		array[pos1] = array[pos2];
		array[pos2] = temp;
	}

	public void print(int[] array) {
		System.out.println(Arrays.toString(array));
	}