Yang Hu - Graphic Go Algorithms: Graphically learn data structures and algorithms better than before

Graphic Go Algorithms: Graphically learn data structures and algorithms better than before — read online for free the complete book (whole text) full work

Below is the text of the book, divided by pages. System saving the place of the last page read, allows you to conveniently read the book "Graphic Go Algorithms: Graphically learn data structures and algorithms better than before" online for free, without having to search again every time where you left off. Put a bookmark, and you can go to the page where you finished reading at any time.

Light

Font size:

↓

↑

Georgia Tahoma Arial Verdana

Reset

Interval:

↓

↑

Bookmark:

Make

1234567...16

Graphic Go Algorithms

YANG HU

The complexity of life, because they do not understand to simplify the complex, simple is the beginning of wisdom. From the essence of practice,this book to briefly explain the concept and vividly cultivate programming interest, you will learn it easy and fast.

http://en.verejava.com

Copyright 2020 Yang Hu

All rights reserved.

ISBN : 9798655038363

CONTENTS

.

.

.

.

.

14.1

14.2

14.3

14.4

15.1

15.2

15.3

15.4

16.1

16.2

16.3

17.1

17.2

17.3

23.1

23.2

23.3

23.4

23.5

23.6

26.1

26.2

26.3

.

.

.

.

.

.

.

Linear Table Definition

Linear Table:

Sequence of elements, is a one-dimensional array.

. Define a one-dimensional array of student scores

TestOneArray.go

package main import "fmt" func main() { var scores = [] int { , , , , , } var length = len (scores) for i := ; i < length; i++ { fmt.Printf( "%d," , scores[i]) } }

Result:

90,70,50,80,60,85,

Maximum Value

Maximum of Integer Sequences:

. Algorithmic ideas

Compare arrays[i] with arrays[i + 1] , if arrays[i] > arrays[i + 1] are exchanged. So continue until the last number, arrays[length - 1] is the maximum.

TestMaxValue.go

package main import "fmt" func max(arrays [] int , length int ) int { for i := ; i < length- ; i++ { if arrays[i] > arrays[i+ ] { // swap var temp = arrays[i] arrays[i] = arrays[i+ ] arrays[i+ ] = temp } } var maxValue = arrays[length- ] return maxValue } func main() { var scores = [] int { , , , , } var length = len (scores) var maxValue = max(scores, length) fmt.Printf( "Max Value = %d\n" , maxValue) }

Result:

Max Value = 95

Bubble Sorting Algorithm

Bubble Sorting Algorithm:

Compare arrays[j] with arrays[j + 1] , if arrays[j] > arrays[j + 1] are exchanged.

Remaining elements repeat this process, until sorting is completed.

Sort the following numbers from small to large

Explanation:

No sorting,

Comparing,

Already sorted

. First sorting:

. Second sorting:

. Third sorting:

No swap so terminate sorting : we can get the sorting numbers from small to large

TestBubbleSort.go

package main import "fmt" func main() { // index starts from var scores = [] int { , , , , , } var length = len (scores) sort(scores, length) for i := ; i < length; i++ { fmt.Printf( "%d," , scores[i]) } } func sort(arrays [] int , length int ) { for i := ; i < length- ; i++ { for j := ; j < length-i- ; j++ { if arrays[j] > arrays[j+ ] { //swap var flag = arrays[j] arrays[j] = arrays[j+ ] arrays[j+ ] = flag } } } }

Result:

50,60,70,80,85,90,

Minimum Value

Search the Minimum of Integer Sequences:

. Algorithmic ideas

Initial value minIndex=0, j=1 Compare arrays[minIndex] with arrays[j]

if arrays[minIndex] > arrays[j] then minIndex=j, j++ else j++. continue until the last number, arrays[minIndex] is the Min Value.

TestMinValue.go

package main import "fmt" func min(arrays [] int , length int ) int { var minIndex = // the index of the minimum for j := ; j < length; j++ { if arrays[minIndex] > arrays[j] { minIndex = j } } return arrays[minIndex] } func main() { var scores = [] int { , , , , } var length = len (scores) var minValue = min(scores, length) fmt.Printf( "Min Value = %d\n" , minValue) }

Result:

Min Value = 50

Select Sorting Algorithm

Select Sorting Algorithm:

Sorts an array by repeatedly finding the minimum element from unsorted part and putting it at the beginning.

Sort the following numbers from small to large

Explanation:

No sorting,

Comparing,

Already sorted.

Next page

1234567...16

Light

Font size:

↓

↑

Georgia Tahoma Arial Verdana

Reset

Interval:

↓

↑

Bookmark:

Make

Similar books «Graphic Go Algorithms: Graphically learn data structures and algorithms better than before»

Look at similar books to Graphic Go Algorithms: Graphically learn data structures and algorithms better than before. We have selected literature similar in name and meaning in the hope of providing readers with more options to find new, interesting, not yet read works.

Yang Hu

Graphic JavaScript Algorithms: Graphic learn Data Structure and Algorithm for JavaScript

K. Erciyes

Algebraic Graph Algorithms: A Practical Guide Using Python (Undergraduate Topics in Computer Science)

Gabriel Valiente

Algorithms on Trees and Graphs: With Python Code

Mahmoud Parsian

Data Algorithms with Spark: Recipes and Design Patterns for Scaling Up using PySpark

John Paul Mueller

Algorithms For Dummies

Amy E. Hodler

Graph Algorithms: Neo4j version

Amy E. Hodler

Graph Algorithms

James Cutajar [James Cutajar]

Beginning Java Data Structures and Algorithms

K Erciyes

Guide to Graph Algorithms Sequential, Parallel and Distributed

Wisnu Anggoro

C# Data Structures and Algorithms

Michael McMillan

Data Structures and Algorithms with JavaScript

Robert Sedgewick

Algorithms in C++ Part 5: Graph Algorithms

Discussion, reviews of the book Graphic Go Algorithms: Graphically learn data structures and algorithms better than before and just readers' own opinions. Leave your comments, write what you think about the work, its meaning or the main characters. Specify what exactly you liked and what you didn't like, and why you think so.