sorting & linked lists
DESCRIPTION
presentationTRANSCRIPT
Sorting, Sorting, ADTs, ADTs,
Linked ListsLinked Lists
No New Material This Week
Lets write a practice program... make a personT struct with name, ID# make some functions: (make stubs first)
newPerson(personT *nu) – ask user for her info... swap(personT *a, personT *b); exchange contents isSorted(personT *a, personT *b)
TRUE if person 'a' is before 'b' alphabetically
Gather entries in an array. Can we sort it?
SortingSorting
SortSort = arrange data according to its values
Closely related to the search problem. Example:
arrange numbers in largest-to-smallest order arrange names in alphabetical order arrange structstructs based on a 'key' field
(e.g. the .name.name field of the workerTworkerT structure we used in binary search)
SortingSorting
Many sorting algorithms; We will discuss only two simple methods: selection sort insertion sort
Demonstrate sorting items in arrays BUT sorts within dynamically-allocated memory are far more common.
Selection SortSelection SortCore Idea: Core Idea:
1.1. FindFind the item in list that shouldshould be first, How? for small-to-large ordering? large-to-
small?
2.2. SwapSwap it with the actualactual first item in the list remember the swap function? How did it work?
3.3. MoveMove a ‘wall’ or marker to separate the list into sorted and unsorted parts
4.4. RepeatRepeat on the unsorted part of the list untiluntil it disappears
Selection SortSelection Sort
1)1) FindFind smallest item in unsorted part of list
2)2) SwapSwap it with first item in the unsorted part of the list
3)3) MoveMove the ‘wall’ forward by one item, past sorted item
4)4) RepeatRepeat until the unsorted part of the list vanishes
Example: Example: small-to-large sortsmall-to-large sort
00
Selection Selection sortsort
Example: Example: small-to-large sortsmall-to-large sort
Selection Sort: Example Selection Sort: Example CodeCode
void SelSort(int lst[], int siz)void SelSort(int lst[], int siz){{int j, k, it, tmp;int j, k, it, tmp; /* sorted: 0/* sorted: 0jj
unsorted: j+1 unsorted: j+1siz-1siz-1 smallest unsorted: it smallest unsorted: it
*/*/
for(j=0; j<siz; j++)for(j=0; j<siz; j++) /* for all items on list *//* for all items on list */{{ it = j; it = j; /* (test item j first) *//* (test item j first) */ for(k=j+1; k<siz; k++) /* Search for min. item: */ for(k=j+1; k<siz; k++) /* Search for min. item: */ { { if(lst[k] < lst[it]) /*is ‘it’ smallest? */ if(lst[k] < lst[it]) /*is ‘it’ smallest? */ { { it = k; /* no—keep the smaller ‘k’ */ it = k; /* no—keep the smaller ‘k’ */ } } } /* Now ‘it’ is the smallest unsorted item. } /* Now ‘it’ is the smallest unsorted item. Swap ‘it’ and ‘j’ items*/ Swap ‘it’ and ‘j’ items*/ tmp = lst[j]; tmp = lst[j]; lst[j] = lst[it]; lst[j] = lst[it]; lst[it] = lst[tmp]; lst[it] = lst[tmp]; } }}}
Insertion SortInsertion Sort
Core Idea:Core Idea: As before, a ‘wall’‘wall’ separates list into sorted and
unsorted parts (sorted part is empty at first). 1)1) FindFind the 1st unsorted item (just past the ‘wall’)2)2) SearchSearch sorted list for 1st item’s proper position, 3)3) SwapSwap 1st item: Remove from the unsorted list,
and Insert into sorted list.4)4) RepeatRepeat until unsorted list is empty.
Insertion SortInsertion Sort
Rem
ove
Rem
oveIn
sert
Inse
rt
Insertion Insertion sortsortExampleExample
(1(1stst unsorted item unsorted itemis automatially theis automatially the 11stst sorted item) sorted item)
Abstract Data Types: Abstract Data Types: ADTADTss
(Recall) ‘data type’‘data type’ determines the set of all possible values for a variable.
Data types defined by C language syntax: basic data types: int, char, float, double derived data types: arrays, pointers, structs, and
their constructions (e.g. array of int, pointer to float)
But what is this ‘daisy chain’? it is made of dynamically-allocated structs and
pointers It is a data type defined by the way you use it, defined by the way you use it,
an
AAbstract bstract DData ata TTypeype (ADT)
Abstract Data Types: Abstract Data Types: ADTADTss
An ADT is defined by BOTH its structure, and a set of operations (functions) that control it.
Structure alone isn’t enough. EXAMPLE: Setting pointers properly is requiredrequired for this
‘daisy chain’ to work as sorted/unsorted list
kkcc ee ff ss vvgg qq
pBgnpBgn pEndpEndpSortEndpSortEnd
NULLNULL
ADTs: How to do itADTs: How to do it
The best ADTs are easy to use: The best ADTs are easy to use: they ‘hide the details’ from user with well-chosen functions and structures.
Users don’t want (or need) to know the Users don’t want (or need) to know the details;details; Give them simple ‘interface’ functions to do the needed tasks (e.g. void void insert(pHere,pThis); insert(pHere,pThis); void remove(pThis); void remove(pThis); )
Good strategy for large programming Good strategy for large programming projects:projects:If the function prototypes do not change, then(e.g. ‘the interface’, or .h.h file) then the function’s author can improve, repair, upgradeimprove, repair, upgrade it without changing any programs/code that use it!
ADTsADTs
ADT
Data structure
Operations
Interface UsersUsers(you, and other (you, and other project programmers)project programmers)
ADT ExamplesADT Examples
lists (sequential order, but easy insert/remove)
queues (first-come, first-served structures) stacks (last-in, first-out; like a stack of paper) dynamic sets (a collection of objects, no
ordering) graphs (trees, networks of connected nodes)‘Interface’ functions often include:
“create new item,” “delete/remove this item,” “get next item,” “push an item onto stack,” “pop an item off of the stack,” etc.
An ADT: Singly Linked ListAn ADT: Singly Linked List
A listlist is a sequential data collection without any intrinsic numbering. Does NOT require sequential memory locations Much more general, flexible than array
Each list item can have different type(!) CS Jargon: a ‘nodenode’ is an item on a linked list
kkcc ee ff ss vvgg qq
pBgnpBgn pEndpEndpSortEndpSortEnd
NULLNULL
ADT: Linked ListsADT: Linked Lists
What defines a linked list?What defines a linked list?
Nodes have pointers to ‘link’ them togetherin a linear, chain-like arrangement.
A list is linear : each node has exactly one ‘parent’ and exactly one ‘child’
Changing pointers makes a list dynamic: the number of nodes can change, AND the arrangement of nodes can change
ADT: Singly Linked ListsADT: Singly Linked Lists
Each node of a singly linked list contains: a node value (could be a complex struct struct...) a pointer to the next node.
The last node on the list points to NULL (tail).
We also need a pointer for the list start (head).
Singly linked lists are one-directional; must always move from head to tailhead 8 3 12 1 NULL
nodenode nodenode nodenode nodenode
ADT: Singly Linked ListsADT: Singly Linked Lists
How can we define a node structure? Simple Example:
typedef struct node typedef struct node
{{
struct node *pNext; struct node *pNext; /*Pointer-to-node*//*Pointer-to-node*/
int value;int value;
} nodeT;} nodeT;A little tricky here:A little tricky here:Recall: data type is Recall: data type is struct nodestruct node,,typedef renames it all as typedef renames it all as nodeTnodeT, , thus thus
member variable member variable pNextpNext is is a pointer-to-nodeT-type-objectsa pointer-to-nodeT-type-objects
ADT: Singly Linked ListsADT: Singly Linked Lists
Be sure you understand this:
typedef struct GoodNode typedef struct GoodNode
{{
struct GoodNode *pNext; struct GoodNode *pNext; /*Pointer-to-node*//*Pointer-to-node*/
int value;int value;
} nodeT;} nodeT;
typedef struct nodeT typedef struct nodeT
{{
nodeT *pNext; nodeT *pNext; /*Pointer-to-node*//*Pointer-to-node*/
int value;int value;
} nodeT;} nodeT;
This works!This works!
NO! THE NO! THE OBVIOUSOBVIOUS WAY DOESN’T WORK!WAY DOESN’T WORK!
Singly Linked ListsSingly Linked Lists
What does this program create?int main(void) int main(void)
{{
nodeT *pHead, *pNode1;nodeT *pHead, *pNode1;
pNode1 = (nodeT*)malloc(1*sizeof(nodeT));pNode1 = (nodeT*)malloc(1*sizeof(nodeT));
pNode1–>pNext = NULL;pNode1–>pNext = NULL;
pNode1–>value = 10;pNode1–>value = 10;
pHead = pNode1;pHead = pNode1;
return 0;return 0;
}} 10 NULLNULLpHeadpHead
ADT: Singly Linked ListsADT: Singly Linked Lists
Typical interface functions you will need to write for a singly linked list ADT:
insert - add an element to the list delete - remove an element from the list isEmpty - find out if the list is empty printList - traverse and display the list.
How would you write the ‘isEmpty’ function? The ‘insert’ function?
Singly Linked ListsSingly Linked Lists
To attach a newly-created nodea newly-created node at pNew pNew right after the pNow pNow
node: nextnext’ member of struct at pNewpNew
pNew–>pNext = pNow–>pNext;pNew–>pNext = pNow–>pNext;
Then point pNowpNow’s next member to pNewpNew.pNow–>next = pNew;pNow–>next = pNew;
8 12 1 NULL
10pNewpNew
pHeadpHead
pNowpNow
Singly Linked ListsSingly Linked Lists
To attach a newly-created nodea newly-created node at pNew pNew right after the pNow pNow
node: First set the `nextnext’ member of struct at pNewpNew
pNew–>pNext = pNow–>pNext;pNew–>pNext = pNow–>pNext;
Then point pNowpNow’s next member to pNewpNew.pNow–>next = pNew;pNow–>next = pNew;
8 12 1 NULL
10pNewpNew
pHeadpHead
pNowpNow
Singly Linked ListsSingly Linked Lists
To attach a newly-created nodea newly-created node at pNew pNew right after the pNow pNow node:
First set the `nextnext’ member of struct at pNewpNewpNew–>pNext = pNow–>pNext;pNew–>pNext = pNow–>pNext;
Then point pNowpNow’s next member to pNewpNew.pNow–>next = pNew;pNow–>next = pNew;
8 12 1 NULL
10pNewpNew
pHeadpHead
pNowpNow