数据结构学习笔记（三）-CSDN博客

本文链接：https://blog.csdn.net/passer_by_hq/article/details/51839171

数据结构学习笔记（三）

链表

链表也是一种数据结构，它用来实现对链式物理结构的管理使用链表可以把链式物理结构的管理代码和使用代码分隔开

链表包含的功能包括，插入，删除，查找和遍历

二叉树

如果单向线性链式物理结构中每个节点有可能找到多个其他节点则它就变成树

树里的所有节点可以分成几层，不同层之间符合线性规律(任意两层之间有前后顺序)

树的最上面一层只有一个节点，这个节点叫做根节点

根节点可以代表整棵树

树里不同节点之间的直接关系叫做父子关系

其中接近根节点的叫父节点，另外一个节点叫子节点

树里任何一个节点最多只能有一个父节点(根节点没有父节点)

如果树里任何节点最多只能有两个节点，这种树叫二叉树

二叉树是最简单的树，我们用左右区分二叉树里某个节点的两个子节点

树里任何节点都可以当作根节点看待，它可以代表它下面所有节点构成的树

二叉树里任何节点都可以当作一个新的二叉树来看待

一个节点的左子节点作为根节点构成的树叫做这个节点的左子树

任何一棵树可以分成三部分看待：根节点，根节点的左子树，根节点的右子树

所有树都可以转换成二叉树

依次处理树中每个节点的操作叫树的遍历，树的绝大多数操作都是通过遍历实现的

树的遍历通常采用递归方式实现的

遍历树的时候永远先遍历左子树而后遍历右子树

前序遍历：根节点——>左子树——>右子树

中序遍历：左子树——>根节点——>右子树

后序遍历：左子树——>右子树——>根节点

算法

解决常见问题的方法

同一个问题可能有多种解决方法，不同方法适合用在不同的地方

排序

冒泡排序算法

//冒泡排序基本算法

8 for(l=size-1; l>0; l--)

9 {

10 for(h = 0; h < l; h++)

11 {

12 if( *(p_arr+h) > *(p_arr+h+1) )

13 {

14 *(p_arr+h) ^= *(p_arr+h+1);

15 *(p_arr+h+1) ^= *(p_arr+h);

16 *(p_arr+h) ^= *(p_arr+h+1);

17 }

18 }

19 }

// 冒泡排序算法改进

25 void bubble_sort(int * p_arr, int num )

26{

27 int low = 0;

28 int high = num-1;

29 int l = 0;

30 int h = 0;

32 while(low < high)

33 {

34 for( l = low; l<high; l++)

35 {

36 if(*(p_arr+l) > *(p_arr+l+1))

37 {

38 *(p_arr+l) ^= *(p_arr+l+1);

39 *(p_arr+l+1) ^= *(p_arr+l);

40 *(p_arr+l) ^= *(p_arr+l+1);

41 }

42 }

44 low++;

46 for( h = high; h>low; h--)

47 {

48 if( *(p_arr+h-1) > *(p_arr+h) )

49 {

50 *(p_arr+h-1) ^= *(p_arr+h);

51 *(p_arr+h) ^= *(p_arr+h-1);

52 *(p_arr+h-1) ^= *(p_arr+h);

53 }

55 }

57 high--;

59 }

61}

选择排序算法

67 for(low = 0; low < size-1; low++)

68 {

69 for( high=low+1; high < size;high++)

70 {

71 if( *(p_arr+low) <*(p_arr+high))

72 {

73 *(p_arr+low) ^= *(p_arr+high);

74 *(p_arr+high) ^= *(p_arr+low);

75 *(p_arr+low) ^= *(p_arr+high);

76 }

77 }

78 }

插入排序算法

3 int * insert_sort(int * p_num, int size)

4 {

5 int num = 0;

6 int num1 = 0;

7 for( num=1; num<=size-1; num++ )

8 {

9 for(num1= num-1; num1>=0; num1--)

10 {

11 if( *(p_num+num1) >*(p_num+num1+1) )

12 {

13 *(p_num+num1) ^=*(p_num+num1+1);

14 *(p_num+num1+1) ^=*(p_num+num1);

15 *(p_num+num1) ^=*(p_num+num1+1);

16 }

17 else

18 break;

19 }

20 }

22 return p_num;

23 }

快速排序算法

4 int * quick_sort(int * p_num, int size)

5 {

7 int base = *p_num;

9 int * p_start = p_num;

10 int * p_end = p_num+size-1;

12 if( size <= 1)

13 {

14 return p_num;

15 }

17 while( p_start < p_end )

18 {

19 if( *p_start > *p_end )

20 {

21 *p_start ^= *p_end;

22 *p_end ^= *p_start;

23 *p_start ^= *p_end;

24 }

26 if(*p_start == base )

27 {

28 p_end--;

29 }

30 else

31 p_start++;

33 }

35 quick_sort(p_num,p_start - p_num);

36 quick_sort(p_start+1, size-(p_end-p_num)-1);

38 return p_num;

39 }

查找

顺序查找 —— 无序数据

折半查找 —— 有序数据

3 int * half_search(int *p_start, int* p_end, int num )

4 {

5 int mid = (p_end-p_start+1) / 2;

7 if( p_start > p_end )

8 {

9 return NULL;

10 }

12 if( *(p_start+mid) == num )

13 {

14 return p_start+mid;

15 }

16 else if( *(p_start+mid) > num )

17 {

18 return ( half_search(p_start,p_start+mid-1, num) );

19 }

20 else

21 return ( half_search(p_start+mid+1,p_end, num) );

23 }

3 int *half_search( int * p_start, int *p_end)

4 {

5 int * p_head = p_start;

6 int * p_tail = p_end;

7 int * p_tmp = NULL;

9 while(p_head <= p_tail)

10 {

11 p_tmp = p_head + (p_tail - p_head+1)/2;

13 if(*p_tmp == num)

14 return p_tmp;

15 else if( *p_tmp > num )

16 {

17 p_tail = p_tmp -1;

18 }

19 else

20 p_head = p_tmp +1;

21 }

23 return NULL;

24 }

数据结构学习笔记（完）