Python编程：数据结构与算法实战

需积分: 45 191 浏览量更新于2024-07-28 收藏 10.19MB PDF 举报

"Data Structures and Algorithms Using Python 是一本专注于使用Python语言讲解数据结构与算法的书籍，由Rance D. Necaise撰写，属于计算机科学领域，由John Wiley & Sons, Inc.出版。这本书覆盖了数据结构如数组、链表、栈、队列、树、图等，以及排序和搜索算法，如冒泡排序、快速排序、二分查找等，并深入探讨了这些概念在实际编程中的应用。" 在这本《Data Structures and Algorithms Using Python》中，作者详细介绍了数据结构的基础概念，如线性结构（如数组和链表）和非线性结构（如栈、队列、树和图）。线性结构是数据元素在逻辑上呈现连续顺序的一类数据结构，而数组是最基本的线性结构，它的特点是通过索引访问元素。链表则不依赖内存地址的连续性，通过节点间的指针连接，更灵活地处理动态变化的数据集合。栈是一种后进先出（LIFO）的数据结构，常用于函数调用和表达式求值。队列则是先进先出（FIFO）的数据结构，常见于任务调度和消息传递系统。树结构包括二叉树、平衡树（如AVL树和红黑树）等，用于高效地进行查找、插入和删除操作。图则广泛应用于网络、路由和社交网络分析等场景。书中也涵盖了各种算法，如排序算法（冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等）和搜索算法（线性搜索、二分查找、哈希表查找）。排序算法用于对数据进行排列，而搜索算法则帮助在数据中查找特定元素。例如，冒泡排序通过不断地交换相邻的逆序元素来逐步排序，而快速排序则是通过分治策略实现高效排序。此外，本书可能还讨论了递归、动态规划、贪心算法、回溯和分支限界等复杂算法思想。这些算法在解决实际问题，如最短路径、最小生成树、旅行商问题等经典问题时发挥着关键作用。书中还会涉及Python语言的特性，如列表推导、元组、字典等内置数据类型在实现数据结构时的应用，以及如何利用Python的高阶函数和面向对象编程来简化算法实现。同时，读者还能学习到如何分析算法的时间复杂度和空间复杂度，以便优化代码性能。总而言之，《Data Structures and Algorithms Using Python》是一本深入浅出的教材，适合计算机科学学生、程序员和任何希望提升自己Python编程技能，特别是对数据结构和算法理解的人士阅读。通过阅读此书，读者不仅可以掌握数据结构和算法的基本原理，还能学会如何在Python环境下高效地实现和运用它们。

xiv PREFACE

basics” approach to learning data structures and algorithms without overwhelming

the reader with all of the OOP terminology and concepts, which is especially

important when the instructor has no plans to cover such topics. Second, diﬀerent

instructors take diﬀerent approaches with Python in their ﬁrst course. Our aim is

to provide an excellent text to the widest possible audience. We do this by placing

the focus on the data structures and algorithms, while designing the examples to

allow the introduction of object-oriented programming if so desired.

The text also introduces the concept of algorithm analysis and explores the

eﬃciency of algorithms and data structures throughout the text. The major pre-

sentation of complexity analysis is contained in a single chapter, which allows it to

be omitted by instructors who do not normally cover such material in their data

structures course. Additional evaluations are provided throughout the text as new

algorithms and data structures are introduced, with the major details contained in

individual sections. When algorithm analysis is covered, examples of the various

complexity functions are introduced, including amortized cost. The latter is im-

portant when using Python since many of the list operations have a very eﬃcient

amortized cost.

Prerequisites

This book assumes that the student has completed the standard introduction to

programming and problem-solving course using the Python language. Since the

contents of the ﬁrst course can diﬀer from college to college and instructor to

instructor, we assume the students are familiar with or can do the following:



Design and implement complete programs in Python, including the use of

modules and namespaces



Apply the basic data types and constructs, including loops, selection state-

ments, and subprograms (functions)



Create and use the built-in list and dictionary structures



Design and implement basics classes, including the use of helper methods and

private attributes

Contents and Organization

The text is organized into fourteen chapters and four appendices. The basic con-

cepts related to abstract data types, data structures, and algorithms are presented

in the ﬁrst four chapters. Later chapters build on these earlier concepts to present

more advanced topics and introduce the student to additional abstract data types

and more advanced data structures. The book contains several topic threads that

run throughout the text, in which the topics are revisited in various chapters as

appropriate. The layout of the text does not force a rigid outline, but allows for the

PREFACE xv

reordering of some topics. For example, the chapters on recursion and hashing can

be presented at any time after the discussion of algorithm analysis in Chapter 4.

Chapter 1: Abstract Data Types. Introduces the concept of abstract data types

(ADTs) for both simple types, those containing individual data ﬁelds, and the more

complex types, those containing data structures. ADTs are presented in terms

of their deﬁnition, use, and implementation. After discussing the importance of

abstraction, we deﬁne several ADTs and then show how a well-deﬁned ADT can

be used without knowing how its actually implemented. The focus then turns to

the implementation of the ADTs with an emphasis placed on the importance of

selecting an appropriate data structure. The chapter includes an introduction to

the Python iterator mechanism and provides an example of a user-deﬁned iterator

for use with a container type ADT.

Chapter 2: Arrays. Introduces the student to the array structure, which is im-

portant since Python only provides the list structure and students are unlikely to

have seen the concept of the array as a ﬁxed-sized structure in a ﬁrst course using

Python. We deﬁne an ADT for a one-dimensional array and implement it using a

hardware array provided through a special mechanism of the C-implemented ver-

sion of Python. The two-dimensional array is also introduced and implemented

using a 1-D array of arrays. The array structures will be used throughout the text

in place of the Python’s list when it is the appropriate choice. The implementa-

tion of the list structure provided by Python is presented to show how the various

operations are implemented using a 1-D array. The Matrix ADT is introduced and

includes an implementation using a two-dimensional array that exposes the stu-

dents to an example of an ADT that is best implemented using a structure other

than the list or dictionary.

Chapter 3: Sets and Maps. This chapter reintroduces the students to both

the Set and Map (or dictionary) ADTs with which they are likely to be familiar

from their ﬁrst programming course using Python. Even though Python provides

these ADTs, they both provide great examples of abstract data types that can be

implemented in many diﬀerent ways. The chapter also continues the discussion of

arrays from the previous chapter by introducing multi-dimensional arrays (those

of two or more dimensions) along with the concept of physically storing these

using a one-dimensional array in either row-major or column-major order. The

chapter concludes with an example application that can beneﬁt from the use of a

three-dimensional array.

Chapter 4: Algorithm Analysis. Introduces the basic concept and importance

of complexity analysis by evaluating the operations of Python’s list structure and

the Set ADT as implemented in the previous chapter. This information will be used

to provide a more eﬃcient implementation of the Set ADT in the following chapter.

The chapter concludes by introducing the Sparse Matrix ADT and providing a more

eﬃcient implementation with the use of a list in place of a two-dimensional array.

xvi PREFACE

Chapter 5: Searching and Sorting. Introduces the concepts of searching and

sorting and illustrates how the eﬃciency of some ADTs can be improved when

working with sorted sequences. Search operations for an unsorted sequence are

discussed and the binary search algorithm is introduced as a way of improving this

operation. Three of the basic sorting algorithms are also introduced to further

illustrate the use of algorithm analysis. A new implementation of the Set ADT is

provided to show how diﬀerent data structures or data organizations can change

the eﬃciency of an ADT.

Chapter 6: Linked Structures. Provides an introduction to dynamic structures

by illustrating the construction and use of the singly linked list using dynamic

storage allocation. The common operations — traversal, searching, insertion, and

deletion — are presented as is the use of a tail reference when appropriate. Several

of the ADTs presented in earlier chapters are reimplemented using the singly linked

list, and the run times of their operations are compared to the earlier versions.

A new implementation of the Sparse Matrix is especially eye-opening to many

students as it uses an array of sorted linked lists instead of a single Python list as

was done in an earlier chapter.

Chapter 7: Stacks. Introduces the Stack ADT and includes implementations

using both a Python list and a linked list. Several common stack applications

are then presented, including balanced delimiter veriﬁcation and the evaluation of

postﬁx expressions. The concept of backtracking is also introduced as part of the

application for solving a maze. A detailed discussion is provided in designing a

solution and a partial implementation.

Chapter 8: Queues. Introduces the Queue ADT and includes three diﬀerent

implementations: Python list, circular array, and linked list. The priority queue

is introduced to provide an opportunity to discuss diﬀerent structures and data

organization for an eﬃcient implementation. The application of the queue presents

the concept of discrete event computer simulations using an airline ticket counter

as the example.

Chapter 9: Advanced Linked Lists. Continues the discussion of dynamic struc-

tures by introducing a collection of more advanced linked lists. These include the

doubly linked, circularly linked, and multi linked lists. The latter provides an

example of a linked structure containing multiple chains and is applied by reimple-

menting the Sparse Matrix to use two arrays of linked lists, one for the rows and

one for the columns. The doubly linked list is applied to the problem of designing

and implementing an Edit Buﬀer ADT for use with a basic text editor.

Chapter 10: Recursion. Introduces the use of recursion to solve various pro-

gramming problems. The properties of creating recursive functions are presented

along with common examples, including factorial, greatest common divisor, and

the Towers of Hanoi. The concept of backtracking is revisited to use recursion for

solving the eight-queens problem.

PREFACE xvii

Chapter 11: Hash Tables. Introduces the concept of hashing and the use of hash

tables for performing fast searches. Diﬀerent addressing techniques are presented,

including those for both closed and open addressing. Collision resolution techniques

and hash function design are also discussed. The magic behind Python’s dictionary

structure, which uses a hash table, is exposed and its eﬃciency evaluated.

Chapter 12: Advanced Sorting. Continues the discussion of the sorting problem

by introducing the recursive sorting algorithms—merge sort and quick sort—along

with the radix distribution sort algorithm, all of which can be used to sort se-

quences. Some of the common techniques for sorting linked lists are also presented.

Chapter 13: Binary Trees. Presents the tree structure and the general binary

tree speciﬁcally. The construction and use of the binary tree is presented along

with various properties and the various traversal operations. The binary tree is

used to build and evaluate arithmetic expressions and in decoding Morse Code

sequences. The tree-based heap structure is also introduced along with its use in

implementing a priority queue and the heapsort algorithm.

Chapter 14: Search Trees. Continues the discussion from the previous chapter

by using the tree structure to solve the search problem. The basic binary search

tree and the balanced binary search tree (AVL) are both introduced along with

new implementations of the Map ADT. Finally, a brief introduction to the 2-3

multi-way tree is also provided, which shows an alternative to both the binary

search and AVL trees.

Appendix A: Python Review. Provides a review of the Python language and

concepts learned in the traditional ﬁrst course. The review includes a presentation

of the basic constructs and built-in data structures.

Appendix B: User-Deﬁned Modules. Describes the use of modules in creating

well structured programs. The diﬀerent approaches for importing modules is also

discussed along with the use of namespaces.

Appendix C: Exceptions. Provides a basic introduction to the use of exceptions

for handling and raising errors during program execution.

Appendix D: Classes. Introduces the basic concepts of object-oriented program-

ming, including encapsulation, inheritance, and polymorphism. The presentation

is divided into two main parts. The ﬁrst part presents the basic design and use

of classes for those instructors who use a “back to basics” approach in teaching

data structures. The second part brieﬂy explores the more advanced features of

inheritance and polymorphism for those instructors who typically include these

topics in their course.

剩余539页未读，继续阅读

haha875232

粉丝: 4
资源: 91

Python编程：数据结构与算法实战

Data Structures and Algorithms with Python

Data Structures and Algorithms With Python

Data Structures and Algorithms Using Python.pdf

Data Structures and Algorithms Using Python and C++

3Data Structures and Algorithms Using Python

Data Structures and Algorithms Using Python - 2011.pdf

Data Structures and Algorithms Using Python_algorithms_数据结构pytho

Problem Solving in Data Structures and Algorithms Using Python epub 0分

Problem Solving in Data Structures and Algorithms Using Python 无水印pdf 0分

Problem Solving in Data Structures and Algorithms Using C azw3

最新资源